# Generated from CPP14Parser.g4 by ANTLR 4.11.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,149,2120,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,
        7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
        2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
        7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,
        2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,
        7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,
        2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,
        7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191,
        1,0,3,0,386,8,0,1,0,1,0,1,1,4,1,391,8,1,11,1,12,1,392,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,3,1,402,8,1,1,2,1,2,3,2,406,8,2,1,3,1,3,1,3,1,
        3,1,3,1,3,1,3,3,3,415,8,3,1,3,3,3,418,8,3,1,4,1,4,3,4,422,8,4,1,
        4,1,4,1,5,1,5,1,5,1,5,3,5,430,8,5,1,5,1,5,1,5,1,5,1,5,3,5,437,8,
        5,1,5,3,5,440,8,5,1,5,5,5,443,8,5,10,5,12,5,446,9,5,1,6,1,6,3,6,
        450,8,6,1,6,1,6,1,7,1,7,3,7,456,8,7,1,7,1,7,1,8,1,8,1,8,1,8,3,8,
        464,8,8,3,8,466,8,8,1,9,1,9,1,10,1,10,1,10,5,10,473,8,10,10,10,12,
        10,476,9,10,1,10,3,10,479,8,10,1,11,1,11,3,11,483,8,11,1,12,3,12,
        486,8,12,1,12,1,12,3,12,490,8,12,1,13,3,13,493,8,13,1,13,1,13,1,
        13,1,14,1,14,3,14,500,8,14,1,14,1,14,3,14,504,8,14,1,14,3,14,507,
        8,14,1,14,3,14,510,8,14,1,14,3,14,513,8,14,1,15,1,15,1,15,1,15,3,
        15,519,8,15,1,15,1,15,3,15,523,8,15,1,15,1,15,3,15,527,8,15,1,15,
        1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,541,
        8,15,1,15,1,15,3,15,545,8,15,1,15,1,15,1,15,1,15,3,15,551,8,15,1,
        15,1,15,1,15,1,15,1,15,3,15,558,8,15,1,15,1,15,1,15,1,15,3,15,564,
        8,15,1,15,1,15,3,15,568,8,15,1,15,1,15,5,15,572,8,15,10,15,12,15,
        575,9,15,1,16,1,16,1,17,1,17,1,18,3,18,582,8,18,1,18,1,18,1,18,3,
        18,587,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
        18,3,18,600,8,18,1,19,1,19,1,19,1,19,1,19,3,19,607,8,19,1,19,1,19,
        1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,619,8,19,1,19,1,19,
        1,19,1,19,1,19,1,19,1,19,1,19,3,19,629,8,19,1,20,1,20,1,21,3,21,
        634,8,21,1,21,1,21,3,21,638,8,21,1,21,1,21,1,21,1,21,1,21,3,21,645,
        8,21,1,21,3,21,648,8,21,1,22,1,22,1,22,1,22,1,23,1,23,3,23,656,8,
        23,1,24,1,24,3,24,660,8,24,1,24,3,24,663,8,24,1,25,1,25,1,25,1,25,
        1,25,3,25,670,8,25,1,25,1,25,1,25,1,25,1,25,3,25,677,8,25,5,25,679,
        8,25,10,25,12,25,682,9,25,1,26,1,26,3,26,686,8,26,1,26,1,26,3,26,
        690,8,26,1,27,3,27,693,8,27,1,27,1,27,1,27,3,27,698,8,27,1,27,1,
        27,1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,3,29,713,
        8,29,1,30,1,30,1,30,5,30,718,8,30,10,30,12,30,721,9,30,1,31,1,31,
        1,31,5,31,726,8,31,10,31,12,31,729,9,31,1,32,1,32,1,32,5,32,734,
        8,32,10,32,12,32,737,9,32,1,33,1,33,1,33,1,33,5,33,743,8,33,10,33,
        12,33,746,9,33,1,34,1,34,1,34,1,34,3,34,752,8,34,1,35,1,35,1,35,
        5,35,757,8,35,10,35,12,35,760,9,35,1,36,1,36,1,36,5,36,765,8,36,
        10,36,12,36,768,9,36,1,37,1,37,1,37,5,37,773,8,37,10,37,12,37,776,
        9,37,1,38,1,38,1,38,5,38,781,8,38,10,38,12,38,784,9,38,1,39,1,39,
        1,39,5,39,789,8,39,10,39,12,39,792,9,39,1,40,1,40,1,40,5,40,797,
        8,40,10,40,12,40,800,9,40,1,41,1,41,1,41,5,41,805,8,41,10,41,12,
        41,808,9,41,1,42,1,42,1,42,1,42,1,42,1,42,3,42,816,8,42,1,43,1,43,
        1,43,1,43,1,43,1,43,3,43,824,8,43,1,44,1,44,1,45,1,45,1,45,5,45,
        831,8,45,10,45,12,45,834,9,45,1,46,1,46,1,47,1,47,1,47,3,47,841,
        8,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,849,8,47,3,47,851,8,47,1,
        48,3,48,854,8,48,1,48,1,48,1,48,1,48,3,48,860,8,48,1,48,1,48,1,48,
        1,49,3,49,866,8,49,1,49,1,49,1,50,1,50,3,50,872,8,50,1,50,1,50,1,
        51,4,51,877,8,51,11,51,12,51,878,1,52,1,52,1,52,1,52,1,52,1,52,1,
        52,3,52,888,8,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,896,8,52,1,53,
        1,53,3,53,900,8,53,1,53,1,53,1,53,1,53,1,53,3,53,907,8,53,3,53,909,
        8,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,
        1,54,1,54,1,54,1,54,1,54,1,54,3,54,929,8,54,1,54,1,54,3,54,933,8,
        54,1,54,1,54,1,54,1,54,3,54,939,8,54,1,54,1,54,1,54,3,54,944,8,54,
        1,55,1,55,3,55,948,8,55,1,56,3,56,951,8,56,1,56,1,56,1,56,1,57,1,
        57,3,57,958,8,57,1,58,1,58,1,58,1,58,1,58,3,58,965,8,58,1,58,1,58,
        3,58,969,8,58,1,58,1,58,1,59,1,59,1,60,4,60,976,8,60,11,60,12,60,
        977,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,990,8,
        61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,1000,8,62,1,63,1,
        63,1,63,3,63,1005,8,63,1,63,1,63,1,63,1,63,1,64,3,64,1012,8,64,1,
        64,3,64,1015,8,64,1,64,1,64,1,64,3,64,1020,8,64,1,64,1,64,1,64,3,
        64,1025,8,64,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,
        67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1046,8,68,1,69,4,
        69,1049,8,69,11,69,12,69,1050,1,69,3,69,1054,8,69,1,70,1,70,1,71,
        1,71,1,72,1,72,1,73,1,73,1,73,3,73,1065,8,73,1,74,1,74,1,74,1,74,
        3,74,1071,8,74,1,75,4,75,1074,8,75,11,75,12,75,1075,1,75,3,75,1079,
        8,75,1,76,4,76,1082,8,76,11,76,12,76,1083,1,76,3,76,1087,8,76,1,
        77,1,77,1,78,1,78,1,79,3,79,1094,8,79,1,79,1,79,1,79,1,79,1,79,1,
        79,1,79,3,79,1103,8,79,1,79,4,79,1106,8,79,11,79,12,79,1107,1,79,
        3,79,1111,8,79,1,79,1,79,3,79,1115,8,79,1,79,1,79,3,79,1119,8,79,
        1,79,1,79,3,79,1123,8,79,1,79,1,79,1,79,3,79,1128,8,79,1,79,5,79,
        1131,8,79,10,79,12,79,1134,9,79,1,79,1,79,1,79,3,79,1139,8,79,1,
        79,1,79,1,79,1,79,3,79,1145,8,79,1,80,1,80,1,80,1,80,3,80,1151,8,
        80,1,81,1,81,1,81,1,81,3,81,1157,8,81,1,81,1,81,1,82,1,82,3,82,1163,
        8,82,1,82,3,82,1166,8,82,1,82,1,82,1,82,1,82,3,82,1172,8,82,1,82,
        1,82,3,82,1176,8,82,1,82,1,82,3,82,1180,8,82,1,82,3,82,1183,8,82,
        1,83,1,83,1,84,1,84,1,84,1,84,3,84,1191,8,84,3,84,1193,8,84,1,84,
        1,84,1,85,1,85,3,85,1199,8,85,1,85,3,85,1202,8,85,1,85,3,85,1205,
        8,85,1,85,3,85,1208,8,85,1,86,1,86,3,86,1212,8,86,1,86,1,86,3,86,
        1216,8,86,1,86,1,86,1,87,1,87,3,87,1222,8,87,1,88,1,88,1,88,1,89,
        1,89,1,89,5,89,1230,8,89,10,89,12,89,1233,9,89,1,90,1,90,1,90,3,
        90,1238,8,90,1,91,1,91,1,92,1,92,3,92,1244,8,92,1,93,1,93,1,94,3,
        94,1249,8,94,1,94,1,94,1,94,3,94,1254,8,94,1,94,1,94,3,94,1258,8,
        94,1,94,1,94,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96,1,97,3,97,1271,
        8,97,1,97,1,97,1,98,1,98,3,98,1277,8,98,1,98,1,98,3,98,1281,8,98,
        1,98,1,98,1,98,1,99,3,99,1287,8,99,1,99,1,99,1,99,3,99,1292,8,99,
        1,99,1,99,1,99,1,100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,
        101,1,101,3,101,1307,8,101,1,101,1,101,3,101,1311,8,101,1,102,4,
        102,1314,8,102,11,102,12,102,1315,1,103,1,103,1,103,3,103,1321,8,
        103,1,103,1,103,1,103,3,103,1326,8,103,1,104,1,104,1,104,1,104,3,
        104,1332,8,104,1,104,3,104,1335,8,104,1,104,1,104,1,105,1,105,1,
        105,5,105,1342,8,105,10,105,12,105,1345,9,105,1,105,3,105,1348,8,
        105,1,106,1,106,1,106,3,106,1353,8,106,1,106,1,106,3,106,1357,8,
        106,1,107,1,107,1,108,1,108,3,108,1363,8,108,1,108,1,108,1,109,4,
        109,1368,8,109,11,109,12,109,1369,1,110,1,110,1,110,1,110,1,110,
        1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,4,110,1385,8,110,
        11,110,12,110,1386,3,110,1389,8,110,1,111,1,111,1,111,5,111,1394,
        8,111,10,111,12,111,1397,9,111,1,112,1,112,3,112,1401,8,112,1,113,
        1,113,1,113,1,113,1,113,3,113,1408,8,113,1,114,1,114,3,114,1412,
        8,114,5,114,1414,8,114,10,114,12,114,1417,9,114,1,114,1,114,1,115,
        1,115,1,115,3,115,1424,8,115,1,115,1,115,1,115,1,115,3,115,1430,
        8,115,1,115,1,115,1,115,1,115,3,115,1436,8,115,1,115,1,115,3,115,
        1440,8,115,3,115,1442,8,115,5,115,1444,8,115,10,115,12,115,1447,
        9,115,1,116,1,116,3,116,1451,8,116,1,116,1,116,3,116,1455,8,116,
        1,116,3,116,1458,8,116,1,116,3,116,1461,8,116,1,116,3,116,1464,8,
        116,1,117,1,117,1,117,3,117,1469,8,117,1,118,1,118,3,118,1473,8,
        118,1,118,3,118,1476,8,118,1,118,1,118,3,118,1480,8,118,1,118,3,
        118,1483,8,118,3,118,1485,8,118,1,119,4,119,1488,8,119,11,119,12,
        119,1489,1,120,1,120,1,121,1,121,1,122,3,122,1497,8,122,1,122,1,
        122,1,123,1,123,3,123,1503,8,123,1,124,1,124,3,124,1507,8,124,1,
        124,1,124,1,124,1,124,3,124,1513,8,124,1,125,1,125,4,125,1517,8,
        125,11,125,12,125,1518,1,125,3,125,1522,8,125,3,125,1524,8,125,1,
        126,1,126,1,126,1,126,3,126,1530,8,126,1,126,1,126,3,126,1534,8,
        126,1,126,1,126,1,126,1,126,3,126,1540,8,126,1,126,1,126,1,126,1,
        126,1,126,3,126,1547,8,126,1,126,1,126,3,126,1551,8,126,3,126,1553,
        8,126,5,126,1555,8,126,10,126,12,126,1558,9,126,1,127,5,127,1561,
        8,127,10,127,12,127,1564,9,127,1,127,1,127,1,128,1,128,1,128,1,128,
        1,128,1,128,1,128,3,128,1575,8,128,1,128,1,128,3,128,1579,8,128,
        3,128,1581,8,128,5,128,1583,8,128,10,128,12,128,1586,9,128,1,129,
        1,129,3,129,1590,8,129,1,129,3,129,1593,8,129,1,130,1,130,1,130,
        5,130,1598,8,130,10,130,12,130,1601,9,130,1,131,3,131,1604,8,131,
        1,131,1,131,1,131,3,131,1609,8,131,3,131,1611,8,131,1,131,1,131,
        3,131,1615,8,131,1,132,3,132,1618,8,132,1,132,3,132,1621,8,132,1,
        132,1,132,3,132,1625,8,132,1,132,1,132,1,133,3,133,1630,8,133,1,
        133,1,133,1,133,1,133,1,133,3,133,1637,8,133,1,134,1,134,1,134,1,
        134,1,134,3,134,1644,8,134,1,135,1,135,1,135,3,135,1649,8,135,1,
        136,1,136,3,136,1653,8,136,1,137,1,137,3,137,1657,8,137,1,137,1,
        137,1,137,3,137,1662,8,137,5,137,1664,8,137,10,137,12,137,1667,9,
        137,1,138,1,138,1,138,3,138,1672,8,138,3,138,1674,8,138,1,138,1,
        138,1,139,1,139,3,139,1680,8,139,1,140,1,140,1,140,3,140,1685,8,
        140,1,140,1,140,1,141,1,141,3,141,1691,8,141,1,141,1,141,3,141,1695,
        8,141,3,141,1697,8,141,1,141,3,141,1700,8,141,1,141,1,141,3,141,
        1704,8,141,1,141,1,141,3,141,1708,8,141,3,141,1710,8,141,3,141,1712,
        8,141,1,142,3,142,1715,8,142,1,142,1,142,1,143,1,143,1,144,1,144,
        1,145,1,145,1,145,1,145,4,145,1727,8,145,11,145,12,145,1728,1,146,
        3,146,1732,8,146,1,146,3,146,1735,8,146,1,146,3,146,1738,8,146,1,
        146,1,146,1,146,1,146,1,146,1,146,1,146,3,146,1747,8,146,1,147,1,
        147,1,147,5,147,1752,8,147,10,147,12,147,1755,9,147,1,148,1,148,
        3,148,1759,8,148,1,148,3,148,1762,8,148,1,148,3,148,1765,8,148,3,
        148,1767,8,148,1,148,3,148,1770,8,148,1,148,3,148,1773,8,148,1,148,
        1,148,3,148,1777,8,148,1,149,4,149,1780,8,149,11,149,12,149,1781,
        1,150,1,150,1,151,1,151,1,151,1,152,1,152,1,152,1,153,1,153,3,153,
        1794,8,153,1,153,1,153,1,153,3,153,1799,8,153,5,153,1801,8,153,10,
        153,12,153,1804,9,153,1,154,3,154,1807,8,154,1,154,1,154,1,154,3,
        154,1812,8,154,1,154,1,154,1,154,3,154,1817,8,154,1,154,1,154,3,
        154,1821,8,154,1,155,3,155,1824,8,155,1,155,1,155,3,155,1828,8,155,
        1,156,1,156,1,157,1,157,1,158,1,158,1,158,1,159,1,159,3,159,1839,
        8,159,1,160,1,160,3,160,1843,8,160,1,161,1,161,1,161,1,162,1,162,
        3,162,1850,8,162,1,162,1,162,1,162,3,162,1855,8,162,5,162,1857,8,
        162,10,162,12,162,1860,9,162,1,163,1,163,1,163,3,163,1865,8,163,
        1,163,1,163,3,163,1869,8,163,1,164,1,164,3,164,1873,8,164,1,165,
        1,165,1,165,1,166,1,166,1,166,1,166,3,166,1882,8,166,1,167,1,167,
        1,167,1,167,1,167,1,167,1,168,1,168,1,168,5,168,1893,8,168,10,168,
        12,168,1896,9,168,1,169,1,169,3,169,1900,8,169,1,170,1,170,1,170,
        1,170,1,170,3,170,1907,8,170,1,170,1,170,3,170,1911,8,170,1,170,
        3,170,1914,8,170,1,170,3,170,1917,8,170,1,170,3,170,1920,8,170,1,
        170,1,170,3,170,1924,8,170,1,171,1,171,1,171,3,171,1929,8,171,1,
        171,1,171,1,172,1,172,1,172,3,172,1936,8,172,1,172,1,172,3,172,1940,
        8,172,1,172,1,172,3,172,1944,8,172,1,173,1,173,1,174,1,174,3,174,
        1950,8,174,1,174,1,174,1,174,3,174,1955,8,174,5,174,1957,8,174,10,
        174,12,174,1960,9,174,1,175,1,175,1,175,3,175,1965,8,175,1,176,1,
        176,1,176,1,176,3,176,1971,8,176,1,176,3,176,1974,8,176,1,177,3,
        177,1977,8,177,1,177,1,177,1,177,1,178,1,178,1,178,1,178,1,178,1,
        179,1,179,1,179,1,179,1,180,1,180,3,180,1993,8,180,1,180,1,180,1,
        180,1,181,4,181,1999,8,181,11,181,12,181,2000,1,182,1,182,1,182,
        1,182,1,182,1,182,1,183,3,183,2010,8,183,1,183,1,183,1,183,3,183,
        2015,8,183,1,183,3,183,2018,8,183,1,184,1,184,3,184,2022,8,184,1,
        185,1,185,3,185,2026,8,185,1,186,1,186,1,186,3,186,2031,8,186,1,
        186,1,186,1,187,1,187,3,187,2037,8,187,1,187,1,187,1,187,3,187,2042,
        8,187,5,187,2044,8,187,10,187,12,187,2047,9,187,1,188,1,188,1,188,
        1,188,1,188,1,188,3,188,2055,8,188,1,189,1,189,1,189,1,189,3,189,
        2061,8,189,1,189,1,189,1,190,1,190,1,190,3,190,2068,8,190,1,190,
        1,190,1,190,3,190,2073,8,190,1,190,1,190,1,190,1,190,1,190,1,190,
        1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,
        1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,
        1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,1,190,
        1,190,1,190,3,190,2116,8,190,1,191,1,191,1,191,1,1050,6,10,30,50,
        230,252,256,192,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,
        36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,
        80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,
        118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,
        150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,
        182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212,
        214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,
        246,248,250,252,254,256,258,260,262,264,266,268,270,272,274,276,
        278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,308,
        310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,340,
        342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372,
        374,376,378,380,382,0,23,2,0,100,100,104,104,4,0,25,25,33,33,60,
        60,67,67,2,0,127,127,132,132,1,0,123,124,2,0,94,96,100,103,2,0,126,
        126,133,133,1,0,96,98,1,0,94,95,2,0,105,106,119,120,1,0,117,118,
        2,0,104,104,107,116,5,0,38,38,49,49,59,59,65,65,72,72,3,0,36,36,
        46,46,83,83,2,0,48,48,62,62,2,0,63,63,81,81,2,0,22,22,68,68,1,0,
        88,93,2,0,100,100,121,121,2,0,23,23,85,85,2,0,28,28,30,30,2,0,40,
        40,55,55,1,0,56,58,1,0,1,7,2354,0,385,1,0,0,0,2,401,1,0,0,0,4,405,
        1,0,0,0,6,417,1,0,0,0,8,419,1,0,0,0,10,425,1,0,0,0,12,447,1,0,0,
        0,14,453,1,0,0,0,16,465,1,0,0,0,18,467,1,0,0,0,20,469,1,0,0,0,22,
        482,1,0,0,0,24,489,1,0,0,0,26,492,1,0,0,0,28,497,1,0,0,0,30,544,
        1,0,0,0,32,576,1,0,0,0,34,578,1,0,0,0,36,599,1,0,0,0,38,628,1,0,
        0,0,40,630,1,0,0,0,42,633,1,0,0,0,44,649,1,0,0,0,46,653,1,0,0,0,
        48,662,1,0,0,0,50,664,1,0,0,0,52,689,1,0,0,0,54,692,1,0,0,0,56,701,
        1,0,0,0,58,712,1,0,0,0,60,714,1,0,0,0,62,722,1,0,0,0,64,730,1,0,
        0,0,66,738,1,0,0,0,68,751,1,0,0,0,70,753,1,0,0,0,72,761,1,0,0,0,
        74,769,1,0,0,0,76,777,1,0,0,0,78,785,1,0,0,0,80,793,1,0,0,0,82,801,
        1,0,0,0,84,809,1,0,0,0,86,823,1,0,0,0,88,825,1,0,0,0,90,827,1,0,
        0,0,92,835,1,0,0,0,94,850,1,0,0,0,96,853,1,0,0,0,98,865,1,0,0,0,
        100,869,1,0,0,0,102,876,1,0,0,0,104,895,1,0,0,0,106,908,1,0,0,0,
        108,943,1,0,0,0,110,947,1,0,0,0,112,950,1,0,0,0,114,957,1,0,0,0,
        116,968,1,0,0,0,118,972,1,0,0,0,120,975,1,0,0,0,122,989,1,0,0,0,
        124,999,1,0,0,0,126,1001,1,0,0,0,128,1024,1,0,0,0,130,1026,1,0,0,
        0,132,1034,1,0,0,0,134,1036,1,0,0,0,136,1045,1,0,0,0,138,1048,1,
        0,0,0,140,1055,1,0,0,0,142,1057,1,0,0,0,144,1059,1,0,0,0,146,1064,
        1,0,0,0,148,1070,1,0,0,0,150,1073,1,0,0,0,152,1081,1,0,0,0,154,1088,
        1,0,0,0,156,1090,1,0,0,0,158,1144,1,0,0,0,160,1150,1,0,0,0,162,1152,
        1,0,0,0,164,1182,1,0,0,0,166,1184,1,0,0,0,168,1186,1,0,0,0,170,1196,
        1,0,0,0,172,1209,1,0,0,0,174,1219,1,0,0,0,176,1223,1,0,0,0,178,1226,
        1,0,0,0,180,1234,1,0,0,0,182,1239,1,0,0,0,184,1243,1,0,0,0,186,1245,
        1,0,0,0,188,1248,1,0,0,0,190,1261,1,0,0,0,192,1263,1,0,0,0,194,1270,
        1,0,0,0,196,1274,1,0,0,0,198,1286,1,0,0,0,200,1296,1,0,0,0,202,1302,
        1,0,0,0,204,1313,1,0,0,0,206,1325,1,0,0,0,208,1327,1,0,0,0,210,1338,
        1,0,0,0,212,1352,1,0,0,0,214,1358,1,0,0,0,216,1360,1,0,0,0,218,1367,
        1,0,0,0,220,1388,1,0,0,0,222,1390,1,0,0,0,224,1398,1,0,0,0,226,1407,
        1,0,0,0,228,1415,1,0,0,0,230,1429,1,0,0,0,232,1448,1,0,0,0,234,1465,
        1,0,0,0,236,1484,1,0,0,0,238,1487,1,0,0,0,240,1491,1,0,0,0,242,1493,
        1,0,0,0,244,1496,1,0,0,0,246,1500,1,0,0,0,248,1512,1,0,0,0,250,1523,
        1,0,0,0,252,1539,1,0,0,0,254,1562,1,0,0,0,256,1567,1,0,0,0,258,1587,
        1,0,0,0,260,1594,1,0,0,0,262,1603,1,0,0,0,264,1617,1,0,0,0,266,1636,
        1,0,0,0,268,1643,1,0,0,0,270,1648,1,0,0,0,272,1652,1,0,0,0,274,1654,
        1,0,0,0,276,1668,1,0,0,0,278,1679,1,0,0,0,280,1681,1,0,0,0,282,1711,
        1,0,0,0,284,1714,1,0,0,0,286,1718,1,0,0,0,288,1720,1,0,0,0,290,1726,
        1,0,0,0,292,1746,1,0,0,0,294,1748,1,0,0,0,296,1776,1,0,0,0,298,1779,
        1,0,0,0,300,1783,1,0,0,0,302,1785,1,0,0,0,304,1788,1,0,0,0,306,1791,
        1,0,0,0,308,1806,1,0,0,0,310,1827,1,0,0,0,312,1829,1,0,0,0,314,1831,
        1,0,0,0,316,1833,1,0,0,0,318,1836,1,0,0,0,320,1840,1,0,0,0,322,1844,
        1,0,0,0,324,1847,1,0,0,0,326,1861,1,0,0,0,328,1872,1,0,0,0,330,1874,
        1,0,0,0,332,1877,1,0,0,0,334,1883,1,0,0,0,336,1889,1,0,0,0,338,1899,
        1,0,0,0,340,1910,1,0,0,0,342,1925,1,0,0,0,344,1943,1,0,0,0,346,1945,
        1,0,0,0,348,1947,1,0,0,0,350,1964,1,0,0,0,352,1966,1,0,0,0,354,1976,
        1,0,0,0,356,1981,1,0,0,0,358,1986,1,0,0,0,360,1990,1,0,0,0,362,1998,
        1,0,0,0,364,2002,1,0,0,0,366,2017,1,0,0,0,368,2019,1,0,0,0,370,2025,
        1,0,0,0,372,2027,1,0,0,0,374,2034,1,0,0,0,376,2054,1,0,0,0,378,2056,
        1,0,0,0,380,2115,1,0,0,0,382,2117,1,0,0,0,384,386,3,120,60,0,385,
        384,1,0,0,0,385,386,1,0,0,0,386,387,1,0,0,0,387,388,5,0,0,1,388,
        1,1,0,0,0,389,391,3,382,191,0,390,389,1,0,0,0,391,392,1,0,0,0,392,
        390,1,0,0,0,392,393,1,0,0,0,393,402,1,0,0,0,394,402,5,71,0,0,395,
        396,5,88,0,0,396,397,3,90,45,0,397,398,5,89,0,0,398,402,1,0,0,0,
        399,402,3,4,2,0,400,402,3,12,6,0,401,390,1,0,0,0,401,394,1,0,0,0,
        401,395,1,0,0,0,401,399,1,0,0,0,401,400,1,0,0,0,402,3,1,0,0,0,403,
        406,3,6,3,0,404,406,3,8,4,0,405,403,1,0,0,0,405,404,1,0,0,0,406,
        5,1,0,0,0,407,418,5,136,0,0,408,418,3,330,165,0,409,418,3,316,158,
        0,410,418,3,332,166,0,411,414,5,102,0,0,412,415,3,278,139,0,413,
        415,3,162,81,0,414,412,1,0,0,0,414,413,1,0,0,0,415,418,1,0,0,0,416,
        418,3,344,172,0,417,407,1,0,0,0,417,408,1,0,0,0,417,409,1,0,0,0,
        417,410,1,0,0,0,417,411,1,0,0,0,417,416,1,0,0,0,418,7,1,0,0,0,419,
        421,3,10,5,0,420,422,5,70,0,0,421,420,1,0,0,0,421,422,1,0,0,0,422,
        423,1,0,0,0,423,424,3,6,3,0,424,9,1,0,0,0,425,429,6,5,-1,0,426,430,
        3,160,80,0,427,430,3,184,92,0,428,430,3,162,81,0,429,426,1,0,0,0,
        429,427,1,0,0,0,429,428,1,0,0,0,429,430,1,0,0,0,430,431,1,0,0,0,
        431,432,5,130,0,0,432,444,1,0,0,0,433,439,10,1,0,0,434,440,5,136,
        0,0,435,437,5,70,0,0,436,435,1,0,0,0,436,437,1,0,0,0,437,438,1,0,
        0,0,438,440,3,342,171,0,439,434,1,0,0,0,439,436,1,0,0,0,440,441,
        1,0,0,0,441,443,5,130,0,0,442,433,1,0,0,0,443,446,1,0,0,0,444,442,
        1,0,0,0,444,445,1,0,0,0,445,11,1,0,0,0,446,444,1,0,0,0,447,449,3,
        14,7,0,448,450,3,28,14,0,449,448,1,0,0,0,449,450,1,0,0,0,450,451,
        1,0,0,0,451,452,3,100,50,0,452,13,1,0,0,0,453,455,5,90,0,0,454,456,
        3,16,8,0,455,454,1,0,0,0,455,456,1,0,0,0,456,457,1,0,0,0,457,458,
        5,91,0,0,458,15,1,0,0,0,459,466,3,20,10,0,460,463,3,18,9,0,461,462,
        5,125,0,0,462,464,3,20,10,0,463,461,1,0,0,0,463,464,1,0,0,0,464,
        466,1,0,0,0,465,459,1,0,0,0,465,460,1,0,0,0,466,17,1,0,0,0,467,468,
        7,0,0,0,468,19,1,0,0,0,469,474,3,22,11,0,470,471,5,125,0,0,471,473,
        3,22,11,0,472,470,1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,474,475,
        1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,477,479,5,134,0,0,478,477,
        1,0,0,0,478,479,1,0,0,0,479,21,1,0,0,0,480,483,3,24,12,0,481,483,
        3,26,13,0,482,480,1,0,0,0,482,481,1,0,0,0,483,23,1,0,0,0,484,486,
        5,100,0,0,485,484,1,0,0,0,485,486,1,0,0,0,486,487,1,0,0,0,487,490,
        5,136,0,0,488,490,5,71,0,0,489,485,1,0,0,0,489,488,1,0,0,0,490,25,
        1,0,0,0,491,493,5,100,0,0,492,491,1,0,0,0,492,493,1,0,0,0,493,494,
        1,0,0,0,494,495,5,136,0,0,495,496,3,268,134,0,496,27,1,0,0,0,497,
        499,5,88,0,0,498,500,3,258,129,0,499,498,1,0,0,0,499,500,1,0,0,0,
        500,501,1,0,0,0,501,503,5,89,0,0,502,504,5,49,0,0,503,502,1,0,0,
        0,503,504,1,0,0,0,504,506,1,0,0,0,505,507,3,370,185,0,506,505,1,
        0,0,0,506,507,1,0,0,0,507,509,1,0,0,0,508,510,3,204,102,0,509,508,
        1,0,0,0,509,510,1,0,0,0,510,512,1,0,0,0,511,513,3,234,117,0,512,
        511,1,0,0,0,512,513,1,0,0,0,513,29,1,0,0,0,514,515,6,15,-1,0,515,
        545,3,2,1,0,516,519,3,158,79,0,517,519,3,352,176,0,518,516,1,0,0,
        0,518,517,1,0,0,0,519,526,1,0,0,0,520,522,5,88,0,0,521,523,3,34,
        17,0,522,521,1,0,0,0,522,523,1,0,0,0,523,524,1,0,0,0,524,527,5,89,
        0,0,525,527,3,276,138,0,526,520,1,0,0,0,526,525,1,0,0,0,527,545,
        1,0,0,0,528,529,7,1,0,0,529,530,5,105,0,0,530,531,3,246,123,0,531,
        532,5,106,0,0,532,533,5,88,0,0,533,534,3,90,45,0,534,535,5,89,0,
        0,535,545,1,0,0,0,536,537,3,32,16,0,537,540,5,88,0,0,538,541,3,90,
        45,0,539,541,3,246,123,0,540,538,1,0,0,0,540,539,1,0,0,0,541,542,
        1,0,0,0,542,543,5,89,0,0,543,545,1,0,0,0,544,514,1,0,0,0,544,518,
        1,0,0,0,544,528,1,0,0,0,544,536,1,0,0,0,545,573,1,0,0,0,546,547,
        10,7,0,0,547,550,5,90,0,0,548,551,3,90,45,0,549,551,3,276,138,0,
        550,548,1,0,0,0,550,549,1,0,0,0,551,552,1,0,0,0,552,553,5,91,0,0,
        553,572,1,0,0,0,554,555,10,6,0,0,555,557,5,88,0,0,556,558,3,34,17,
        0,557,556,1,0,0,0,557,558,1,0,0,0,558,559,1,0,0,0,559,572,5,89,0,
        0,560,561,10,4,0,0,561,567,7,2,0,0,562,564,5,70,0,0,563,562,1,0,
        0,0,563,564,1,0,0,0,564,565,1,0,0,0,565,568,3,4,2,0,566,568,3,36,
        18,0,567,563,1,0,0,0,567,566,1,0,0,0,568,572,1,0,0,0,569,570,10,
        3,0,0,570,572,7,3,0,0,571,546,1,0,0,0,571,554,1,0,0,0,571,560,1,
        0,0,0,571,569,1,0,0,0,572,575,1,0,0,0,573,571,1,0,0,0,573,574,1,
        0,0,0,574,31,1,0,0,0,575,573,1,0,0,0,576,577,5,78,0,0,577,33,1,0,
        0,0,578,579,3,274,137,0,579,35,1,0,0,0,580,582,3,10,5,0,581,580,
        1,0,0,0,581,582,1,0,0,0,582,586,1,0,0,0,583,584,3,160,80,0,584,585,
        5,130,0,0,585,587,1,0,0,0,586,583,1,0,0,0,586,587,1,0,0,0,587,588,
        1,0,0,0,588,589,5,102,0,0,589,600,3,160,80,0,590,591,3,10,5,0,591,
        592,5,70,0,0,592,593,3,342,171,0,593,594,5,130,0,0,594,595,5,102,
        0,0,595,596,3,160,80,0,596,600,1,0,0,0,597,598,5,102,0,0,598,600,
        3,162,81,0,599,581,1,0,0,0,599,590,1,0,0,0,599,597,1,0,0,0,600,37,
        1,0,0,0,601,629,3,30,15,0,602,607,5,123,0,0,603,607,5,124,0,0,604,
        607,3,40,20,0,605,607,5,64,0,0,606,602,1,0,0,0,606,603,1,0,0,0,606,
        604,1,0,0,0,606,605,1,0,0,0,607,608,1,0,0,0,608,629,3,38,19,0,609,
        618,5,64,0,0,610,611,5,88,0,0,611,612,3,246,123,0,612,613,5,89,0,
        0,613,619,1,0,0,0,614,615,5,134,0,0,615,616,5,88,0,0,616,617,5,136,
        0,0,617,619,5,89,0,0,618,610,1,0,0,0,618,614,1,0,0,0,619,629,1,0,
        0,0,620,621,5,12,0,0,621,622,5,88,0,0,622,623,3,246,123,0,623,624,
        5,89,0,0,624,629,1,0,0,0,625,629,3,56,28,0,626,629,3,42,21,0,627,
        629,3,54,27,0,628,601,1,0,0,0,628,606,1,0,0,0,628,609,1,0,0,0,628,
        620,1,0,0,0,628,625,1,0,0,0,628,626,1,0,0,0,628,627,1,0,0,0,629,
        39,1,0,0,0,630,631,7,4,0,0,631,41,1,0,0,0,632,634,5,130,0,0,633,
        632,1,0,0,0,633,634,1,0,0,0,634,635,1,0,0,0,635,637,5,51,0,0,636,
        638,3,44,22,0,637,636,1,0,0,0,637,638,1,0,0,0,638,644,1,0,0,0,639,
        645,3,46,23,0,640,641,5,88,0,0,641,642,3,246,123,0,642,643,5,89,
        0,0,643,645,1,0,0,0,644,639,1,0,0,0,644,640,1,0,0,0,645,647,1,0,
        0,0,646,648,3,52,26,0,647,646,1,0,0,0,647,648,1,0,0,0,648,43,1,0,
        0,0,649,650,5,88,0,0,650,651,3,34,17,0,651,652,5,89,0,0,652,45,1,
        0,0,0,653,655,3,150,75,0,654,656,3,48,24,0,655,654,1,0,0,0,655,656,
        1,0,0,0,656,47,1,0,0,0,657,659,3,236,118,0,658,660,3,48,24,0,659,
        658,1,0,0,0,659,660,1,0,0,0,660,663,1,0,0,0,661,663,3,50,25,0,662,
        657,1,0,0,0,662,661,1,0,0,0,663,49,1,0,0,0,664,665,6,25,-1,0,665,
        666,5,90,0,0,666,667,3,90,45,0,667,669,5,91,0,0,668,670,3,204,102,
        0,669,668,1,0,0,0,669,670,1,0,0,0,670,680,1,0,0,0,671,672,10,1,0,
        0,672,673,5,90,0,0,673,674,3,92,46,0,674,676,5,91,0,0,675,677,3,
        204,102,0,676,675,1,0,0,0,676,677,1,0,0,0,677,679,1,0,0,0,678,671,
        1,0,0,0,679,682,1,0,0,0,680,678,1,0,0,0,680,681,1,0,0,0,681,51,1,
        0,0,0,682,680,1,0,0,0,683,685,5,88,0,0,684,686,3,34,17,0,685,684,
        1,0,0,0,685,686,1,0,0,0,686,687,1,0,0,0,687,690,5,89,0,0,688,690,
        3,276,138,0,689,683,1,0,0,0,689,688,1,0,0,0,690,53,1,0,0,0,691,693,
        5,130,0,0,692,691,1,0,0,0,692,693,1,0,0,0,693,694,1,0,0,0,694,697,
        5,30,0,0,695,696,5,90,0,0,696,698,5,91,0,0,697,695,1,0,0,0,697,698,
        1,0,0,0,698,699,1,0,0,0,699,700,3,58,29,0,700,55,1,0,0,0,701,702,
        5,52,0,0,702,703,5,88,0,0,703,704,3,90,45,0,704,705,5,89,0,0,705,
        57,1,0,0,0,706,713,3,38,19,0,707,708,5,88,0,0,708,709,3,246,123,
        0,709,710,5,89,0,0,710,711,3,58,29,0,711,713,1,0,0,0,712,706,1,0,
        0,0,712,707,1,0,0,0,713,59,1,0,0,0,714,719,3,58,29,0,715,716,7,5,
        0,0,716,718,3,58,29,0,717,715,1,0,0,0,718,721,1,0,0,0,719,717,1,
        0,0,0,719,720,1,0,0,0,720,61,1,0,0,0,721,719,1,0,0,0,722,727,3,60,
        30,0,723,724,7,6,0,0,724,726,3,60,30,0,725,723,1,0,0,0,726,729,1,
        0,0,0,727,725,1,0,0,0,727,728,1,0,0,0,728,63,1,0,0,0,729,727,1,0,
        0,0,730,735,3,62,31,0,731,732,7,7,0,0,732,734,3,62,31,0,733,731,
        1,0,0,0,734,737,1,0,0,0,735,733,1,0,0,0,735,736,1,0,0,0,736,65,1,
        0,0,0,737,735,1,0,0,0,738,744,3,64,32,0,739,740,3,68,34,0,740,741,
        3,64,32,0,741,743,1,0,0,0,742,739,1,0,0,0,743,746,1,0,0,0,744,742,
        1,0,0,0,744,745,1,0,0,0,745,67,1,0,0,0,746,744,1,0,0,0,747,748,5,
        106,0,0,748,752,5,106,0,0,749,750,5,105,0,0,750,752,5,105,0,0,751,
        747,1,0,0,0,751,749,1,0,0,0,752,69,1,0,0,0,753,758,3,66,33,0,754,
        755,7,8,0,0,755,757,3,66,33,0,756,754,1,0,0,0,757,760,1,0,0,0,758,
        756,1,0,0,0,758,759,1,0,0,0,759,71,1,0,0,0,760,758,1,0,0,0,761,766,
        3,70,35,0,762,763,7,9,0,0,763,765,3,70,35,0,764,762,1,0,0,0,765,
        768,1,0,0,0,766,764,1,0,0,0,766,767,1,0,0,0,767,73,1,0,0,0,768,766,
        1,0,0,0,769,774,3,72,36,0,770,771,5,100,0,0,771,773,3,72,36,0,772,
        770,1,0,0,0,773,776,1,0,0,0,774,772,1,0,0,0,774,775,1,0,0,0,775,
        75,1,0,0,0,776,774,1,0,0,0,777,782,3,74,37,0,778,779,5,99,0,0,779,
        781,3,74,37,0,780,778,1,0,0,0,781,784,1,0,0,0,782,780,1,0,0,0,782,
        783,1,0,0,0,783,77,1,0,0,0,784,782,1,0,0,0,785,790,3,76,38,0,786,
        787,5,101,0,0,787,789,3,76,38,0,788,786,1,0,0,0,789,792,1,0,0,0,
        790,788,1,0,0,0,790,791,1,0,0,0,791,79,1,0,0,0,792,790,1,0,0,0,793,
        798,3,78,39,0,794,795,5,121,0,0,795,797,3,78,39,0,796,794,1,0,0,
        0,797,800,1,0,0,0,798,796,1,0,0,0,798,799,1,0,0,0,799,81,1,0,0,0,
        800,798,1,0,0,0,801,806,3,80,40,0,802,803,5,122,0,0,803,805,3,80,
        40,0,804,802,1,0,0,0,805,808,1,0,0,0,806,804,1,0,0,0,806,807,1,0,
        0,0,807,83,1,0,0,0,808,806,1,0,0,0,809,815,3,82,41,0,810,811,5,128,
        0,0,811,812,3,90,45,0,812,813,5,129,0,0,813,814,3,86,43,0,814,816,
        1,0,0,0,815,810,1,0,0,0,815,816,1,0,0,0,816,85,1,0,0,0,817,824,3,
        84,42,0,818,819,3,82,41,0,819,820,3,88,44,0,820,821,3,272,136,0,
        821,824,1,0,0,0,822,824,3,368,184,0,823,817,1,0,0,0,823,818,1,0,
        0,0,823,822,1,0,0,0,824,87,1,0,0,0,825,826,7,10,0,0,826,89,1,0,0,
        0,827,832,3,86,43,0,828,829,5,125,0,0,829,831,3,86,43,0,830,828,
        1,0,0,0,831,834,1,0,0,0,832,830,1,0,0,0,832,833,1,0,0,0,833,91,1,
        0,0,0,834,832,1,0,0,0,835,836,3,84,42,0,836,93,1,0,0,0,837,851,3,
        96,48,0,838,851,3,118,59,0,839,841,3,204,102,0,840,839,1,0,0,0,840,
        841,1,0,0,0,841,848,1,0,0,0,842,849,3,98,49,0,843,849,3,100,50,0,
        844,849,3,104,52,0,845,849,3,108,54,0,846,849,3,116,58,0,847,849,
        3,358,179,0,848,842,1,0,0,0,848,843,1,0,0,0,848,844,1,0,0,0,848,
        845,1,0,0,0,848,846,1,0,0,0,848,847,1,0,0,0,849,851,1,0,0,0,850,
        837,1,0,0,0,850,838,1,0,0,0,850,840,1,0,0,0,851,95,1,0,0,0,852,854,
        3,204,102,0,853,852,1,0,0,0,853,854,1,0,0,0,854,859,1,0,0,0,855,
        860,5,136,0,0,856,857,5,17,0,0,857,860,3,92,46,0,858,860,5,28,0,
        0,859,855,1,0,0,0,859,856,1,0,0,0,859,858,1,0,0,0,860,861,1,0,0,
        0,861,862,5,129,0,0,862,863,3,94,47,0,863,97,1,0,0,0,864,866,3,90,
        45,0,865,864,1,0,0,0,865,866,1,0,0,0,866,867,1,0,0,0,867,868,5,131,
        0,0,868,99,1,0,0,0,869,871,5,92,0,0,870,872,3,102,51,0,871,870,1,
        0,0,0,871,872,1,0,0,0,872,873,1,0,0,0,873,874,5,93,0,0,874,101,1,
        0,0,0,875,877,3,94,47,0,876,875,1,0,0,0,877,878,1,0,0,0,878,876,
        1,0,0,0,878,879,1,0,0,0,879,103,1,0,0,0,880,881,5,45,0,0,881,882,
        5,88,0,0,882,883,3,106,53,0,883,884,5,89,0,0,884,887,3,94,47,0,885,
        886,5,34,0,0,886,888,3,94,47,0,887,885,1,0,0,0,887,888,1,0,0,0,888,
        896,1,0,0,0,889,890,5,69,0,0,890,891,5,88,0,0,891,892,3,106,53,0,
        892,893,5,89,0,0,893,894,3,94,47,0,894,896,1,0,0,0,895,880,1,0,0,
        0,895,889,1,0,0,0,896,105,1,0,0,0,897,909,3,90,45,0,898,900,3,204,
        102,0,899,898,1,0,0,0,899,900,1,0,0,0,900,901,1,0,0,0,901,902,3,
        138,69,0,902,906,3,226,113,0,903,904,5,104,0,0,904,907,3,272,136,
        0,905,907,3,276,138,0,906,903,1,0,0,0,906,905,1,0,0,0,907,909,1,
        0,0,0,908,897,1,0,0,0,908,899,1,0,0,0,909,107,1,0,0,0,910,911,5,
        87,0,0,911,912,5,88,0,0,912,913,3,106,53,0,913,914,5,89,0,0,914,
        915,3,94,47,0,915,944,1,0,0,0,916,917,5,31,0,0,917,918,3,94,47,0,
        918,919,5,87,0,0,919,920,5,88,0,0,920,921,3,90,45,0,921,922,5,89,
        0,0,922,923,5,131,0,0,923,944,1,0,0,0,924,925,5,42,0,0,925,938,5,
        88,0,0,926,928,3,110,55,0,927,929,3,106,53,0,928,927,1,0,0,0,928,
        929,1,0,0,0,929,930,1,0,0,0,930,932,5,131,0,0,931,933,3,90,45,0,
        932,931,1,0,0,0,932,933,1,0,0,0,933,939,1,0,0,0,934,935,3,112,56,
        0,935,936,5,129,0,0,936,937,3,114,57,0,937,939,1,0,0,0,938,926,1,
        0,0,0,938,934,1,0,0,0,939,940,1,0,0,0,940,941,5,89,0,0,941,942,3,
        94,47,0,942,944,1,0,0,0,943,910,1,0,0,0,943,916,1,0,0,0,943,924,
        1,0,0,0,944,109,1,0,0,0,945,948,3,98,49,0,946,948,3,128,64,0,947,
        945,1,0,0,0,947,946,1,0,0,0,948,111,1,0,0,0,949,951,3,204,102,0,
        950,949,1,0,0,0,950,951,1,0,0,0,951,952,1,0,0,0,952,953,3,138,69,
        0,953,954,3,226,113,0,954,113,1,0,0,0,955,958,3,90,45,0,956,958,
        3,276,138,0,957,955,1,0,0,0,957,956,1,0,0,0,958,115,1,0,0,0,959,
        969,5,16,0,0,960,969,5,26,0,0,961,964,5,61,0,0,962,965,3,90,45,0,
        963,965,3,276,138,0,964,962,1,0,0,0,964,963,1,0,0,0,964,965,1,0,
        0,0,965,969,1,0,0,0,966,967,5,44,0,0,967,969,5,136,0,0,968,959,1,
        0,0,0,968,960,1,0,0,0,968,961,1,0,0,0,968,966,1,0,0,0,969,970,1,
        0,0,0,970,971,5,131,0,0,971,117,1,0,0,0,972,973,3,124,62,0,973,119,
        1,0,0,0,974,976,3,122,61,0,975,974,1,0,0,0,976,977,1,0,0,0,977,975,
        1,0,0,0,977,978,1,0,0,0,978,121,1,0,0,0,979,990,3,124,62,0,980,990,
        3,264,132,0,981,990,3,334,167,0,982,990,3,354,177,0,983,990,3,356,
        178,0,984,990,3,202,101,0,985,990,3,188,94,0,986,990,3,132,66,0,
        987,990,3,134,67,0,988,990,3,378,189,0,989,979,1,0,0,0,989,980,1,
        0,0,0,989,981,1,0,0,0,989,982,1,0,0,0,989,983,1,0,0,0,989,984,1,
        0,0,0,989,985,1,0,0,0,989,986,1,0,0,0,989,987,1,0,0,0,989,988,1,
        0,0,0,990,123,1,0,0,0,991,1000,3,128,64,0,992,1000,3,200,100,0,993,
        1000,3,192,96,0,994,1000,3,196,98,0,995,1000,3,198,99,0,996,1000,
        3,130,65,0,997,1000,3,126,63,0,998,1000,3,172,86,0,999,991,1,0,0,
        0,999,992,1,0,0,0,999,993,1,0,0,0,999,994,1,0,0,0,999,995,1,0,0,
        0,999,996,1,0,0,0,999,997,1,0,0,0,999,998,1,0,0,0,1000,125,1,0,0,
        0,1001,1002,5,82,0,0,1002,1004,5,136,0,0,1003,1005,3,204,102,0,1004,
        1003,1,0,0,0,1004,1005,1,0,0,0,1005,1006,1,0,0,0,1006,1007,5,104,
        0,0,1007,1008,3,246,123,0,1008,1009,5,131,0,0,1009,127,1,0,0,0,1010,
        1012,3,138,69,0,1011,1010,1,0,0,0,1011,1012,1,0,0,0,1012,1014,1,
        0,0,0,1013,1015,3,222,111,0,1014,1013,1,0,0,0,1014,1015,1,0,0,0,
        1015,1016,1,0,0,0,1016,1025,5,131,0,0,1017,1019,3,204,102,0,1018,
        1020,3,138,69,0,1019,1018,1,0,0,0,1019,1020,1,0,0,0,1020,1021,1,
        0,0,0,1021,1022,3,222,111,0,1022,1023,5,131,0,0,1023,1025,1,0,0,
        0,1024,1011,1,0,0,0,1024,1017,1,0,0,0,1025,129,1,0,0,0,1026,1027,
        5,66,0,0,1027,1028,5,88,0,0,1028,1029,3,92,46,0,1029,1030,5,125,
        0,0,1030,1031,5,4,0,0,1031,1032,5,89,0,0,1032,1033,5,131,0,0,1033,
        131,1,0,0,0,1034,1035,5,131,0,0,1035,133,1,0,0,0,1036,1037,3,204,
        102,0,1037,1038,5,131,0,0,1038,135,1,0,0,0,1039,1046,3,140,70,0,
        1040,1046,3,146,73,0,1041,1046,3,142,71,0,1042,1046,5,43,0,0,1043,
        1046,5,77,0,0,1044,1046,5,24,0,0,1045,1039,1,0,0,0,1045,1040,1,0,
        0,0,1045,1041,1,0,0,0,1045,1042,1,0,0,0,1045,1043,1,0,0,0,1045,1044,
        1,0,0,0,1046,137,1,0,0,0,1047,1049,3,136,68,0,1048,1047,1,0,0,0,
        1049,1050,1,0,0,0,1050,1051,1,0,0,0,1050,1048,1,0,0,0,1051,1053,
        1,0,0,0,1052,1054,3,204,102,0,1053,1052,1,0,0,0,1053,1054,1,0,0,
        0,1054,139,1,0,0,0,1055,1056,7,11,0,0,1056,141,1,0,0,0,1057,1058,
        7,12,0,0,1058,143,1,0,0,0,1059,1060,5,136,0,0,1060,145,1,0,0,0,1061,
        1065,3,148,74,0,1062,1065,3,280,140,0,1063,1065,3,168,84,0,1064,
        1061,1,0,0,0,1064,1062,1,0,0,0,1064,1063,1,0,0,0,1065,147,1,0,0,
        0,1066,1071,3,158,79,0,1067,1071,3,164,82,0,1068,1071,3,352,176,
        0,1069,1071,3,240,120,0,1070,1066,1,0,0,0,1070,1067,1,0,0,0,1070,
        1068,1,0,0,0,1070,1069,1,0,0,0,1071,149,1,0,0,0,1072,1074,3,146,
        73,0,1073,1072,1,0,0,0,1074,1075,1,0,0,0,1075,1073,1,0,0,0,1075,
        1076,1,0,0,0,1076,1078,1,0,0,0,1077,1079,3,204,102,0,1078,1077,1,
        0,0,0,1078,1079,1,0,0,0,1079,151,1,0,0,0,1080,1082,3,148,74,0,1081,
        1080,1,0,0,0,1082,1083,1,0,0,0,1083,1081,1,0,0,0,1083,1084,1,0,0,
        0,1084,1086,1,0,0,0,1085,1087,3,204,102,0,1086,1085,1,0,0,0,1086,
        1087,1,0,0,0,1087,153,1,0,0,0,1088,1089,7,13,0,0,1089,155,1,0,0,
        0,1090,1091,7,14,0,0,1091,157,1,0,0,0,1092,1094,3,10,5,0,1093,1092,
        1,0,0,0,1093,1094,1,0,0,0,1094,1095,1,0,0,0,1095,1145,3,160,80,0,
        1096,1097,3,10,5,0,1097,1098,5,70,0,0,1098,1099,3,342,171,0,1099,
        1145,1,0,0,0,1100,1145,3,156,78,0,1101,1103,3,156,78,0,1102,1101,
        1,0,0,0,1102,1103,1,0,0,0,1103,1105,1,0,0,0,1104,1106,3,154,77,0,
        1105,1104,1,0,0,0,1106,1107,1,0,0,0,1107,1105,1,0,0,0,1107,1108,
        1,0,0,0,1108,1145,1,0,0,0,1109,1111,3,156,78,0,1110,1109,1,0,0,0,
        1110,1111,1,0,0,0,1111,1112,1,0,0,0,1112,1145,5,19,0,0,1113,1115,
        3,156,78,0,1114,1113,1,0,0,0,1114,1115,1,0,0,0,1115,1116,1,0,0,0,
        1116,1145,5,20,0,0,1117,1119,3,156,78,0,1118,1117,1,0,0,0,1118,1119,
        1,0,0,0,1119,1120,1,0,0,0,1120,1145,5,21,0,0,1121,1123,3,156,78,
        0,1122,1121,1,0,0,0,1122,1123,1,0,0,0,1123,1124,1,0,0,0,1124,1145,
        5,86,0,0,1125,1145,5,15,0,0,1126,1128,3,156,78,0,1127,1126,1,0,0,
        0,1127,1128,1,0,0,0,1128,1132,1,0,0,0,1129,1131,3,154,77,0,1130,
        1129,1,0,0,0,1131,1134,1,0,0,0,1132,1130,1,0,0,0,1132,1133,1,0,0,
        0,1133,1135,1,0,0,0,1134,1132,1,0,0,0,1135,1145,5,47,0,0,1136,1145,
        5,41,0,0,1137,1139,3,154,77,0,1138,1137,1,0,0,0,1138,1139,1,0,0,
        0,1139,1140,1,0,0,0,1140,1145,5,32,0,0,1141,1145,5,84,0,0,1142,1145,
        5,14,0,0,1143,1145,3,162,81,0,1144,1093,1,0,0,0,1144,1096,1,0,0,
        0,1144,1100,1,0,0,0,1144,1102,1,0,0,0,1144,1110,1,0,0,0,1144,1114,
        1,0,0,0,1144,1118,1,0,0,0,1144,1122,1,0,0,0,1144,1125,1,0,0,0,1144,
        1127,1,0,0,0,1144,1136,1,0,0,0,1144,1138,1,0,0,0,1144,1141,1,0,0,
        0,1144,1142,1,0,0,0,1144,1143,1,0,0,0,1145,159,1,0,0,0,1146,1151,
        3,278,139,0,1147,1151,3,166,83,0,1148,1151,3,144,72,0,1149,1151,
        3,342,171,0,1150,1146,1,0,0,0,1150,1147,1,0,0,0,1150,1148,1,0,0,
        0,1150,1149,1,0,0,0,1151,161,1,0,0,0,1152,1153,5,27,0,0,1153,1156,
        5,88,0,0,1154,1157,3,90,45,0,1155,1157,5,14,0,0,1156,1154,1,0,0,
        0,1156,1155,1,0,0,0,1157,1158,1,0,0,0,1158,1159,5,89,0,0,1159,163,
        1,0,0,0,1160,1175,3,288,144,0,1161,1163,3,204,102,0,1162,1161,1,
        0,0,0,1162,1163,1,0,0,0,1163,1165,1,0,0,0,1164,1166,3,10,5,0,1165,
        1164,1,0,0,0,1165,1166,1,0,0,0,1166,1167,1,0,0,0,1167,1176,5,136,
        0,0,1168,1176,3,342,171,0,1169,1171,3,10,5,0,1170,1172,5,70,0,0,
        1171,1170,1,0,0,0,1171,1172,1,0,0,0,1172,1173,1,0,0,0,1173,1174,
        3,342,171,0,1174,1176,1,0,0,0,1175,1162,1,0,0,0,1175,1168,1,0,0,
        0,1175,1169,1,0,0,0,1176,1183,1,0,0,0,1177,1179,5,35,0,0,1178,1180,
        3,10,5,0,1179,1178,1,0,0,0,1179,1180,1,0,0,0,1180,1181,1,0,0,0,1181,
        1183,5,136,0,0,1182,1160,1,0,0,0,1182,1177,1,0,0,0,1183,165,1,0,
        0,0,1184,1185,5,136,0,0,1185,167,1,0,0,0,1186,1187,3,170,85,0,1187,
        1192,5,92,0,0,1188,1190,3,178,89,0,1189,1191,5,125,0,0,1190,1189,
        1,0,0,0,1190,1191,1,0,0,0,1191,1193,1,0,0,0,1192,1188,1,0,0,0,1192,
        1193,1,0,0,0,1193,1194,1,0,0,0,1194,1195,5,93,0,0,1195,169,1,0,0,
        0,1196,1198,3,174,87,0,1197,1199,3,204,102,0,1198,1197,1,0,0,0,1198,
        1199,1,0,0,0,1199,1204,1,0,0,0,1200,1202,3,10,5,0,1201,1200,1,0,
        0,0,1201,1202,1,0,0,0,1202,1203,1,0,0,0,1203,1205,5,136,0,0,1204,
        1201,1,0,0,0,1204,1205,1,0,0,0,1205,1207,1,0,0,0,1206,1208,3,176,
        88,0,1207,1206,1,0,0,0,1207,1208,1,0,0,0,1208,171,1,0,0,0,1209,1211,
        3,174,87,0,1210,1212,3,204,102,0,1211,1210,1,0,0,0,1211,1212,1,0,
        0,0,1212,1213,1,0,0,0,1213,1215,5,136,0,0,1214,1216,3,176,88,0,1215,
        1214,1,0,0,0,1215,1216,1,0,0,0,1216,1217,1,0,0,0,1217,1218,5,131,
        0,0,1218,173,1,0,0,0,1219,1221,5,35,0,0,1220,1222,7,15,0,0,1221,
        1220,1,0,0,0,1221,1222,1,0,0,0,1222,175,1,0,0,0,1223,1224,5,129,
        0,0,1224,1225,3,150,75,0,1225,177,1,0,0,0,1226,1231,3,180,90,0,1227,
        1228,5,125,0,0,1228,1230,3,180,90,0,1229,1227,1,0,0,0,1230,1233,
        1,0,0,0,1231,1229,1,0,0,0,1231,1232,1,0,0,0,1232,179,1,0,0,0,1233,
        1231,1,0,0,0,1234,1237,3,182,91,0,1235,1236,5,104,0,0,1236,1238,
        3,92,46,0,1237,1235,1,0,0,0,1237,1238,1,0,0,0,1238,181,1,0,0,0,1239,
        1240,5,136,0,0,1240,183,1,0,0,0,1241,1244,3,186,93,0,1242,1244,3,
        190,95,0,1243,1241,1,0,0,0,1243,1242,1,0,0,0,1244,185,1,0,0,0,1245,
        1246,5,136,0,0,1246,187,1,0,0,0,1247,1249,5,46,0,0,1248,1247,1,0,
        0,0,1248,1249,1,0,0,0,1249,1250,1,0,0,0,1250,1253,5,50,0,0,1251,
        1254,5,136,0,0,1252,1254,3,186,93,0,1253,1251,1,0,0,0,1253,1252,
        1,0,0,0,1253,1254,1,0,0,0,1254,1255,1,0,0,0,1255,1257,5,92,0,0,1256,
        1258,3,120,60,0,1257,1256,1,0,0,0,1257,1258,1,0,0,0,1258,1259,1,
        0,0,0,1259,1260,5,93,0,0,1260,189,1,0,0,0,1261,1262,5,136,0,0,1262,
        191,1,0,0,0,1263,1264,5,50,0,0,1264,1265,5,136,0,0,1265,1266,5,104,
        0,0,1266,1267,3,194,97,0,1267,1268,5,131,0,0,1268,193,1,0,0,0,1269,
        1271,3,10,5,0,1270,1269,1,0,0,0,1270,1271,1,0,0,0,1271,1272,1,0,
        0,0,1272,1273,3,184,92,0,1273,195,1,0,0,0,1274,1280,5,82,0,0,1275,
        1277,5,79,0,0,1276,1275,1,0,0,0,1276,1277,1,0,0,0,1277,1278,1,0,
        0,0,1278,1281,3,10,5,0,1279,1281,5,130,0,0,1280,1276,1,0,0,0,1280,
        1279,1,0,0,0,1281,1282,1,0,0,0,1282,1283,3,6,3,0,1283,1284,5,131,
        0,0,1284,197,1,0,0,0,1285,1287,3,204,102,0,1286,1285,1,0,0,0,1286,
        1287,1,0,0,0,1287,1288,1,0,0,0,1288,1289,5,82,0,0,1289,1291,5,50,
        0,0,1290,1292,3,10,5,0,1291,1290,1,0,0,0,1291,1292,1,0,0,0,1292,
        1293,1,0,0,0,1293,1294,3,184,92,0,1294,1295,5,131,0,0,1295,199,1,
        0,0,0,1296,1297,5,13,0,0,1297,1298,5,88,0,0,1298,1299,5,4,0,0,1299,
        1300,5,89,0,0,1300,1301,5,131,0,0,1301,201,1,0,0,0,1302,1303,5,38,
        0,0,1303,1310,5,4,0,0,1304,1306,5,92,0,0,1305,1307,3,120,60,0,1306,
        1305,1,0,0,0,1306,1307,1,0,0,0,1307,1308,1,0,0,0,1308,1311,5,93,
        0,0,1309,1311,3,122,61,0,1310,1304,1,0,0,0,1310,1309,1,0,0,0,1311,
        203,1,0,0,0,1312,1314,3,206,103,0,1313,1312,1,0,0,0,1314,1315,1,
        0,0,0,1315,1313,1,0,0,0,1315,1316,1,0,0,0,1316,205,1,0,0,0,1317,
        1318,5,90,0,0,1318,1320,5,90,0,0,1319,1321,3,210,105,0,1320,1319,
        1,0,0,0,1320,1321,1,0,0,0,1321,1322,1,0,0,0,1322,1323,5,91,0,0,1323,
        1326,5,91,0,0,1324,1326,3,208,104,0,1325,1317,1,0,0,0,1325,1324,
        1,0,0,0,1326,207,1,0,0,0,1327,1328,5,11,0,0,1328,1331,5,88,0,0,1329,
        1332,3,246,123,0,1330,1332,3,92,46,0,1331,1329,1,0,0,0,1331,1330,
        1,0,0,0,1332,1334,1,0,0,0,1333,1335,5,134,0,0,1334,1333,1,0,0,0,
        1334,1335,1,0,0,0,1335,1336,1,0,0,0,1336,1337,5,89,0,0,1337,209,
        1,0,0,0,1338,1343,3,212,106,0,1339,1340,5,125,0,0,1340,1342,3,212,
        106,0,1341,1339,1,0,0,0,1342,1345,1,0,0,0,1343,1341,1,0,0,0,1343,
        1344,1,0,0,0,1344,1347,1,0,0,0,1345,1343,1,0,0,0,1346,1348,5,134,
        0,0,1347,1346,1,0,0,0,1347,1348,1,0,0,0,1348,211,1,0,0,0,1349,1350,
        3,214,107,0,1350,1351,5,130,0,0,1351,1353,1,0,0,0,1352,1349,1,0,
        0,0,1352,1353,1,0,0,0,1353,1354,1,0,0,0,1354,1356,5,136,0,0,1355,
        1357,3,216,108,0,1356,1355,1,0,0,0,1356,1357,1,0,0,0,1357,213,1,
        0,0,0,1358,1359,5,136,0,0,1359,215,1,0,0,0,1360,1362,5,88,0,0,1361,
        1363,3,218,109,0,1362,1361,1,0,0,0,1362,1363,1,0,0,0,1363,1364,1,
        0,0,0,1364,1365,5,89,0,0,1365,217,1,0,0,0,1366,1368,3,220,110,0,
        1367,1366,1,0,0,0,1368,1369,1,0,0,0,1369,1367,1,0,0,0,1369,1370,
        1,0,0,0,1370,219,1,0,0,0,1371,1372,5,88,0,0,1372,1373,3,218,109,
        0,1373,1374,5,89,0,0,1374,1389,1,0,0,0,1375,1376,5,90,0,0,1376,1377,
        3,218,109,0,1377,1378,5,91,0,0,1378,1389,1,0,0,0,1379,1380,5,92,
        0,0,1380,1381,3,218,109,0,1381,1382,5,93,0,0,1382,1389,1,0,0,0,1383,
        1385,8,16,0,0,1384,1383,1,0,0,0,1385,1386,1,0,0,0,1386,1384,1,0,
        0,0,1386,1387,1,0,0,0,1387,1389,1,0,0,0,1388,1371,1,0,0,0,1388,1375,
        1,0,0,0,1388,1379,1,0,0,0,1388,1384,1,0,0,0,1389,221,1,0,0,0,1390,
        1395,3,224,112,0,1391,1392,5,125,0,0,1392,1394,3,224,112,0,1393,
        1391,1,0,0,0,1394,1397,1,0,0,0,1395,1393,1,0,0,0,1395,1396,1,0,0,
        0,1396,223,1,0,0,0,1397,1395,1,0,0,0,1398,1400,3,226,113,0,1399,
        1401,3,268,134,0,1400,1399,1,0,0,0,1400,1401,1,0,0,0,1401,225,1,
        0,0,0,1402,1408,3,228,114,0,1403,1404,3,230,115,0,1404,1405,3,232,
        116,0,1405,1406,3,234,117,0,1406,1408,1,0,0,0,1407,1402,1,0,0,0,
        1407,1403,1,0,0,0,1408,227,1,0,0,0,1409,1411,3,236,118,0,1410,1412,
        5,23,0,0,1411,1410,1,0,0,0,1411,1412,1,0,0,0,1412,1414,1,0,0,0,1413,
        1409,1,0,0,0,1414,1417,1,0,0,0,1415,1413,1,0,0,0,1415,1416,1,0,0,
        0,1416,1418,1,0,0,0,1417,1415,1,0,0,0,1418,1419,3,230,115,0,1419,
        229,1,0,0,0,1420,1421,6,115,-1,0,1421,1423,3,244,122,0,1422,1424,
        3,204,102,0,1423,1422,1,0,0,0,1423,1424,1,0,0,0,1424,1430,1,0,0,
        0,1425,1426,5,88,0,0,1426,1427,3,228,114,0,1427,1428,5,89,0,0,1428,
        1430,1,0,0,0,1429,1420,1,0,0,0,1429,1425,1,0,0,0,1430,1445,1,0,0,
        0,1431,1441,10,2,0,0,1432,1442,3,232,116,0,1433,1435,5,90,0,0,1434,
        1436,3,92,46,0,1435,1434,1,0,0,0,1435,1436,1,0,0,0,1436,1437,1,0,
        0,0,1437,1439,5,91,0,0,1438,1440,3,204,102,0,1439,1438,1,0,0,0,1439,
        1440,1,0,0,0,1440,1442,1,0,0,0,1441,1432,1,0,0,0,1441,1433,1,0,0,
        0,1442,1444,1,0,0,0,1443,1431,1,0,0,0,1444,1447,1,0,0,0,1445,1443,
        1,0,0,0,1445,1446,1,0,0,0,1446,231,1,0,0,0,1447,1445,1,0,0,0,1448,
        1450,5,88,0,0,1449,1451,3,258,129,0,1450,1449,1,0,0,0,1450,1451,
        1,0,0,0,1451,1452,1,0,0,0,1452,1454,5,89,0,0,1453,1455,3,238,119,
        0,1454,1453,1,0,0,0,1454,1455,1,0,0,0,1455,1457,1,0,0,0,1456,1458,
        3,242,121,0,1457,1456,1,0,0,0,1457,1458,1,0,0,0,1458,1460,1,0,0,
        0,1459,1461,3,370,185,0,1460,1459,1,0,0,0,1460,1461,1,0,0,0,1461,
        1463,1,0,0,0,1462,1464,3,204,102,0,1463,1462,1,0,0,0,1463,1464,1,
        0,0,0,1464,233,1,0,0,0,1465,1466,5,127,0,0,1466,1468,3,152,76,0,
        1467,1469,3,248,124,0,1468,1467,1,0,0,0,1468,1469,1,0,0,0,1469,235,
        1,0,0,0,1470,1472,7,17,0,0,1471,1473,3,204,102,0,1472,1471,1,0,0,
        0,1472,1473,1,0,0,0,1473,1485,1,0,0,0,1474,1476,3,10,5,0,1475,1474,
        1,0,0,0,1475,1476,1,0,0,0,1476,1477,1,0,0,0,1477,1479,5,96,0,0,1478,
        1480,3,204,102,0,1479,1478,1,0,0,0,1479,1480,1,0,0,0,1480,1482,1,
        0,0,0,1481,1483,3,238,119,0,1482,1481,1,0,0,0,1482,1483,1,0,0,0,
        1483,1485,1,0,0,0,1484,1470,1,0,0,0,1484,1475,1,0,0,0,1485,237,1,
        0,0,0,1486,1488,3,240,120,0,1487,1486,1,0,0,0,1488,1489,1,0,0,0,
        1489,1487,1,0,0,0,1489,1490,1,0,0,0,1490,239,1,0,0,0,1491,1492,7,
        18,0,0,1492,241,1,0,0,0,1493,1494,7,17,0,0,1494,243,1,0,0,0,1495,
        1497,5,134,0,0,1496,1495,1,0,0,0,1496,1497,1,0,0,0,1497,1498,1,0,
        0,0,1498,1499,3,4,2,0,1499,245,1,0,0,0,1500,1502,3,150,75,0,1501,
        1503,3,248,124,0,1502,1501,1,0,0,0,1502,1503,1,0,0,0,1503,247,1,
        0,0,0,1504,1513,3,250,125,0,1505,1507,3,252,126,0,1506,1505,1,0,
        0,0,1506,1507,1,0,0,0,1507,1508,1,0,0,0,1508,1509,3,232,116,0,1509,
        1510,3,234,117,0,1510,1513,1,0,0,0,1511,1513,3,254,127,0,1512,1504,
        1,0,0,0,1512,1506,1,0,0,0,1512,1511,1,0,0,0,1513,249,1,0,0,0,1514,
        1524,3,252,126,0,1515,1517,3,236,118,0,1516,1515,1,0,0,0,1517,1518,
        1,0,0,0,1518,1516,1,0,0,0,1518,1519,1,0,0,0,1519,1521,1,0,0,0,1520,
        1522,3,252,126,0,1521,1520,1,0,0,0,1521,1522,1,0,0,0,1522,1524,1,
        0,0,0,1523,1514,1,0,0,0,1523,1516,1,0,0,0,1524,251,1,0,0,0,1525,
        1526,6,126,-1,0,1526,1540,3,232,116,0,1527,1529,5,90,0,0,1528,1530,
        3,92,46,0,1529,1528,1,0,0,0,1529,1530,1,0,0,0,1530,1531,1,0,0,0,
        1531,1533,5,91,0,0,1532,1534,3,204,102,0,1533,1532,1,0,0,0,1533,
        1534,1,0,0,0,1534,1540,1,0,0,0,1535,1536,5,88,0,0,1536,1537,3,250,
        125,0,1537,1538,5,89,0,0,1538,1540,1,0,0,0,1539,1525,1,0,0,0,1539,
        1527,1,0,0,0,1539,1535,1,0,0,0,1540,1556,1,0,0,0,1541,1552,10,4,
        0,0,1542,1553,3,232,116,0,1543,1544,3,252,126,0,1544,1546,5,90,0,
        0,1545,1547,3,92,46,0,1546,1545,1,0,0,0,1546,1547,1,0,0,0,1547,1548,
        1,0,0,0,1548,1550,5,91,0,0,1549,1551,3,204,102,0,1550,1549,1,0,0,
        0,1550,1551,1,0,0,0,1551,1553,1,0,0,0,1552,1542,1,0,0,0,1552,1543,
        1,0,0,0,1553,1555,1,0,0,0,1554,1541,1,0,0,0,1555,1558,1,0,0,0,1556,
        1554,1,0,0,0,1556,1557,1,0,0,0,1557,253,1,0,0,0,1558,1556,1,0,0,
        0,1559,1561,3,236,118,0,1560,1559,1,0,0,0,1561,1564,1,0,0,0,1562,
        1560,1,0,0,0,1562,1563,1,0,0,0,1563,1565,1,0,0,0,1564,1562,1,0,0,
        0,1565,1566,3,256,128,0,1566,255,1,0,0,0,1567,1568,6,128,-1,0,1568,
        1569,5,134,0,0,1569,1584,1,0,0,0,1570,1580,10,2,0,0,1571,1581,3,
        232,116,0,1572,1574,5,90,0,0,1573,1575,3,92,46,0,1574,1573,1,0,0,
        0,1574,1575,1,0,0,0,1575,1576,1,0,0,0,1576,1578,5,91,0,0,1577,1579,
        3,204,102,0,1578,1577,1,0,0,0,1578,1579,1,0,0,0,1579,1581,1,0,0,
        0,1580,1571,1,0,0,0,1580,1572,1,0,0,0,1581,1583,1,0,0,0,1582,1570,
        1,0,0,0,1583,1586,1,0,0,0,1584,1582,1,0,0,0,1584,1585,1,0,0,0,1585,
        257,1,0,0,0,1586,1584,1,0,0,0,1587,1592,3,260,130,0,1588,1590,5,
        125,0,0,1589,1588,1,0,0,0,1589,1590,1,0,0,0,1590,1591,1,0,0,0,1591,
        1593,5,134,0,0,1592,1589,1,0,0,0,1592,1593,1,0,0,0,1593,259,1,0,
        0,0,1594,1599,3,262,131,0,1595,1596,5,125,0,0,1596,1598,3,262,131,
        0,1597,1595,1,0,0,0,1598,1601,1,0,0,0,1599,1597,1,0,0,0,1599,1600,
        1,0,0,0,1600,261,1,0,0,0,1601,1599,1,0,0,0,1602,1604,3,204,102,0,
        1603,1602,1,0,0,0,1603,1604,1,0,0,0,1604,1605,1,0,0,0,1605,1610,
        3,138,69,0,1606,1611,3,226,113,0,1607,1609,3,248,124,0,1608,1607,
        1,0,0,0,1608,1609,1,0,0,0,1609,1611,1,0,0,0,1610,1606,1,0,0,0,1610,
        1608,1,0,0,0,1611,1614,1,0,0,0,1612,1613,5,104,0,0,1613,1615,3,272,
        136,0,1614,1612,1,0,0,0,1614,1615,1,0,0,0,1615,263,1,0,0,0,1616,
        1618,3,204,102,0,1617,1616,1,0,0,0,1617,1618,1,0,0,0,1618,1620,1,
        0,0,0,1619,1621,3,138,69,0,1620,1619,1,0,0,0,1620,1621,1,0,0,0,1621,
        1622,1,0,0,0,1622,1624,3,226,113,0,1623,1625,3,298,149,0,1624,1623,
        1,0,0,0,1624,1625,1,0,0,0,1625,1626,1,0,0,0,1626,1627,3,266,133,
        0,1627,265,1,0,0,0,1628,1630,3,322,161,0,1629,1628,1,0,0,0,1629,
        1630,1,0,0,0,1630,1631,1,0,0,0,1631,1637,3,100,50,0,1632,1637,3,
        360,180,0,1633,1634,5,104,0,0,1634,1635,7,19,0,0,1635,1637,5,131,
        0,0,1636,1629,1,0,0,0,1636,1632,1,0,0,0,1636,1633,1,0,0,0,1637,267,
        1,0,0,0,1638,1644,3,270,135,0,1639,1640,5,88,0,0,1640,1641,3,34,
        17,0,1641,1642,5,89,0,0,1642,1644,1,0,0,0,1643,1638,1,0,0,0,1643,
        1639,1,0,0,0,1644,269,1,0,0,0,1645,1646,5,104,0,0,1646,1649,3,272,
        136,0,1647,1649,3,276,138,0,1648,1645,1,0,0,0,1648,1647,1,0,0,0,
        1649,271,1,0,0,0,1650,1653,3,86,43,0,1651,1653,3,276,138,0,1652,
        1650,1,0,0,0,1652,1651,1,0,0,0,1653,273,1,0,0,0,1654,1656,3,272,
        136,0,1655,1657,5,134,0,0,1656,1655,1,0,0,0,1656,1657,1,0,0,0,1657,
        1665,1,0,0,0,1658,1659,5,125,0,0,1659,1661,3,272,136,0,1660,1662,
        5,134,0,0,1661,1660,1,0,0,0,1661,1662,1,0,0,0,1662,1664,1,0,0,0,
        1663,1658,1,0,0,0,1664,1667,1,0,0,0,1665,1663,1,0,0,0,1665,1666,
        1,0,0,0,1666,275,1,0,0,0,1667,1665,1,0,0,0,1668,1673,5,92,0,0,1669,
        1671,3,274,137,0,1670,1672,5,125,0,0,1671,1670,1,0,0,0,1671,1672,
        1,0,0,0,1672,1674,1,0,0,0,1673,1669,1,0,0,0,1673,1674,1,0,0,0,1674,
        1675,1,0,0,0,1675,1676,5,93,0,0,1676,277,1,0,0,0,1677,1680,5,136,
        0,0,1678,1680,3,342,171,0,1679,1677,1,0,0,0,1679,1678,1,0,0,0,1680,
        279,1,0,0,0,1681,1682,3,282,141,0,1682,1684,5,92,0,0,1683,1685,3,
        290,145,0,1684,1683,1,0,0,0,1684,1685,1,0,0,0,1685,1686,1,0,0,0,
        1686,1687,5,93,0,0,1687,281,1,0,0,0,1688,1690,3,288,144,0,1689,1691,
        3,204,102,0,1690,1689,1,0,0,0,1690,1691,1,0,0,0,1691,1696,1,0,0,
        0,1692,1694,3,284,142,0,1693,1695,3,286,143,0,1694,1693,1,0,0,0,
        1694,1695,1,0,0,0,1695,1697,1,0,0,0,1696,1692,1,0,0,0,1696,1697,
        1,0,0,0,1697,1699,1,0,0,0,1698,1700,3,304,152,0,1699,1698,1,0,0,
        0,1699,1700,1,0,0,0,1700,1712,1,0,0,0,1701,1703,5,80,0,0,1702,1704,
        3,204,102,0,1703,1702,1,0,0,0,1703,1704,1,0,0,0,1704,1709,1,0,0,
        0,1705,1707,3,284,142,0,1706,1708,3,286,143,0,1707,1706,1,0,0,0,
        1707,1708,1,0,0,0,1708,1710,1,0,0,0,1709,1705,1,0,0,0,1709,1710,
        1,0,0,0,1710,1712,1,0,0,0,1711,1688,1,0,0,0,1711,1701,1,0,0,0,1712,
        283,1,0,0,0,1713,1715,3,10,5,0,1714,1713,1,0,0,0,1714,1715,1,0,0,
        0,1715,1716,1,0,0,0,1716,1717,3,278,139,0,1717,285,1,0,0,0,1718,
        1719,5,40,0,0,1719,287,1,0,0,0,1720,1721,7,15,0,0,1721,289,1,0,0,
        0,1722,1727,3,292,146,0,1723,1724,3,314,157,0,1724,1725,5,129,0,
        0,1725,1727,1,0,0,0,1726,1722,1,0,0,0,1726,1723,1,0,0,0,1727,1728,
        1,0,0,0,1728,1726,1,0,0,0,1728,1729,1,0,0,0,1729,291,1,0,0,0,1730,
        1732,3,204,102,0,1731,1730,1,0,0,0,1731,1732,1,0,0,0,1732,1734,1,
        0,0,0,1733,1735,3,138,69,0,1734,1733,1,0,0,0,1734,1735,1,0,0,0,1735,
        1737,1,0,0,0,1736,1738,3,294,147,0,1737,1736,1,0,0,0,1737,1738,1,
        0,0,0,1738,1739,1,0,0,0,1739,1747,5,131,0,0,1740,1747,3,264,132,
        0,1741,1747,3,196,98,0,1742,1747,3,130,65,0,1743,1747,3,334,167,
        0,1744,1747,3,126,63,0,1745,1747,3,132,66,0,1746,1731,1,0,0,0,1746,
        1740,1,0,0,0,1746,1741,1,0,0,0,1746,1742,1,0,0,0,1746,1743,1,0,0,
        0,1746,1744,1,0,0,0,1746,1745,1,0,0,0,1747,293,1,0,0,0,1748,1753,
        3,296,148,0,1749,1750,5,125,0,0,1750,1752,3,296,148,0,1751,1749,
        1,0,0,0,1752,1755,1,0,0,0,1753,1751,1,0,0,0,1753,1754,1,0,0,0,1754,
        295,1,0,0,0,1755,1753,1,0,0,0,1756,1766,3,226,113,0,1757,1759,3,
        298,149,0,1758,1757,1,0,0,0,1758,1759,1,0,0,0,1759,1761,1,0,0,0,
        1760,1762,3,302,151,0,1761,1760,1,0,0,0,1761,1762,1,0,0,0,1762,1767,
        1,0,0,0,1763,1765,3,270,135,0,1764,1763,1,0,0,0,1764,1765,1,0,0,
        0,1765,1767,1,0,0,0,1766,1758,1,0,0,0,1766,1764,1,0,0,0,1767,1777,
        1,0,0,0,1768,1770,5,136,0,0,1769,1768,1,0,0,0,1769,1770,1,0,0,0,
        1770,1772,1,0,0,0,1771,1773,3,204,102,0,1772,1771,1,0,0,0,1772,1773,
        1,0,0,0,1773,1774,1,0,0,0,1774,1775,5,129,0,0,1775,1777,3,92,46,
        0,1776,1756,1,0,0,0,1776,1769,1,0,0,0,1777,297,1,0,0,0,1778,1780,
        3,300,150,0,1779,1778,1,0,0,0,1780,1781,1,0,0,0,1781,1779,1,0,0,
        0,1781,1782,1,0,0,0,1782,299,1,0,0,0,1783,1784,7,20,0,0,1784,301,
        1,0,0,0,1785,1786,5,104,0,0,1786,1787,5,74,0,0,1787,303,1,0,0,0,
        1788,1789,5,129,0,0,1789,1790,3,306,153,0,1790,305,1,0,0,0,1791,
        1793,3,308,154,0,1792,1794,5,134,0,0,1793,1792,1,0,0,0,1793,1794,
        1,0,0,0,1794,1802,1,0,0,0,1795,1796,5,125,0,0,1796,1798,3,308,154,
        0,1797,1799,5,134,0,0,1798,1797,1,0,0,0,1798,1799,1,0,0,0,1799,1801,
        1,0,0,0,1800,1795,1,0,0,0,1801,1804,1,0,0,0,1802,1800,1,0,0,0,1802,
        1803,1,0,0,0,1803,307,1,0,0,0,1804,1802,1,0,0,0,1805,1807,3,204,
        102,0,1806,1805,1,0,0,0,1806,1807,1,0,0,0,1807,1820,1,0,0,0,1808,
        1821,3,312,156,0,1809,1811,5,83,0,0,1810,1812,3,314,157,0,1811,1810,
        1,0,0,0,1811,1812,1,0,0,0,1812,1813,1,0,0,0,1813,1821,3,312,156,
        0,1814,1816,3,314,157,0,1815,1817,5,83,0,0,1816,1815,1,0,0,0,1816,
        1817,1,0,0,0,1817,1818,1,0,0,0,1818,1819,3,312,156,0,1819,1821,1,
        0,0,0,1820,1808,1,0,0,0,1820,1809,1,0,0,0,1820,1814,1,0,0,0,1821,
        309,1,0,0,0,1822,1824,3,10,5,0,1823,1822,1,0,0,0,1823,1824,1,0,0,
        0,1824,1825,1,0,0,0,1825,1828,3,278,139,0,1826,1828,3,162,81,0,1827,
        1823,1,0,0,0,1827,1826,1,0,0,0,1828,311,1,0,0,0,1829,1830,3,310,
        155,0,1830,313,1,0,0,0,1831,1832,7,21,0,0,1832,315,1,0,0,0,1833,
        1834,5,54,0,0,1834,1835,3,318,159,0,1835,317,1,0,0,0,1836,1838,3,
        150,75,0,1837,1839,3,320,160,0,1838,1837,1,0,0,0,1838,1839,1,0,0,
        0,1839,319,1,0,0,0,1840,1842,3,236,118,0,1841,1843,3,320,160,0,1842,
        1841,1,0,0,0,1842,1843,1,0,0,0,1843,321,1,0,0,0,1844,1845,5,129,
        0,0,1845,1846,3,324,162,0,1846,323,1,0,0,0,1847,1849,3,326,163,0,
        1848,1850,5,134,0,0,1849,1848,1,0,0,0,1849,1850,1,0,0,0,1850,1858,
        1,0,0,0,1851,1852,5,125,0,0,1852,1854,3,326,163,0,1853,1855,5,134,
        0,0,1854,1853,1,0,0,0,1854,1855,1,0,0,0,1855,1857,1,0,0,0,1856,1851,
        1,0,0,0,1857,1860,1,0,0,0,1858,1856,1,0,0,0,1858,1859,1,0,0,0,1859,
        325,1,0,0,0,1860,1858,1,0,0,0,1861,1868,3,328,164,0,1862,1864,5,
        88,0,0,1863,1865,3,34,17,0,1864,1863,1,0,0,0,1864,1865,1,0,0,0,1865,
        1866,1,0,0,0,1866,1869,5,89,0,0,1867,1869,3,276,138,0,1868,1862,
        1,0,0,0,1868,1867,1,0,0,0,1869,327,1,0,0,0,1870,1873,3,310,155,0,
        1871,1873,5,136,0,0,1872,1870,1,0,0,0,1872,1871,1,0,0,0,1873,329,
        1,0,0,0,1874,1875,5,54,0,0,1875,1876,3,380,190,0,1876,331,1,0,0,
        0,1877,1881,5,54,0,0,1878,1879,5,4,0,0,1879,1882,5,136,0,0,1880,
        1882,5,144,0,0,1881,1878,1,0,0,0,1881,1880,1,0,0,0,1882,333,1,0,
        0,0,1883,1884,5,70,0,0,1884,1885,5,105,0,0,1885,1886,3,336,168,0,
        1886,1887,5,106,0,0,1887,1888,3,122,61,0,1888,335,1,0,0,0,1889,1894,
        3,338,169,0,1890,1891,5,125,0,0,1891,1893,3,338,169,0,1892,1890,
        1,0,0,0,1893,1896,1,0,0,0,1894,1892,1,0,0,0,1894,1895,1,0,0,0,1895,
        337,1,0,0,0,1896,1894,1,0,0,0,1897,1900,3,340,170,0,1898,1900,3,
        262,131,0,1899,1897,1,0,0,0,1899,1898,1,0,0,0,1900,339,1,0,0,0,1901,
        1902,5,70,0,0,1902,1903,5,105,0,0,1903,1904,3,336,168,0,1904,1905,
        5,106,0,0,1905,1907,1,0,0,0,1906,1901,1,0,0,0,1906,1907,1,0,0,0,
        1907,1908,1,0,0,0,1908,1911,5,22,0,0,1909,1911,5,79,0,0,1910,1906,
        1,0,0,0,1910,1909,1,0,0,0,1911,1923,1,0,0,0,1912,1914,5,134,0,0,
        1913,1912,1,0,0,0,1913,1914,1,0,0,0,1914,1916,1,0,0,0,1915,1917,
        5,136,0,0,1916,1915,1,0,0,0,1916,1917,1,0,0,0,1917,1924,1,0,0,0,
        1918,1920,5,136,0,0,1919,1918,1,0,0,0,1919,1920,1,0,0,0,1920,1921,
        1,0,0,0,1921,1922,5,104,0,0,1922,1924,3,246,123,0,1923,1913,1,0,
        0,0,1923,1919,1,0,0,0,1924,341,1,0,0,0,1925,1926,3,346,173,0,1926,
        1928,5,105,0,0,1927,1929,3,348,174,0,1928,1927,1,0,0,0,1928,1929,
        1,0,0,0,1929,1930,1,0,0,0,1930,1931,5,106,0,0,1931,343,1,0,0,0,1932,
        1944,3,342,171,0,1933,1936,3,330,165,0,1934,1936,3,332,166,0,1935,
        1933,1,0,0,0,1935,1934,1,0,0,0,1936,1937,1,0,0,0,1937,1939,5,105,
        0,0,1938,1940,3,348,174,0,1939,1938,1,0,0,0,1939,1940,1,0,0,0,1940,
        1941,1,0,0,0,1941,1942,5,106,0,0,1942,1944,1,0,0,0,1943,1932,1,0,
        0,0,1943,1935,1,0,0,0,1944,345,1,0,0,0,1945,1946,5,136,0,0,1946,
        347,1,0,0,0,1947,1949,3,350,175,0,1948,1950,5,134,0,0,1949,1948,
        1,0,0,0,1949,1950,1,0,0,0,1950,1958,1,0,0,0,1951,1952,5,125,0,0,
        1952,1954,3,350,175,0,1953,1955,5,134,0,0,1954,1953,1,0,0,0,1954,
        1955,1,0,0,0,1955,1957,1,0,0,0,1956,1951,1,0,0,0,1957,1960,1,0,0,
        0,1958,1956,1,0,0,0,1958,1959,1,0,0,0,1959,349,1,0,0,0,1960,1958,
        1,0,0,0,1961,1965,3,246,123,0,1962,1965,3,92,46,0,1963,1965,3,4,
        2,0,1964,1961,1,0,0,0,1964,1962,1,0,0,0,1964,1963,1,0,0,0,1965,351,
        1,0,0,0,1966,1967,5,79,0,0,1967,1973,3,10,5,0,1968,1974,5,136,0,
        0,1969,1971,5,70,0,0,1970,1969,1,0,0,0,1970,1971,1,0,0,0,1971,1972,
        1,0,0,0,1972,1974,3,342,171,0,1973,1968,1,0,0,0,1973,1970,1,0,0,
        0,1974,353,1,0,0,0,1975,1977,5,38,0,0,1976,1975,1,0,0,0,1976,1977,
        1,0,0,0,1977,1978,1,0,0,0,1978,1979,5,70,0,0,1979,1980,3,122,61,
        0,1980,355,1,0,0,0,1981,1982,5,70,0,0,1982,1983,5,105,0,0,1983,1984,
        5,106,0,0,1984,1985,3,122,61,0,1985,357,1,0,0,0,1986,1987,5,76,0,
        0,1987,1988,3,100,50,0,1988,1989,3,362,181,0,1989,359,1,0,0,0,1990,
        1992,5,76,0,0,1991,1993,3,322,161,0,1992,1991,1,0,0,0,1992,1993,
        1,0,0,0,1993,1994,1,0,0,0,1994,1995,3,100,50,0,1995,1996,3,362,181,
        0,1996,361,1,0,0,0,1997,1999,3,364,182,0,1998,1997,1,0,0,0,1999,
        2000,1,0,0,0,2000,1998,1,0,0,0,2000,2001,1,0,0,0,2001,363,1,0,0,
        0,2002,2003,5,18,0,0,2003,2004,5,88,0,0,2004,2005,3,366,183,0,2005,
        2006,5,89,0,0,2006,2007,3,100,50,0,2007,365,1,0,0,0,2008,2010,3,
        204,102,0,2009,2008,1,0,0,0,2009,2010,1,0,0,0,2010,2011,1,0,0,0,
        2011,2014,3,150,75,0,2012,2015,3,226,113,0,2013,2015,3,248,124,0,
        2014,2012,1,0,0,0,2014,2013,1,0,0,0,2014,2015,1,0,0,0,2015,2018,
        1,0,0,0,2016,2018,5,134,0,0,2017,2009,1,0,0,0,2017,2016,1,0,0,0,
        2018,367,1,0,0,0,2019,2021,5,73,0,0,2020,2022,3,86,43,0,2021,2020,
        1,0,0,0,2021,2022,1,0,0,0,2022,369,1,0,0,0,2023,2026,3,372,186,0,
        2024,2026,3,376,188,0,2025,2023,1,0,0,0,2025,2024,1,0,0,0,2026,371,
        1,0,0,0,2027,2028,5,73,0,0,2028,2030,5,88,0,0,2029,2031,3,374,187,
        0,2030,2029,1,0,0,0,2030,2031,1,0,0,0,2031,2032,1,0,0,0,2032,2033,
        5,89,0,0,2033,373,1,0,0,0,2034,2036,3,246,123,0,2035,2037,5,134,
        0,0,2036,2035,1,0,0,0,2036,2037,1,0,0,0,2037,2045,1,0,0,0,2038,2039,
        5,125,0,0,2039,2041,3,246,123,0,2040,2042,5,134,0,0,2041,2040,1,
        0,0,0,2041,2042,1,0,0,0,2042,2044,1,0,0,0,2043,2038,1,0,0,0,2044,
        2047,1,0,0,0,2045,2043,1,0,0,0,2045,2046,1,0,0,0,2046,375,1,0,0,
        0,2047,2045,1,0,0,0,2048,2049,5,52,0,0,2049,2050,5,88,0,0,2050,2051,
        3,92,46,0,2051,2052,5,89,0,0,2052,2055,1,0,0,0,2053,2055,5,52,0,
        0,2054,2048,1,0,0,0,2054,2053,1,0,0,0,2055,377,1,0,0,0,2056,2057,
        5,135,0,0,2057,2060,5,29,0,0,2058,2061,5,136,0,0,2059,2061,3,226,
        113,0,2060,2058,1,0,0,0,2060,2059,1,0,0,0,2061,2062,1,0,0,0,2062,
        2063,3,2,1,0,2063,379,1,0,0,0,2064,2067,5,51,0,0,2065,2066,5,90,
        0,0,2066,2068,5,91,0,0,2067,2065,1,0,0,0,2067,2068,1,0,0,0,2068,
        2116,1,0,0,0,2069,2072,5,30,0,0,2070,2071,5,90,0,0,2071,2073,5,91,
        0,0,2072,2070,1,0,0,0,2072,2073,1,0,0,0,2073,2116,1,0,0,0,2074,2116,
        5,94,0,0,2075,2116,5,95,0,0,2076,2116,5,96,0,0,2077,2116,5,97,0,
        0,2078,2116,5,98,0,0,2079,2116,5,99,0,0,2080,2116,5,100,0,0,2081,
        2116,5,101,0,0,2082,2116,5,102,0,0,2083,2116,5,103,0,0,2084,2116,
        5,104,0,0,2085,2116,5,106,0,0,2086,2116,5,105,0,0,2087,2116,5,120,
        0,0,2088,2116,5,107,0,0,2089,2116,5,108,0,0,2090,2116,5,109,0,0,
        2091,2116,5,111,0,0,2092,2116,5,112,0,0,2093,2116,5,113,0,0,2094,
        2116,5,114,0,0,2095,2096,5,105,0,0,2096,2116,5,105,0,0,2097,2098,
        5,106,0,0,2098,2116,5,106,0,0,2099,2116,5,116,0,0,2100,2116,5,115,
        0,0,2101,2116,5,117,0,0,2102,2116,5,118,0,0,2103,2116,5,119,0,0,
        2104,2116,5,121,0,0,2105,2116,5,122,0,0,2106,2116,5,123,0,0,2107,
        2116,5,124,0,0,2108,2116,5,125,0,0,2109,2116,5,126,0,0,2110,2116,
        5,127,0,0,2111,2112,5,88,0,0,2112,2116,5,89,0,0,2113,2114,5,90,0,
        0,2114,2116,5,91,0,0,2115,2064,1,0,0,0,2115,2069,1,0,0,0,2115,2074,
        1,0,0,0,2115,2075,1,0,0,0,2115,2076,1,0,0,0,2115,2077,1,0,0,0,2115,
        2078,1,0,0,0,2115,2079,1,0,0,0,2115,2080,1,0,0,0,2115,2081,1,0,0,
        0,2115,2082,1,0,0,0,2115,2083,1,0,0,0,2115,2084,1,0,0,0,2115,2085,
        1,0,0,0,2115,2086,1,0,0,0,2115,2087,1,0,0,0,2115,2088,1,0,0,0,2115,
        2089,1,0,0,0,2115,2090,1,0,0,0,2115,2091,1,0,0,0,2115,2092,1,0,0,
        0,2115,2093,1,0,0,0,2115,2094,1,0,0,0,2115,2095,1,0,0,0,2115,2097,
        1,0,0,0,2115,2099,1,0,0,0,2115,2100,1,0,0,0,2115,2101,1,0,0,0,2115,
        2102,1,0,0,0,2115,2103,1,0,0,0,2115,2104,1,0,0,0,2115,2105,1,0,0,
        0,2115,2106,1,0,0,0,2115,2107,1,0,0,0,2115,2108,1,0,0,0,2115,2109,
        1,0,0,0,2115,2110,1,0,0,0,2115,2111,1,0,0,0,2115,2113,1,0,0,0,2116,
        381,1,0,0,0,2117,2118,7,22,0,0,2118,383,1,0,0,0,307,385,392,401,
        405,414,417,421,429,436,439,444,449,455,463,465,474,478,482,485,
        489,492,499,503,506,509,512,518,522,526,540,544,550,557,563,567,
        571,573,581,586,599,606,618,628,633,637,644,647,655,659,662,669,
        676,680,685,689,692,697,712,719,727,735,744,751,758,766,774,782,
        790,798,806,815,823,832,840,848,850,853,859,865,871,878,887,895,
        899,906,908,928,932,938,943,947,950,957,964,968,977,989,999,1004,
        1011,1014,1019,1024,1045,1050,1053,1064,1070,1075,1078,1083,1086,
        1093,1102,1107,1110,1114,1118,1122,1127,1132,1138,1144,1150,1156,
        1162,1165,1171,1175,1179,1182,1190,1192,1198,1201,1204,1207,1211,
        1215,1221,1231,1237,1243,1248,1253,1257,1270,1276,1280,1286,1291,
        1306,1310,1315,1320,1325,1331,1334,1343,1347,1352,1356,1362,1369,
        1386,1388,1395,1400,1407,1411,1415,1423,1429,1435,1439,1441,1445,
        1450,1454,1457,1460,1463,1468,1472,1475,1479,1482,1484,1489,1496,
        1502,1506,1512,1518,1521,1523,1529,1533,1539,1546,1550,1552,1556,
        1562,1574,1578,1580,1584,1589,1592,1599,1603,1608,1610,1614,1617,
        1620,1624,1629,1636,1643,1648,1652,1656,1661,1665,1671,1673,1679,
        1684,1690,1694,1696,1699,1703,1707,1709,1711,1714,1726,1728,1731,
        1734,1737,1746,1753,1758,1761,1764,1766,1769,1772,1776,1781,1793,
        1798,1802,1806,1811,1816,1820,1823,1827,1838,1842,1849,1854,1858,
        1864,1868,1872,1881,1894,1899,1906,1910,1913,1916,1919,1923,1928,
        1935,1939,1943,1949,1954,1958,1964,1970,1973,1976,1992,2000,2009,
        2014,2017,2021,2025,2030,2036,2041,2045,2054,2060,2067,2072,2115
    ]

class CPP14Parser ( Parser ):

    grammarFileName = "CPP14Parser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'alignas'", 
                     "'alignof'", "'asm'", "'auto'", "'bool'", "'break'", 
                     "'case'", "'catch'", "'char'", "'char16_t'", "'char32_t'", 
                     "'class'", "'const'", "'constexpr'", "'const_cast'", 
                     "'continue'", "'decltype'", "'default'", "'define'", 
                     "'delete'", "'do'", "'double'", "'dynamic_cast'", "'else'", 
                     "'enum'", "'explicit'", "'export'", "'extern'", "'false'", 
                     "'final'", "'float'", "'for'", "'friend'", "'goto'", 
                     "'if'", "'inline'", "'int'", "'long'", "'mutable'", 
                     "'namespace'", "'new'", "'noexcept'", "'nullptr'", 
                     "'operator'", "'override'", "'private'", "'protected'", 
                     "'public'", "'register'", "'reinterpret_cast'", "'return'", 
                     "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", 
                     "'static_cast'", "'struct'", "'switch'", "'template'", 
                     "'this'", "'thread_local'", "'throw'", "'0'", "'true'", 
                     "'try'", "'typedef'", "'typeid'", "'typename'", "'union'", 
                     "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", 
                     "'wchar_t'", "'while'", "'('", "')'", "'['", "']'", 
                     "'{'", "'}'", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", 
                     "'&'", "'|'", "'~'", "<INVALID>", "'='", "'<'", "'>'", 
                     "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", "'&='", 
                     "'|='", "'<<='", "'>>='", "'=='", "'!='", "'<='", "'>='", 
                     "<INVALID>", "<INVALID>", "'++'", "'--'", "','", "'->*'", 
                     "'->'", "'?'", "':'", "'::'", "';'", "'.'", "'.*'", 
                     "'...'", "'#'" ]

    symbolicNames = [ "<INVALID>", "IntegerLiteral", "CharacterLiteral", 
                      "FloatingLiteral", "StringLiteral", "BooleanLiteral", 
                      "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", 
                      "NonDefineDirectives", "Directive", "Alignas", "Alignof", 
                      "Asm", "Auto", "Bool", "Break", "Case", "Catch", "Char", 
                      "Char16", "Char32", "Class", "Const", "Constexpr", 
                      "Const_cast", "Continue", "Decltype", "Default", "Define", 
                      "Delete", "Do", "Double", "Dynamic_cast", "Else", 
                      "Enum", "Explicit", "Export", "Extern", "False_", 
                      "Final", "Float", "For", "Friend", "Goto", "If", "Inline", 
                      "Int", "Long", "Mutable", "Namespace", "New", "Noexcept", 
                      "Nullptr", "Operator", "Override", "Private", "Protected", 
                      "Public", "Register", "Reinterpret_cast", "Return", 
                      "Short", "Signed", "Sizeof", "Static", "Static_assert", 
                      "Static_cast", "Struct", "Switch", "Template", "This", 
                      "Thread_local", "Throw", "Zero", "True_", "Try", "Typedef", 
                      "Typeid_", "Typename_", "Union", "Unsigned", "Using", 
                      "Virtual", "Void", "Volatile", "Wchar", "While", "LeftParen", 
                      "RightParen", "LeftBracket", "RightBracket", "LeftBrace", 
                      "RightBrace", "Plus", "Minus", "Star", "Div", "Mod", 
                      "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", 
                      "Greater", "PlusAssign", "MinusAssign", "StarAssign", 
                      "DivAssign", "ModAssign", "XorAssign", "AndAssign", 
                      "OrAssign", "LeftShiftAssign", "RightShiftAssign", 
                      "Equal", "NotEqual", "LessEqual", "GreaterEqual", 
                      "AndAnd", "OrOr", "PlusPlus", "MinusMinus", "Comma", 
                      "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", 
                      "Semi", "Dot", "DotStar", "Ellipsis", "Pound", "Identifier", 
                      "DecimalLiteral", "OctalLiteral", "HexadecimalLiteral", 
                      "BinaryLiteral", "Integersuffix", "UserDefinedIntegerLiteral", 
                      "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", 
                      "UserDefinedCharacterLiteral", "Whitespace", "Newline", 
                      "BlockComment", "LineComment" ]

    RULE_translationUnit = 0
    RULE_primaryExpression = 1
    RULE_idExpression = 2
    RULE_unqualifiedId = 3
    RULE_qualifiedId = 4
    RULE_nestedNameSpecifier = 5
    RULE_lambdaExpression = 6
    RULE_lambdaIntroducer = 7
    RULE_lambdaCapture = 8
    RULE_captureDefault = 9
    RULE_captureList = 10
    RULE_capture = 11
    RULE_simpleCapture = 12
    RULE_initcapture = 13
    RULE_lambdaDeclarator = 14
    RULE_postfixExpression = 15
    RULE_typeIdOfTheTypeId = 16
    RULE_expressionList = 17
    RULE_pseudoDestructorName = 18
    RULE_unaryExpression = 19
    RULE_unaryOperator = 20
    RULE_newExpression = 21
    RULE_newPlacement = 22
    RULE_newTypeId = 23
    RULE_newDeclarator = 24
    RULE_noPointerNewDeclarator = 25
    RULE_newInitializer = 26
    RULE_deleteExpression = 27
    RULE_noExceptExpression = 28
    RULE_castExpression = 29
    RULE_pointerMemberExpression = 30
    RULE_multiplicativeExpression = 31
    RULE_additiveExpression = 32
    RULE_shiftExpression = 33
    RULE_shiftOperator = 34
    RULE_relationalExpression = 35
    RULE_equalityExpression = 36
    RULE_andExpression = 37
    RULE_exclusiveOrExpression = 38
    RULE_inclusiveOrExpression = 39
    RULE_logicalAndExpression = 40
    RULE_logicalOrExpression = 41
    RULE_conditionalExpression = 42
    RULE_assignmentExpression = 43
    RULE_assignmentOperator = 44
    RULE_expression = 45
    RULE_constantExpression = 46
    RULE_statement = 47
    RULE_labeledStatement = 48
    RULE_expressionStatement = 49
    RULE_compoundStatement = 50
    RULE_statementSeq = 51
    RULE_selectionStatement = 52
    RULE_condition = 53
    RULE_iterationStatement = 54
    RULE_forInitStatement = 55
    RULE_forRangeDeclaration = 56
    RULE_forRangeInitializer = 57
    RULE_jumpStatement = 58
    RULE_declarationStatement = 59
    RULE_declarationseq = 60
    RULE_declaration = 61
    RULE_blockDeclaration = 62
    RULE_aliasDeclaration = 63
    RULE_simpleDeclaration = 64
    RULE_staticAssertDeclaration = 65
    RULE_emptyDeclaration = 66
    RULE_attributeDeclaration = 67
    RULE_declSpecifier = 68
    RULE_declSpecifierSeq = 69
    RULE_storageClassSpecifier = 70
    RULE_functionSpecifier = 71
    RULE_typedefName = 72
    RULE_typeSpecifier = 73
    RULE_trailingTypeSpecifier = 74
    RULE_typeSpecifierSeq = 75
    RULE_trailingTypeSpecifierSeq = 76
    RULE_simpleTypeLengthModifier = 77
    RULE_simpleTypeSignednessModifier = 78
    RULE_simpleTypeSpecifier = 79
    RULE_theTypeName = 80
    RULE_decltypeSpecifier = 81
    RULE_elaboratedTypeSpecifier = 82
    RULE_enumName = 83
    RULE_enumSpecifier = 84
    RULE_enumHead = 85
    RULE_opaqueEnumDeclaration = 86
    RULE_enumkey = 87
    RULE_enumbase = 88
    RULE_enumeratorList = 89
    RULE_enumeratorDefinition = 90
    RULE_enumerator = 91
    RULE_namespaceName = 92
    RULE_originalNamespaceName = 93
    RULE_namespaceDefinition = 94
    RULE_namespaceAlias = 95
    RULE_namespaceAliasDefinition = 96
    RULE_qualifiednamespacespecifier = 97
    RULE_usingDeclaration = 98
    RULE_usingDirective = 99
    RULE_asmDefinition = 100
    RULE_linkageSpecification = 101
    RULE_attributeSpecifierSeq = 102
    RULE_attributeSpecifier = 103
    RULE_alignmentspecifier = 104
    RULE_attributeList = 105
    RULE_attribute = 106
    RULE_attributeNamespace = 107
    RULE_attributeArgumentClause = 108
    RULE_balancedTokenSeq = 109
    RULE_balancedtoken = 110
    RULE_initDeclaratorList = 111
    RULE_initDeclarator = 112
    RULE_declarator = 113
    RULE_pointerDeclarator = 114
    RULE_noPointerDeclarator = 115
    RULE_parametersAndQualifiers = 116
    RULE_trailingReturnType = 117
    RULE_pointerOperator = 118
    RULE_cvqualifierseq = 119
    RULE_cvQualifier = 120
    RULE_refqualifier = 121
    RULE_declaratorid = 122
    RULE_theTypeId = 123
    RULE_abstractDeclarator = 124
    RULE_pointerAbstractDeclarator = 125
    RULE_noPointerAbstractDeclarator = 126
    RULE_abstractPackDeclarator = 127
    RULE_noPointerAbstractPackDeclarator = 128
    RULE_parameterDeclarationClause = 129
    RULE_parameterDeclarationList = 130
    RULE_parameterDeclaration = 131
    RULE_functionDefinition = 132
    RULE_functionBody = 133
    RULE_initializer = 134
    RULE_braceOrEqualInitializer = 135
    RULE_initializerClause = 136
    RULE_initializerList = 137
    RULE_bracedInitList = 138
    RULE_className = 139
    RULE_classSpecifier = 140
    RULE_classHead = 141
    RULE_classHeadName = 142
    RULE_classVirtSpecifier = 143
    RULE_classKey = 144
    RULE_memberSpecification = 145
    RULE_memberdeclaration = 146
    RULE_memberDeclaratorList = 147
    RULE_memberDeclarator = 148
    RULE_virtualSpecifierSeq = 149
    RULE_virtualSpecifier = 150
    RULE_pureSpecifier = 151
    RULE_baseClause = 152
    RULE_baseSpecifierList = 153
    RULE_baseSpecifier = 154
    RULE_classOrDeclType = 155
    RULE_baseTypeSpecifier = 156
    RULE_accessSpecifier = 157
    RULE_conversionFunctionId = 158
    RULE_conversionTypeId = 159
    RULE_conversionDeclarator = 160
    RULE_constructorInitializer = 161
    RULE_memInitializerList = 162
    RULE_memInitializer = 163
    RULE_meminitializerid = 164
    RULE_operatorFunctionId = 165
    RULE_literalOperatorId = 166
    RULE_templateDeclaration = 167
    RULE_templateparameterList = 168
    RULE_templateParameter = 169
    RULE_typeParameter = 170
    RULE_simpleTemplateId = 171
    RULE_templateId = 172
    RULE_templateName = 173
    RULE_templateArgumentList = 174
    RULE_templateArgument = 175
    RULE_typeNameSpecifier = 176
    RULE_explicitInstantiation = 177
    RULE_explicitSpecialization = 178
    RULE_tryBlock = 179
    RULE_functionTryBlock = 180
    RULE_handlerSeq = 181
    RULE_handler = 182
    RULE_exceptionDeclaration = 183
    RULE_throwExpression = 184
    RULE_exceptionSpecification = 185
    RULE_dynamicExceptionSpecification = 186
    RULE_typeIdList = 187
    RULE_noeExceptSpecification = 188
    RULE_define = 189
    RULE_theOperator = 190
    RULE_literal = 191

    ruleNames =  [ "translationUnit", "primaryExpression", "idExpression", 
                   "unqualifiedId", "qualifiedId", "nestedNameSpecifier", 
                   "lambdaExpression", "lambdaIntroducer", "lambdaCapture", 
                   "captureDefault", "captureList", "capture", "simpleCapture", 
                   "initcapture", "lambdaDeclarator", "postfixExpression", 
                   "typeIdOfTheTypeId", "expressionList", "pseudoDestructorName", 
                   "unaryExpression", "unaryOperator", "newExpression", 
                   "newPlacement", "newTypeId", "newDeclarator", "noPointerNewDeclarator", 
                   "newInitializer", "deleteExpression", "noExceptExpression", 
                   "castExpression", "pointerMemberExpression", "multiplicativeExpression", 
                   "additiveExpression", "shiftExpression", "shiftOperator", 
                   "relationalExpression", "equalityExpression", "andExpression", 
                   "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression", 
                   "logicalOrExpression", "conditionalExpression", "assignmentExpression", 
                   "assignmentOperator", "expression", "constantExpression", 
                   "statement", "labeledStatement", "expressionStatement", 
                   "compoundStatement", "statementSeq", "selectionStatement", 
                   "condition", "iterationStatement", "forInitStatement", 
                   "forRangeDeclaration", "forRangeInitializer", "jumpStatement", 
                   "declarationStatement", "declarationseq", "declaration", 
                   "blockDeclaration", "aliasDeclaration", "simpleDeclaration", 
                   "staticAssertDeclaration", "emptyDeclaration", "attributeDeclaration", 
                   "declSpecifier", "declSpecifierSeq", "storageClassSpecifier", 
                   "functionSpecifier", "typedefName", "typeSpecifier", 
                   "trailingTypeSpecifier", "typeSpecifierSeq", "trailingTypeSpecifierSeq", 
                   "simpleTypeLengthModifier", "simpleTypeSignednessModifier", 
                   "simpleTypeSpecifier", "theTypeName", "decltypeSpecifier", 
                   "elaboratedTypeSpecifier", "enumName", "enumSpecifier", 
                   "enumHead", "opaqueEnumDeclaration", "enumkey", "enumbase", 
                   "enumeratorList", "enumeratorDefinition", "enumerator", 
                   "namespaceName", "originalNamespaceName", "namespaceDefinition", 
                   "namespaceAlias", "namespaceAliasDefinition", "qualifiednamespacespecifier", 
                   "usingDeclaration", "usingDirective", "asmDefinition", 
                   "linkageSpecification", "attributeSpecifierSeq", "attributeSpecifier", 
                   "alignmentspecifier", "attributeList", "attribute", "attributeNamespace", 
                   "attributeArgumentClause", "balancedTokenSeq", "balancedtoken", 
                   "initDeclaratorList", "initDeclarator", "declarator", 
                   "pointerDeclarator", "noPointerDeclarator", "parametersAndQualifiers", 
                   "trailingReturnType", "pointerOperator", "cvqualifierseq", 
                   "cvQualifier", "refqualifier", "declaratorid", "theTypeId", 
                   "abstractDeclarator", "pointerAbstractDeclarator", "noPointerAbstractDeclarator", 
                   "abstractPackDeclarator", "noPointerAbstractPackDeclarator", 
                   "parameterDeclarationClause", "parameterDeclarationList", 
                   "parameterDeclaration", "functionDefinition", "functionBody", 
                   "initializer", "braceOrEqualInitializer", "initializerClause", 
                   "initializerList", "bracedInitList", "className", "classSpecifier", 
                   "classHead", "classHeadName", "classVirtSpecifier", "classKey", 
                   "memberSpecification", "memberdeclaration", "memberDeclaratorList", 
                   "memberDeclarator", "virtualSpecifierSeq", "virtualSpecifier", 
                   "pureSpecifier", "baseClause", "baseSpecifierList", "baseSpecifier", 
                   "classOrDeclType", "baseTypeSpecifier", "accessSpecifier", 
                   "conversionFunctionId", "conversionTypeId", "conversionDeclarator", 
                   "constructorInitializer", "memInitializerList", "memInitializer", 
                   "meminitializerid", "operatorFunctionId", "literalOperatorId", 
                   "templateDeclaration", "templateparameterList", "templateParameter", 
                   "typeParameter", "simpleTemplateId", "templateId", "templateName", 
                   "templateArgumentList", "templateArgument", "typeNameSpecifier", 
                   "explicitInstantiation", "explicitSpecialization", "tryBlock", 
                   "functionTryBlock", "handlerSeq", "handler", "exceptionDeclaration", 
                   "throwExpression", "exceptionSpecification", "dynamicExceptionSpecification", 
                   "typeIdList", "noeExceptSpecification", "define", "theOperator", 
                   "literal" ]

    EOF = Token.EOF
    IntegerLiteral=1
    CharacterLiteral=2
    FloatingLiteral=3
    StringLiteral=4
    BooleanLiteral=5
    PointerLiteral=6
    UserDefinedLiteral=7
    MultiLineMacro=8
    NonDefineDirectives=9
    Directive=10
    Alignas=11
    Alignof=12
    Asm=13
    Auto=14
    Bool=15
    Break=16
    Case=17
    Catch=18
    Char=19
    Char16=20
    Char32=21
    Class=22
    Const=23
    Constexpr=24
    Const_cast=25
    Continue=26
    Decltype=27
    Default=28
    Define=29
    Delete=30
    Do=31
    Double=32
    Dynamic_cast=33
    Else=34
    Enum=35
    Explicit=36
    Export=37
    Extern=38
    False_=39
    Final=40
    Float=41
    For=42
    Friend=43
    Goto=44
    If=45
    Inline=46
    Int=47
    Long=48
    Mutable=49
    Namespace=50
    New=51
    Noexcept=52
    Nullptr=53
    Operator=54
    Override=55
    Private=56
    Protected=57
    Public=58
    Register=59
    Reinterpret_cast=60
    Return=61
    Short=62
    Signed=63
    Sizeof=64
    Static=65
    Static_assert=66
    Static_cast=67
    Struct=68
    Switch=69
    Template=70
    This=71
    Thread_local=72
    Throw=73
    Zero=74
    True_=75
    Try=76
    Typedef=77
    Typeid_=78
    Typename_=79
    Union=80
    Unsigned=81
    Using=82
    Virtual=83
    Void=84
    Volatile=85
    Wchar=86
    While=87
    LeftParen=88
    RightParen=89
    LeftBracket=90
    RightBracket=91
    LeftBrace=92
    RightBrace=93
    Plus=94
    Minus=95
    Star=96
    Div=97
    Mod=98
    Caret=99
    And=100
    Or=101
    Tilde=102
    Not=103
    Assign=104
    Less=105
    Greater=106
    PlusAssign=107
    MinusAssign=108
    StarAssign=109
    DivAssign=110
    ModAssign=111
    XorAssign=112
    AndAssign=113
    OrAssign=114
    LeftShiftAssign=115
    RightShiftAssign=116
    Equal=117
    NotEqual=118
    LessEqual=119
    GreaterEqual=120
    AndAnd=121
    OrOr=122
    PlusPlus=123
    MinusMinus=124
    Comma=125
    ArrowStar=126
    Arrow=127
    Question=128
    Colon=129
    Doublecolon=130
    Semi=131
    Dot=132
    DotStar=133
    Ellipsis=134
    Pound=135
    Identifier=136
    DecimalLiteral=137
    OctalLiteral=138
    HexadecimalLiteral=139
    BinaryLiteral=140
    Integersuffix=141
    UserDefinedIntegerLiteral=142
    UserDefinedFloatingLiteral=143
    UserDefinedStringLiteral=144
    UserDefinedCharacterLiteral=145
    Whitespace=146
    Newline=147
    BlockComment=148
    LineComment=149

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.11.1")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class TranslationUnitContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(CPP14Parser.EOF, 0)

        def declarationseq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_translationUnit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTranslationUnit" ):
                listener.enterTranslationUnit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTranslationUnit" ):
                listener.exitTranslationUnit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTranslationUnit" ):
                return visitor.visitTranslationUnit(self)
            else:
                return visitor.visitChildren(self)




    def translationUnit(self):

        localctx = CPP14Parser.TranslationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 385
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 3087508886339534621) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 1035845506523737085) != 0:
                self.state = 384
                self.declarationseq()


            self.state = 387
            self.match(CPP14Parser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.LiteralContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.LiteralContext,i)


        def This(self):
            return self.getToken(CPP14Parser.This, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def lambdaExpression(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_primaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrimaryExpression" ):
                listener.enterPrimaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrimaryExpression" ):
                listener.exitPrimaryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimaryExpression" ):
                return visitor.visitPrimaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def primaryExpression(self):

        localctx = CPP14Parser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_primaryExpression)
        try:
            self.state = 401
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7]:
                self.enterOuterAlt(localctx, 1)
                self.state = 390 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 389
                        self.literal()

                    else:
                        raise NoViableAltException(self)
                    self.state = 392 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,1,self._ctx)

                pass
            elif token in [71]:
                self.enterOuterAlt(localctx, 2)
                self.state = 394
                self.match(CPP14Parser.This)
                pass
            elif token in [88]:
                self.enterOuterAlt(localctx, 3)
                self.state = 395
                self.match(CPP14Parser.LeftParen)
                self.state = 396
                self.expression()
                self.state = 397
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [27, 54, 102, 130, 136]:
                self.enterOuterAlt(localctx, 4)
                self.state = 399
                self.idExpression()
                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 5)
                self.state = 400
                self.lambdaExpression()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unqualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.UnqualifiedIdContext,0)


        def qualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.QualifiedIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_idExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdExpression" ):
                listener.enterIdExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdExpression" ):
                listener.exitIdExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIdExpression" ):
                return visitor.visitIdExpression(self)
            else:
                return visitor.visitChildren(self)




    def idExpression(self):

        localctx = CPP14Parser.IdExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_idExpression)
        try:
            self.state = 405
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 403
                self.unqualifiedId()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 404
                self.qualifiedId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnqualifiedIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def operatorFunctionId(self):
            return self.getTypedRuleContext(CPP14Parser.OperatorFunctionIdContext,0)


        def conversionFunctionId(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionFunctionIdContext,0)


        def literalOperatorId(self):
            return self.getTypedRuleContext(CPP14Parser.LiteralOperatorIdContext,0)


        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def templateId(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_unqualifiedId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnqualifiedId" ):
                listener.enterUnqualifiedId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnqualifiedId" ):
                listener.exitUnqualifiedId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnqualifiedId" ):
                return visitor.visitUnqualifiedId(self)
            else:
                return visitor.visitChildren(self)




    def unqualifiedId(self):

        localctx = CPP14Parser.UnqualifiedIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_unqualifiedId)
        try:
            self.state = 417
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 407
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 408
                self.operatorFunctionId()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 409
                self.conversionFunctionId()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 410
                self.literalOperatorId()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 411
                self.match(CPP14Parser.Tilde)
                self.state = 414
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [136]:
                    self.state = 412
                    self.className()
                    pass
                elif token in [27]:
                    self.state = 413
                    self.decltypeSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 416
                self.templateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def unqualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.UnqualifiedIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_qualifiedId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualifiedId" ):
                listener.enterQualifiedId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualifiedId" ):
                listener.exitQualifiedId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiedId" ):
                return visitor.visitQualifiedId(self)
            else:
                return visitor.visitChildren(self)




    def qualifiedId(self):

        localctx = CPP14Parser.QualifiedIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_qualifiedId)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self.nestedNameSpecifier(0)
            self.state = 421
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==70:
                self.state = 420
                self.match(CPP14Parser.Template)


            self.state = 423
            self.unqualifiedId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NestedNameSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def theTypeName(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeNameContext,0)


        def namespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceNameContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_nestedNameSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNestedNameSpecifier" ):
                listener.enterNestedNameSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNestedNameSpecifier" ):
                listener.exitNestedNameSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNestedNameSpecifier" ):
                return visitor.visitNestedNameSpecifier(self)
            else:
                return visitor.visitChildren(self)



    def nestedNameSpecifier(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NestedNameSpecifierContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 10
        self.enterRecursionRule(localctx, 10, self.RULE_nestedNameSpecifier, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 426
                self.theTypeName()

            elif la_ == 2:
                self.state = 427
                self.namespaceName()

            elif la_ == 3:
                self.state = 428
                self.decltypeSpecifier()


            self.state = 431
            self.match(CPP14Parser.Doublecolon)
            self._ctx.stop = self._input.LT(-1)
            self.state = 444
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NestedNameSpecifierContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_nestedNameSpecifier)
                    self.state = 433
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 439
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
                    if la_ == 1:
                        self.state = 434
                        self.match(CPP14Parser.Identifier)
                        pass

                    elif la_ == 2:
                        self.state = 436
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==70:
                            self.state = 435
                            self.match(CPP14Parser.Template)


                        self.state = 438
                        self.simpleTemplateId()
                        pass


                    self.state = 441
                    self.match(CPP14Parser.Doublecolon) 
                self.state = 446
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class LambdaExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def lambdaIntroducer(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaIntroducerContext,0)


        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def lambdaDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaExpression" ):
                listener.enterLambdaExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaExpression" ):
                listener.exitLambdaExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaExpression" ):
                return visitor.visitLambdaExpression(self)
            else:
                return visitor.visitChildren(self)




    def lambdaExpression(self):

        localctx = CPP14Parser.LambdaExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_lambdaExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 447
            self.lambdaIntroducer()
            self.state = 449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==88:
                self.state = 448
                self.lambdaDeclarator()


            self.state = 451
            self.compoundStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaIntroducerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def lambdaCapture(self):
            return self.getTypedRuleContext(CPP14Parser.LambdaCaptureContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaIntroducer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaIntroducer" ):
                listener.enterLambdaIntroducer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaIntroducer" ):
                listener.exitLambdaIntroducer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaIntroducer" ):
                return visitor.visitLambdaIntroducer(self)
            else:
                return visitor.visitChildren(self)




    def lambdaIntroducer(self):

        localctx = CPP14Parser.LambdaIntroducerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_lambdaIntroducer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 453
            self.match(CPP14Parser.LeftBracket)
            self.state = 455
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 9126805505) != 0 or _la==136:
                self.state = 454
                self.lambdaCapture()


            self.state = 457
            self.match(CPP14Parser.RightBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaCaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def captureList(self):
            return self.getTypedRuleContext(CPP14Parser.CaptureListContext,0)


        def captureDefault(self):
            return self.getTypedRuleContext(CPP14Parser.CaptureDefaultContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaCapture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaCapture" ):
                listener.enterLambdaCapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaCapture" ):
                listener.exitLambdaCapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaCapture" ):
                return visitor.visitLambdaCapture(self)
            else:
                return visitor.visitChildren(self)




    def lambdaCapture(self):

        localctx = CPP14Parser.LambdaCaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_lambdaCapture)
        self._la = 0 # Token type
        try:
            self.state = 465
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 459
                self.captureList()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 460
                self.captureDefault()
                self.state = 463
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==125:
                    self.state = 461
                    self.match(CPP14Parser.Comma)
                    self.state = 462
                    self.captureList()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaptureDefaultContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_captureDefault

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaptureDefault" ):
                listener.enterCaptureDefault(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaptureDefault" ):
                listener.exitCaptureDefault(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCaptureDefault" ):
                return visitor.visitCaptureDefault(self)
            else:
                return visitor.visitChildren(self)




    def captureDefault(self):

        localctx = CPP14Parser.CaptureDefaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_captureDefault)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 467
            _la = self._input.LA(1)
            if not(_la==100 or _la==104):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaptureListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def capture(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.CaptureContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.CaptureContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_captureList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaptureList" ):
                listener.enterCaptureList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaptureList" ):
                listener.exitCaptureList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCaptureList" ):
                return visitor.visitCaptureList(self)
            else:
                return visitor.visitChildren(self)




    def captureList(self):

        localctx = CPP14Parser.CaptureListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_captureList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self.capture()
            self.state = 474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 470
                self.match(CPP14Parser.Comma)
                self.state = 471
                self.capture()
                self.state = 476
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 477
                self.match(CPP14Parser.Ellipsis)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleCapture(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleCaptureContext,0)


        def initcapture(self):
            return self.getTypedRuleContext(CPP14Parser.InitcaptureContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_capture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCapture" ):
                listener.enterCapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCapture" ):
                listener.exitCapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCapture" ):
                return visitor.visitCapture(self)
            else:
                return visitor.visitChildren(self)




    def capture(self):

        localctx = CPP14Parser.CaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_capture)
        try:
            self.state = 482
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 480
                self.simpleCapture()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 481
                self.initcapture()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleCaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def This(self):
            return self.getToken(CPP14Parser.This, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleCapture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleCapture" ):
                listener.enterSimpleCapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleCapture" ):
                listener.exitSimpleCapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleCapture" ):
                return visitor.visitSimpleCapture(self)
            else:
                return visitor.visitChildren(self)




    def simpleCapture(self):

        localctx = CPP14Parser.SimpleCaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_simpleCapture)
        self._la = 0 # Token type
        try:
            self.state = 489
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [100, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 485
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==100:
                    self.state = 484
                    self.match(CPP14Parser.And)


                self.state = 487
                self.match(CPP14Parser.Identifier)
                pass
            elif token in [71]:
                self.enterOuterAlt(localctx, 2)
                self.state = 488
                self.match(CPP14Parser.This)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitcaptureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def initializer(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerContext,0)


        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initcapture

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitcapture" ):
                listener.enterInitcapture(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitcapture" ):
                listener.exitInitcapture(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitcapture" ):
                return visitor.visitInitcapture(self)
            else:
                return visitor.visitChildren(self)




    def initcapture(self):

        localctx = CPP14Parser.InitcaptureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_initcapture)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==100:
                self.state = 491
                self.match(CPP14Parser.And)


            self.state = 494
            self.match(CPP14Parser.Identifier)
            self.state = 495
            self.initializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def parameterDeclarationClause(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationClauseContext,0)


        def Mutable(self):
            return self.getToken(CPP14Parser.Mutable, 0)

        def exceptionSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.ExceptionSpecificationContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def trailingReturnType(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingReturnTypeContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_lambdaDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLambdaDeclarator" ):
                listener.enterLambdaDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLambdaDeclarator" ):
                listener.exitLambdaDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLambdaDeclarator" ):
                return visitor.visitLambdaDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def lambdaDeclarator(self):

        localctx = CPP14Parser.LambdaDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_lambdaDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 497
            self.match(CPP14Parser.LeftParen)
            self.state = 499
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 2475009991168311065) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 585467951558173661) != 0:
                self.state = 498
                self.parameterDeclarationClause()


            self.state = 501
            self.match(CPP14Parser.RightParen)
            self.state = 503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==49:
                self.state = 502
                self.match(CPP14Parser.Mutable)


            self.state = 506
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==52 or _la==73:
                self.state = 505
                self.exceptionSpecification()


            self.state = 509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 508
                self.attributeSpecifierSeq()


            self.state = 512
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==127:
                self.state = 511
                self.trailingReturnType()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PostfixExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def primaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PrimaryExpressionContext,0)


        def simpleTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTypeSpecifierContext,0)


        def typeNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TypeNameSpecifierContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Dynamic_cast(self):
            return self.getToken(CPP14Parser.Dynamic_cast, 0)

        def Static_cast(self):
            return self.getToken(CPP14Parser.Static_cast, 0)

        def Reinterpret_cast(self):
            return self.getToken(CPP14Parser.Reinterpret_cast, 0)

        def Const_cast(self):
            return self.getToken(CPP14Parser.Const_cast, 0)

        def typeIdOfTheTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TypeIdOfTheTypeIdContext,0)


        def postfixExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PostfixExpressionContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def Dot(self):
            return self.getToken(CPP14Parser.Dot, 0)

        def Arrow(self):
            return self.getToken(CPP14Parser.Arrow, 0)

        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def pseudoDestructorName(self):
            return self.getTypedRuleContext(CPP14Parser.PseudoDestructorNameContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def PlusPlus(self):
            return self.getToken(CPP14Parser.PlusPlus, 0)

        def MinusMinus(self):
            return self.getToken(CPP14Parser.MinusMinus, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_postfixExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPostfixExpression" ):
                listener.enterPostfixExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPostfixExpression" ):
                listener.exitPostfixExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPostfixExpression" ):
                return visitor.visitPostfixExpression(self)
            else:
                return visitor.visitChildren(self)



    def postfixExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.PostfixExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 30
        self.enterRecursionRule(localctx, 30, self.RULE_postfixExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 515
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.state = 518
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [14, 15, 19, 20, 21, 27, 32, 41, 47, 48, 62, 63, 81, 84, 86, 130, 136]:
                    self.state = 516
                    self.simpleTypeSpecifier()
                    pass
                elif token in [79]:
                    self.state = 517
                    self.typeNameSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 526
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [88]:
                    self.state = 520
                    self.match(CPP14Parser.LeftParen)
                    self.state = 522
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295576359561) != 0 or _la==130 or _la==136:
                        self.state = 521
                        self.expressionList()


                    self.state = 524
                    self.match(CPP14Parser.RightParen)
                    pass
                elif token in [92]:
                    self.state = 525
                    self.bracedInitList()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 3:
                self.state = 528
                _la = self._input.LA(1)
                if not((((_la - 25)) & ~0x3f) == 0 and ((1 << (_la - 25)) & 4432406249729) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 529
                self.match(CPP14Parser.Less)
                self.state = 530
                self.theTypeId()
                self.state = 531
                self.match(CPP14Parser.Greater)
                self.state = 532
                self.match(CPP14Parser.LeftParen)
                self.state = 533
                self.expression()
                self.state = 534
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 4:
                self.state = 536
                self.typeIdOfTheTypeId()
                self.state = 537
                self.match(CPP14Parser.LeftParen)
                self.state = 540
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
                if la_ == 1:
                    self.state = 538
                    self.expression()
                    pass

                elif la_ == 2:
                    self.state = 539
                    self.theTypeId()
                    pass


                self.state = 542
                self.match(CPP14Parser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 573
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 571
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                    if la_ == 1:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 546
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 547
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 550
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [1, 2, 3, 4, 5, 6, 7, 12, 14, 15, 19, 20, 21, 25, 27, 30, 32, 33, 41, 47, 48, 51, 52, 54, 60, 62, 63, 64, 67, 71, 73, 78, 79, 81, 84, 86, 88, 90, 94, 95, 96, 100, 101, 102, 103, 123, 124, 130, 136]:
                            self.state = 548
                            self.expression()
                            pass
                        elif token in [92]:
                            self.state = 549
                            self.bracedInitList()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 552
                        self.match(CPP14Parser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 554
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 555
                        self.match(CPP14Parser.LeftParen)
                        self.state = 557
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295576359561) != 0 or _la==130 or _la==136:
                            self.state = 556
                            self.expressionList()


                        self.state = 559
                        self.match(CPP14Parser.RightParen)
                        pass

                    elif la_ == 3:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 560
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 561
                        _la = self._input.LA(1)
                        if not(_la==127 or _la==132):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 567
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                        if la_ == 1:
                            self.state = 563
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if _la==70:
                                self.state = 562
                                self.match(CPP14Parser.Template)


                            self.state = 565
                            self.idExpression()
                            pass

                        elif la_ == 2:
                            self.state = 566
                            self.pseudoDestructorName()
                            pass


                        pass

                    elif la_ == 4:
                        localctx = CPP14Parser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 569
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 570
                        _la = self._input.LA(1)
                        if not(_la==123 or _la==124):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

             
                self.state = 575
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class TypeIdOfTheTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Typeid_(self):
            return self.getToken(CPP14Parser.Typeid_, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeIdOfTheTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeIdOfTheTypeId" ):
                listener.enterTypeIdOfTheTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeIdOfTheTypeId" ):
                listener.exitTypeIdOfTheTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeIdOfTheTypeId" ):
                return visitor.visitTypeIdOfTheTypeId(self)
            else:
                return visitor.visitChildren(self)




    def typeIdOfTheTypeId(self):

        localctx = CPP14Parser.TypeIdOfTheTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_typeIdOfTheTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(CPP14Parser.Typeid_)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def initializerList(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_expressionList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionList" ):
                listener.enterExpressionList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionList" ):
                listener.exitExpressionList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionList" ):
                return visitor.visitExpressionList(self)
            else:
                return visitor.visitChildren(self)




    def expressionList(self):

        localctx = CPP14Parser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_expressionList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            self.initializerList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PseudoDestructorNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def theTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TheTypeNameContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TheTypeNameContext,i)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_pseudoDestructorName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPseudoDestructorName" ):
                listener.enterPseudoDestructorName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPseudoDestructorName" ):
                listener.exitPseudoDestructorName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPseudoDestructorName" ):
                return visitor.visitPseudoDestructorName(self)
            else:
                return visitor.visitChildren(self)




    def pseudoDestructorName(self):

        localctx = CPP14Parser.PseudoDestructorNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_pseudoDestructorName)
        self._la = 0 # Token type
        try:
            self.state = 599
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 581
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                if la_ == 1:
                    self.state = 580
                    self.nestedNameSpecifier(0)


                self.state = 586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==136:
                    self.state = 583
                    self.theTypeName()
                    self.state = 584
                    self.match(CPP14Parser.Doublecolon)


                self.state = 588
                self.match(CPP14Parser.Tilde)
                self.state = 589
                self.theTypeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 590
                self.nestedNameSpecifier(0)
                self.state = 591
                self.match(CPP14Parser.Template)
                self.state = 592
                self.simpleTemplateId()
                self.state = 593
                self.match(CPP14Parser.Doublecolon)
                self.state = 594
                self.match(CPP14Parser.Tilde)
                self.state = 595
                self.theTypeName()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 597
                self.match(CPP14Parser.Tilde)
                self.state = 598
                self.decltypeSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def postfixExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PostfixExpressionContext,0)


        def unaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.UnaryExpressionContext,0)


        def PlusPlus(self):
            return self.getToken(CPP14Parser.PlusPlus, 0)

        def MinusMinus(self):
            return self.getToken(CPP14Parser.MinusMinus, 0)

        def unaryOperator(self):
            return self.getTypedRuleContext(CPP14Parser.UnaryOperatorContext,0)


        def Sizeof(self):
            return self.getToken(CPP14Parser.Sizeof, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Alignof(self):
            return self.getToken(CPP14Parser.Alignof, 0)

        def noExceptExpression(self):
            return self.getTypedRuleContext(CPP14Parser.NoExceptExpressionContext,0)


        def newExpression(self):
            return self.getTypedRuleContext(CPP14Parser.NewExpressionContext,0)


        def deleteExpression(self):
            return self.getTypedRuleContext(CPP14Parser.DeleteExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_unaryExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnaryExpression" ):
                listener.enterUnaryExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnaryExpression" ):
                listener.exitUnaryExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnaryExpression" ):
                return visitor.visitUnaryExpression(self)
            else:
                return visitor.visitChildren(self)




    def unaryExpression(self):

        localctx = CPP14Parser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_unaryExpression)
        try:
            self.state = 628
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 601
                self.postfixExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 606
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [123]:
                    self.state = 602
                    self.match(CPP14Parser.PlusPlus)
                    pass
                elif token in [124]:
                    self.state = 603
                    self.match(CPP14Parser.MinusMinus)
                    pass
                elif token in [94, 95, 96, 100, 101, 102, 103]:
                    self.state = 604
                    self.unaryOperator()
                    pass
                elif token in [64]:
                    self.state = 605
                    self.match(CPP14Parser.Sizeof)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 608
                self.unaryExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 609
                self.match(CPP14Parser.Sizeof)
                self.state = 618
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [88]:
                    self.state = 610
                    self.match(CPP14Parser.LeftParen)
                    self.state = 611
                    self.theTypeId()
                    self.state = 612
                    self.match(CPP14Parser.RightParen)
                    pass
                elif token in [134]:
                    self.state = 614
                    self.match(CPP14Parser.Ellipsis)
                    self.state = 615
                    self.match(CPP14Parser.LeftParen)
                    self.state = 616
                    self.match(CPP14Parser.Identifier)
                    self.state = 617
                    self.match(CPP14Parser.RightParen)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 620
                self.match(CPP14Parser.Alignof)
                self.state = 621
                self.match(CPP14Parser.LeftParen)
                self.state = 622
                self.theTypeId()
                self.state = 623
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 625
                self.noExceptExpression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 626
                self.newExpression()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 627
                self.deleteExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnaryOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Or(self):
            return self.getToken(CPP14Parser.Or, 0)

        def Star(self):
            return self.getToken(CPP14Parser.Star, 0)

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def Plus(self):
            return self.getToken(CPP14Parser.Plus, 0)

        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def Minus(self):
            return self.getToken(CPP14Parser.Minus, 0)

        def Not(self):
            return self.getToken(CPP14Parser.Not, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_unaryOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnaryOperator" ):
                listener.enterUnaryOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnaryOperator" ):
                listener.exitUnaryOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnaryOperator" ):
                return visitor.visitUnaryOperator(self)
            else:
                return visitor.visitChildren(self)




    def unaryOperator(self):

        localctx = CPP14Parser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 630
            _la = self._input.LA(1)
            if not((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & 967) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def New(self):
            return self.getToken(CPP14Parser.New, 0)

        def newTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.NewTypeIdContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def newPlacement(self):
            return self.getTypedRuleContext(CPP14Parser.NewPlacementContext,0)


        def newInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.NewInitializerContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_newExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewExpression" ):
                listener.enterNewExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewExpression" ):
                listener.exitNewExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewExpression" ):
                return visitor.visitNewExpression(self)
            else:
                return visitor.visitChildren(self)




    def newExpression(self):

        localctx = CPP14Parser.NewExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_newExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 633
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==130:
                self.state = 632
                self.match(CPP14Parser.Doublecolon)


            self.state = 635
            self.match(CPP14Parser.New)
            self.state = 637
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 636
                self.newPlacement()


            self.state = 644
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14, 15, 19, 20, 21, 22, 23, 27, 32, 35, 41, 47, 48, 62, 63, 68, 79, 80, 81, 84, 85, 86, 130, 136]:
                self.state = 639
                self.newTypeId()
                pass
            elif token in [88]:
                self.state = 640
                self.match(CPP14Parser.LeftParen)
                self.state = 641
                self.theTypeId()
                self.state = 642
                self.match(CPP14Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==88 or _la==92:
                self.state = 646
                self.newInitializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewPlacementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_newPlacement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewPlacement" ):
                listener.enterNewPlacement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewPlacement" ):
                listener.exitNewPlacement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewPlacement" ):
                return visitor.visitNewPlacement(self)
            else:
                return visitor.visitChildren(self)




    def newPlacement(self):

        localctx = CPP14Parser.NewPlacementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_newPlacement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 649
            self.match(CPP14Parser.LeftParen)
            self.state = 650
            self.expressionList()
            self.state = 651
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def newDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NewDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_newTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewTypeId" ):
                listener.enterNewTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewTypeId" ):
                listener.exitNewTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewTypeId" ):
                return visitor.visitNewTypeId(self)
            else:
                return visitor.visitChildren(self)




    def newTypeId(self):

        localctx = CPP14Parser.NewTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_newTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 653
            self.typeSpecifierSeq()
            self.state = 655
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 654
                self.newDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerOperator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,0)


        def newDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NewDeclaratorContext,0)


        def noPointerNewDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerNewDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_newDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewDeclarator" ):
                listener.enterNewDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewDeclarator" ):
                listener.exitNewDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewDeclarator" ):
                return visitor.visitNewDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def newDeclarator(self):

        localctx = CPP14Parser.NewDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_newDeclarator)
        try:
            self.state = 662
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [27, 96, 100, 121, 130, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 657
                self.pointerOperator()
                self.state = 659
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
                if la_ == 1:
                    self.state = 658
                    self.newDeclarator()


                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 2)
                self.state = 661
                self.noPointerNewDeclarator(0)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerNewDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def noPointerNewDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerNewDeclaratorContext,0)


        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerNewDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerNewDeclarator" ):
                listener.enterNoPointerNewDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerNewDeclarator" ):
                listener.exitNoPointerNewDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerNewDeclarator" ):
                return visitor.visitNoPointerNewDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerNewDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerNewDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 50
        self.enterRecursionRule(localctx, 50, self.RULE_noPointerNewDeclarator, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(CPP14Parser.LeftBracket)
            self.state = 666
            self.expression()
            self.state = 667
            self.match(CPP14Parser.RightBracket)
            self.state = 669
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
            if la_ == 1:
                self.state = 668
                self.attributeSpecifierSeq()


            self._ctx.stop = self._input.LT(-1)
            self.state = 680
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerNewDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerNewDeclarator)
                    self.state = 671
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 672
                    self.match(CPP14Parser.LeftBracket)
                    self.state = 673
                    self.constantExpression()
                    self.state = 674
                    self.match(CPP14Parser.RightBracket)
                    self.state = 676
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                    if la_ == 1:
                        self.state = 675
                        self.attributeSpecifierSeq()

             
                self.state = 682
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,52,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class NewInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_newInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNewInitializer" ):
                listener.enterNewInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNewInitializer" ):
                listener.exitNewInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewInitializer" ):
                return visitor.visitNewInitializer(self)
            else:
                return visitor.visitChildren(self)




    def newInitializer(self):

        localctx = CPP14Parser.NewInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_newInitializer)
        self._la = 0 # Token type
        try:
            self.state = 689
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [88]:
                self.enterOuterAlt(localctx, 1)
                self.state = 683
                self.match(CPP14Parser.LeftParen)
                self.state = 685
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295576359561) != 0 or _la==130 or _la==136:
                    self.state = 684
                    self.expressionList()


                self.state = 687
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 2)
                self.state = 688
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeleteExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Delete(self):
            return self.getToken(CPP14Parser.Delete, 0)

        def castExpression(self):
            return self.getTypedRuleContext(CPP14Parser.CastExpressionContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_deleteExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeleteExpression" ):
                listener.enterDeleteExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeleteExpression" ):
                listener.exitDeleteExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeleteExpression" ):
                return visitor.visitDeleteExpression(self)
            else:
                return visitor.visitChildren(self)




    def deleteExpression(self):

        localctx = CPP14Parser.DeleteExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_deleteExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 692
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==130:
                self.state = 691
                self.match(CPP14Parser.Doublecolon)


            self.state = 694
            self.match(CPP14Parser.Delete)
            self.state = 697
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
            if la_ == 1:
                self.state = 695
                self.match(CPP14Parser.LeftBracket)
                self.state = 696
                self.match(CPP14Parser.RightBracket)


            self.state = 699
            self.castExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoExceptExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Noexcept(self):
            return self.getToken(CPP14Parser.Noexcept, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_noExceptExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoExceptExpression" ):
                listener.enterNoExceptExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoExceptExpression" ):
                listener.exitNoExceptExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoExceptExpression" ):
                return visitor.visitNoExceptExpression(self)
            else:
                return visitor.visitChildren(self)




    def noExceptExpression(self):

        localctx = CPP14Parser.NoExceptExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_noExceptExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 701
            self.match(CPP14Parser.Noexcept)
            self.state = 702
            self.match(CPP14Parser.LeftParen)
            self.state = 703
            self.expression()
            self.state = 704
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CastExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def unaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.UnaryExpressionContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def castExpression(self):
            return self.getTypedRuleContext(CPP14Parser.CastExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_castExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCastExpression" ):
                listener.enterCastExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCastExpression" ):
                listener.exitCastExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCastExpression" ):
                return visitor.visitCastExpression(self)
            else:
                return visitor.visitChildren(self)




    def castExpression(self):

        localctx = CPP14Parser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_castExpression)
        try:
            self.state = 712
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 706
                self.unaryExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 707
                self.match(CPP14Parser.LeftParen)
                self.state = 708
                self.theTypeId()
                self.state = 709
                self.match(CPP14Parser.RightParen)
                self.state = 710
                self.castExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerMemberExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def castExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.CastExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.CastExpressionContext,i)


        def DotStar(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.DotStar)
            else:
                return self.getToken(CPP14Parser.DotStar, i)

        def ArrowStar(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.ArrowStar)
            else:
                return self.getToken(CPP14Parser.ArrowStar, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerMemberExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerMemberExpression" ):
                listener.enterPointerMemberExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerMemberExpression" ):
                listener.exitPointerMemberExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerMemberExpression" ):
                return visitor.visitPointerMemberExpression(self)
            else:
                return visitor.visitChildren(self)




    def pointerMemberExpression(self):

        localctx = CPP14Parser.PointerMemberExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_pointerMemberExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 714
            self.castExpression()
            self.state = 719
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==126 or _la==133:
                self.state = 715
                _la = self._input.LA(1)
                if not(_la==126 or _la==133):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 716
                self.castExpression()
                self.state = 721
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MultiplicativeExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerMemberExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerMemberExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerMemberExpressionContext,i)


        def Star(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Star)
            else:
                return self.getToken(CPP14Parser.Star, i)

        def Div(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Div)
            else:
                return self.getToken(CPP14Parser.Div, i)

        def Mod(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Mod)
            else:
                return self.getToken(CPP14Parser.Mod, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_multiplicativeExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMultiplicativeExpression" ):
                listener.enterMultiplicativeExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMultiplicativeExpression" ):
                listener.exitMultiplicativeExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiplicativeExpression" ):
                return visitor.visitMultiplicativeExpression(self)
            else:
                return visitor.visitChildren(self)




    def multiplicativeExpression(self):

        localctx = CPP14Parser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 722
            self.pointerMemberExpression()
            self.state = 727
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 7) != 0:
                self.state = 723
                _la = self._input.LA(1)
                if not((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 7) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 724
                self.pointerMemberExpression()
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AdditiveExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def multiplicativeExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MultiplicativeExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MultiplicativeExpressionContext,i)


        def Plus(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Plus)
            else:
                return self.getToken(CPP14Parser.Plus, i)

        def Minus(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Minus)
            else:
                return self.getToken(CPP14Parser.Minus, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_additiveExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAdditiveExpression" ):
                listener.enterAdditiveExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAdditiveExpression" ):
                listener.exitAdditiveExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAdditiveExpression" ):
                return visitor.visitAdditiveExpression(self)
            else:
                return visitor.visitChildren(self)




    def additiveExpression(self):

        localctx = CPP14Parser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730
            self.multiplicativeExpression()
            self.state = 735
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94 or _la==95:
                self.state = 731
                _la = self._input.LA(1)
                if not(_la==94 or _la==95):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 732
                self.multiplicativeExpression()
                self.state = 737
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShiftExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def additiveExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AdditiveExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AdditiveExpressionContext,i)


        def shiftOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ShiftOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ShiftOperatorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_shiftExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShiftExpression" ):
                listener.enterShiftExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShiftExpression" ):
                listener.exitShiftExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShiftExpression" ):
                return visitor.visitShiftExpression(self)
            else:
                return visitor.visitChildren(self)




    def shiftExpression(self):

        localctx = CPP14Parser.ShiftExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_shiftExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 738
            self.additiveExpression()
            self.state = 744
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 739
                    self.shiftOperator()
                    self.state = 740
                    self.additiveExpression() 
                self.state = 746
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShiftOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Greater(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Greater)
            else:
                return self.getToken(CPP14Parser.Greater, i)

        def Less(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Less)
            else:
                return self.getToken(CPP14Parser.Less, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_shiftOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterShiftOperator" ):
                listener.enterShiftOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitShiftOperator" ):
                listener.exitShiftOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShiftOperator" ):
                return visitor.visitShiftOperator(self)
            else:
                return visitor.visitChildren(self)




    def shiftOperator(self):

        localctx = CPP14Parser.ShiftOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_shiftOperator)
        try:
            self.state = 751
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [106]:
                self.enterOuterAlt(localctx, 1)
                self.state = 747
                self.match(CPP14Parser.Greater)
                self.state = 748
                self.match(CPP14Parser.Greater)
                pass
            elif token in [105]:
                self.enterOuterAlt(localctx, 2)
                self.state = 749
                self.match(CPP14Parser.Less)
                self.state = 750
                self.match(CPP14Parser.Less)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RelationalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def shiftExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ShiftExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ShiftExpressionContext,i)


        def Less(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Less)
            else:
                return self.getToken(CPP14Parser.Less, i)

        def Greater(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Greater)
            else:
                return self.getToken(CPP14Parser.Greater, i)

        def LessEqual(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LessEqual)
            else:
                return self.getToken(CPP14Parser.LessEqual, i)

        def GreaterEqual(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.GreaterEqual)
            else:
                return self.getToken(CPP14Parser.GreaterEqual, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_relationalExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelationalExpression" ):
                listener.enterRelationalExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelationalExpression" ):
                listener.exitRelationalExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelationalExpression" ):
                return visitor.visitRelationalExpression(self)
            else:
                return visitor.visitChildren(self)




    def relationalExpression(self):

        localctx = CPP14Parser.RelationalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 753
            self.shiftExpression()
            self.state = 758
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,63,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 754
                    _la = self._input.LA(1)
                    if not((((_la - 105)) & ~0x3f) == 0 and ((1 << (_la - 105)) & 49155) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 755
                    self.shiftExpression() 
                self.state = 760
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,63,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EqualityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def relationalExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.RelationalExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.RelationalExpressionContext,i)


        def Equal(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Equal)
            else:
                return self.getToken(CPP14Parser.Equal, i)

        def NotEqual(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.NotEqual)
            else:
                return self.getToken(CPP14Parser.NotEqual, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_equalityExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEqualityExpression" ):
                listener.enterEqualityExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEqualityExpression" ):
                listener.exitEqualityExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEqualityExpression" ):
                return visitor.visitEqualityExpression(self)
            else:
                return visitor.visitChildren(self)




    def equalityExpression(self):

        localctx = CPP14Parser.EqualityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 761
            self.relationalExpression()
            self.state = 766
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==117 or _la==118:
                self.state = 762
                _la = self._input.LA(1)
                if not(_la==117 or _la==118):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 763
                self.relationalExpression()
                self.state = 768
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def equalityExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.EqualityExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.EqualityExpressionContext,i)


        def And(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.And)
            else:
                return self.getToken(CPP14Parser.And, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_andExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAndExpression" ):
                listener.enterAndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAndExpression" ):
                listener.exitAndExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAndExpression" ):
                return visitor.visitAndExpression(self)
            else:
                return visitor.visitChildren(self)




    def andExpression(self):

        localctx = CPP14Parser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 769
            self.equalityExpression()
            self.state = 774
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==100:
                self.state = 770
                self.match(CPP14Parser.And)
                self.state = 771
                self.equalityExpression()
                self.state = 776
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def andExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AndExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AndExpressionContext,i)


        def Caret(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Caret)
            else:
                return self.getToken(CPP14Parser.Caret, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_exclusiveOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExclusiveOrExpression" ):
                listener.enterExclusiveOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExclusiveOrExpression" ):
                listener.exitExclusiveOrExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExclusiveOrExpression" ):
                return visitor.visitExclusiveOrExpression(self)
            else:
                return visitor.visitChildren(self)




    def exclusiveOrExpression(self):

        localctx = CPP14Parser.ExclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_exclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 777
            self.andExpression()
            self.state = 782
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==99:
                self.state = 778
                self.match(CPP14Parser.Caret)
                self.state = 779
                self.andExpression()
                self.state = 784
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def exclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ExclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ExclusiveOrExpressionContext,i)


        def Or(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Or)
            else:
                return self.getToken(CPP14Parser.Or, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_inclusiveOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInclusiveOrExpression" ):
                listener.enterInclusiveOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInclusiveOrExpression" ):
                listener.exitInclusiveOrExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInclusiveOrExpression" ):
                return visitor.visitInclusiveOrExpression(self)
            else:
                return visitor.visitChildren(self)




    def inclusiveOrExpression(self):

        localctx = CPP14Parser.InclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_inclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 785
            self.exclusiveOrExpression()
            self.state = 790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==101:
                self.state = 786
                self.match(CPP14Parser.Or)
                self.state = 787
                self.exclusiveOrExpression()
                self.state = 792
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalAndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def inclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.InclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.InclusiveOrExpressionContext,i)


        def AndAnd(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.AndAnd)
            else:
                return self.getToken(CPP14Parser.AndAnd, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_logicalAndExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogicalAndExpression" ):
                listener.enterLogicalAndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogicalAndExpression" ):
                listener.exitLogicalAndExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalAndExpression" ):
                return visitor.visitLogicalAndExpression(self)
            else:
                return visitor.visitChildren(self)




    def logicalAndExpression(self):

        localctx = CPP14Parser.LogicalAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_logicalAndExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 793
            self.inclusiveOrExpression()
            self.state = 798
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==121:
                self.state = 794
                self.match(CPP14Parser.AndAnd)
                self.state = 795
                self.inclusiveOrExpression()
                self.state = 800
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def logicalAndExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.LogicalAndExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.LogicalAndExpressionContext,i)


        def OrOr(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.OrOr)
            else:
                return self.getToken(CPP14Parser.OrOr, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_logicalOrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogicalOrExpression" ):
                listener.enterLogicalOrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogicalOrExpression" ):
                listener.exitLogicalOrExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogicalOrExpression" ):
                return visitor.visitLogicalOrExpression(self)
            else:
                return visitor.visitChildren(self)




    def logicalOrExpression(self):

        localctx = CPP14Parser.LogicalOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_logicalOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 801
            self.logicalAndExpression()
            self.state = 806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==122:
                self.state = 802
                self.match(CPP14Parser.OrOr)
                self.state = 803
                self.logicalAndExpression()
                self.state = 808
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def logicalOrExpression(self):
            return self.getTypedRuleContext(CPP14Parser.LogicalOrExpressionContext,0)


        def Question(self):
            return self.getToken(CPP14Parser.Question, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def assignmentExpression(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conditionalExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConditionalExpression" ):
                listener.enterConditionalExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConditionalExpression" ):
                listener.exitConditionalExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConditionalExpression" ):
                return visitor.visitConditionalExpression(self)
            else:
                return visitor.visitChildren(self)




    def conditionalExpression(self):

        localctx = CPP14Parser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 809
            self.logicalOrExpression()
            self.state = 815
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==128:
                self.state = 810
                self.match(CPP14Parser.Question)
                self.state = 811
                self.expression()
                self.state = 812
                self.match(CPP14Parser.Colon)
                self.state = 813
                self.assignmentExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def conditionalExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionalExpressionContext,0)


        def logicalOrExpression(self):
            return self.getTypedRuleContext(CPP14Parser.LogicalOrExpressionContext,0)


        def assignmentOperator(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentOperatorContext,0)


        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def throwExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ThrowExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_assignmentExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssignmentExpression" ):
                listener.enterAssignmentExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssignmentExpression" ):
                listener.exitAssignmentExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignmentExpression" ):
                return visitor.visitAssignmentExpression(self)
            else:
                return visitor.visitChildren(self)




    def assignmentExpression(self):

        localctx = CPP14Parser.AssignmentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_assignmentExpression)
        try:
            self.state = 823
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 817
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 818
                self.logicalOrExpression()
                self.state = 819
                self.assignmentOperator()
                self.state = 820
                self.initializerClause()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 822
                self.throwExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def StarAssign(self):
            return self.getToken(CPP14Parser.StarAssign, 0)

        def DivAssign(self):
            return self.getToken(CPP14Parser.DivAssign, 0)

        def ModAssign(self):
            return self.getToken(CPP14Parser.ModAssign, 0)

        def PlusAssign(self):
            return self.getToken(CPP14Parser.PlusAssign, 0)

        def MinusAssign(self):
            return self.getToken(CPP14Parser.MinusAssign, 0)

        def RightShiftAssign(self):
            return self.getToken(CPP14Parser.RightShiftAssign, 0)

        def LeftShiftAssign(self):
            return self.getToken(CPP14Parser.LeftShiftAssign, 0)

        def AndAssign(self):
            return self.getToken(CPP14Parser.AndAssign, 0)

        def XorAssign(self):
            return self.getToken(CPP14Parser.XorAssign, 0)

        def OrAssign(self):
            return self.getToken(CPP14Parser.OrAssign, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_assignmentOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssignmentOperator" ):
                listener.enterAssignmentOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssignmentOperator" ):
                listener.exitAssignmentOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignmentOperator" ):
                return visitor.visitAssignmentOperator(self)
            else:
                return visitor.visitChildren(self)




    def assignmentOperator(self):

        localctx = CPP14Parser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 825
            _la = self._input.LA(1)
            if not((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & 8185) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assignmentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)




    def expression(self):

        localctx = CPP14Parser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 827
            self.assignmentExpression()
            self.state = 832
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 828
                self.match(CPP14Parser.Comma)
                self.state = 829
                self.assignmentExpression()
                self.state = 834
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstantExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def conditionalExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_constantExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstantExpression" ):
                listener.enterConstantExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstantExpression" ):
                listener.exitConstantExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstantExpression" ):
                return visitor.visitConstantExpression(self)
            else:
                return visitor.visitChildren(self)




    def constantExpression(self):

        localctx = CPP14Parser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 835
            self.conditionalExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def labeledStatement(self):
            return self.getTypedRuleContext(CPP14Parser.LabeledStatementContext,0)


        def declarationStatement(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationStatementContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionStatementContext,0)


        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def selectionStatement(self):
            return self.getTypedRuleContext(CPP14Parser.SelectionStatementContext,0)


        def iterationStatement(self):
            return self.getTypedRuleContext(CPP14Parser.IterationStatementContext,0)


        def jumpStatement(self):
            return self.getTypedRuleContext(CPP14Parser.JumpStatementContext,0)


        def tryBlock(self):
            return self.getTypedRuleContext(CPP14Parser.TryBlockContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement" ):
                listener.enterStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement" ):
                listener.exitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = CPP14Parser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_statement)
        try:
            self.state = 850
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 837
                self.labeledStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 838
                self.declarationStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 840
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                if la_ == 1:
                    self.state = 839
                    self.attributeSpecifierSeq()


                self.state = 848
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [1, 2, 3, 4, 5, 6, 7, 12, 14, 15, 19, 20, 21, 25, 27, 30, 32, 33, 41, 47, 48, 51, 52, 54, 60, 62, 63, 64, 67, 71, 73, 78, 79, 81, 84, 86, 88, 90, 94, 95, 96, 100, 101, 102, 103, 123, 124, 130, 131, 136]:
                    self.state = 842
                    self.expressionStatement()
                    pass
                elif token in [92]:
                    self.state = 843
                    self.compoundStatement()
                    pass
                elif token in [45, 69]:
                    self.state = 844
                    self.selectionStatement()
                    pass
                elif token in [31, 42, 87]:
                    self.state = 845
                    self.iterationStatement()
                    pass
                elif token in [16, 26, 44, 61]:
                    self.state = 846
                    self.jumpStatement()
                    pass
                elif token in [76]:
                    self.state = 847
                    self.tryBlock()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabeledStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def statement(self):
            return self.getTypedRuleContext(CPP14Parser.StatementContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Case(self):
            return self.getToken(CPP14Parser.Case, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Default(self):
            return self.getToken(CPP14Parser.Default, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_labeledStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLabeledStatement" ):
                listener.enterLabeledStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLabeledStatement" ):
                listener.exitLabeledStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLabeledStatement" ):
                return visitor.visitLabeledStatement(self)
            else:
                return visitor.visitChildren(self)




    def labeledStatement(self):

        localctx = CPP14Parser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_labeledStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 853
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 852
                self.attributeSpecifierSeq()


            self.state = 859
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [136]:
                self.state = 855
                self.match(CPP14Parser.Identifier)
                pass
            elif token in [17]:
                self.state = 856
                self.match(CPP14Parser.Case)
                self.state = 857
                self.constantExpression()
                pass
            elif token in [28]:
                self.state = 858
                self.match(CPP14Parser.Default)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 861
            self.match(CPP14Parser.Colon)
            self.state = 862
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_expressionStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionStatement" ):
                listener.enterExpressionStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionStatement" ):
                listener.exitExpressionStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionStatement" ):
                return visitor.visitExpressionStatement(self)
            else:
                return visitor.visitChildren(self)




    def expressionStatement(self):

        localctx = CPP14Parser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_expressionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 865
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307924105) != 0 or _la==130 or _la==136:
                self.state = 864
                self.expression()


            self.state = 867
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CompoundStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def statementSeq(self):
            return self.getTypedRuleContext(CPP14Parser.StatementSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_compoundStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCompoundStatement" ):
                listener.enterCompoundStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCompoundStatement" ):
                listener.exitCompoundStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCompoundStatement" ):
                return visitor.visitCompoundStatement(self)
            else:
                return visitor.visitChildren(self)




    def compoundStatement(self):

        localctx = CPP14Parser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 869
            self.match(CPP14Parser.LeftBrace)
            self.state = 871
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -549440958962599682) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1873498483663565759) != 0 or (((_la - 130)) & ~0x3f) == 0 and ((1 << (_la - 130)) & 83) != 0:
                self.state = 870
                self.statementSeq()


            self.state = 873
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.StatementContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.StatementContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_statementSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatementSeq" ):
                listener.enterStatementSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatementSeq" ):
                listener.exitStatementSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatementSeq" ):
                return visitor.visitStatementSeq(self)
            else:
                return visitor.visitChildren(self)




    def statementSeq(self):

        localctx = CPP14Parser.StatementSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_statementSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 876 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 875
                self.statement()
                self.state = 878 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((_la) & ~0x3f) == 0 and ((1 << _la) & -549440958962599682) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1873498483663565759) != 0 or (((_la - 130)) & ~0x3f) == 0 and ((1 << (_la - 130)) & 83) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def If(self):
            return self.getToken(CPP14Parser.If, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def condition(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.StatementContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.StatementContext,i)


        def Else(self):
            return self.getToken(CPP14Parser.Else, 0)

        def Switch(self):
            return self.getToken(CPP14Parser.Switch, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_selectionStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelectionStatement" ):
                listener.enterSelectionStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelectionStatement" ):
                listener.exitSelectionStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelectionStatement" ):
                return visitor.visitSelectionStatement(self)
            else:
                return visitor.visitChildren(self)




    def selectionStatement(self):

        localctx = CPP14Parser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_selectionStatement)
        try:
            self.state = 895
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [45]:
                self.enterOuterAlt(localctx, 1)
                self.state = 880
                self.match(CPP14Parser.If)
                self.state = 881
                self.match(CPP14Parser.LeftParen)
                self.state = 882
                self.condition()
                self.state = 883
                self.match(CPP14Parser.RightParen)
                self.state = 884
                self.statement()
                self.state = 887
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
                if la_ == 1:
                    self.state = 885
                    self.match(CPP14Parser.Else)
                    self.state = 886
                    self.statement()


                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 2)
                self.state = 889
                self.match(CPP14Parser.Switch)
                self.state = 890
                self.match(CPP14Parser.LeftParen)
                self.state = 891
                self.condition()
                self.state = 892
                self.match(CPP14Parser.RightParen)
                self.state = 893
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_condition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCondition" ):
                listener.enterCondition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCondition" ):
                listener.exitCondition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCondition" ):
                return visitor.visitCondition(self)
            else:
                return visitor.visitChildren(self)




    def condition(self):

        localctx = CPP14Parser.ConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_condition)
        self._la = 0 # Token type
        try:
            self.state = 908
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 897
                self.expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 899
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11 or _la==90:
                    self.state = 898
                    self.attributeSpecifierSeq()


                self.state = 901
                self.declSpecifierSeq()
                self.state = 902
                self.declarator()
                self.state = 906
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [104]:
                    self.state = 903
                    self.match(CPP14Parser.Assign)
                    self.state = 904
                    self.initializerClause()
                    pass
                elif token in [92]:
                    self.state = 905
                    self.bracedInitList()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IterationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def While(self):
            return self.getToken(CPP14Parser.While, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def condition(self):
            return self.getTypedRuleContext(CPP14Parser.ConditionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def statement(self):
            return self.getTypedRuleContext(CPP14Parser.StatementContext,0)


        def Do(self):
            return self.getToken(CPP14Parser.Do, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def For(self):
            return self.getToken(CPP14Parser.For, 0)

        def forInitStatement(self):
            return self.getTypedRuleContext(CPP14Parser.ForInitStatementContext,0)


        def forRangeDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.ForRangeDeclarationContext,0)


        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def forRangeInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.ForRangeInitializerContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_iterationStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIterationStatement" ):
                listener.enterIterationStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIterationStatement" ):
                listener.exitIterationStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIterationStatement" ):
                return visitor.visitIterationStatement(self)
            else:
                return visitor.visitChildren(self)




    def iterationStatement(self):

        localctx = CPP14Parser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_iterationStatement)
        self._la = 0 # Token type
        try:
            self.state = 943
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [87]:
                self.enterOuterAlt(localctx, 1)
                self.state = 910
                self.match(CPP14Parser.While)
                self.state = 911
                self.match(CPP14Parser.LeftParen)
                self.state = 912
                self.condition()
                self.state = 913
                self.match(CPP14Parser.RightParen)
                self.state = 914
                self.statement()
                pass
            elif token in [31]:
                self.enterOuterAlt(localctx, 2)
                self.state = 916
                self.match(CPP14Parser.Do)
                self.state = 917
                self.statement()
                self.state = 918
                self.match(CPP14Parser.While)
                self.state = 919
                self.match(CPP14Parser.LeftParen)
                self.state = 920
                self.expression()
                self.state = 921
                self.match(CPP14Parser.RightParen)
                self.state = 922
                self.match(CPP14Parser.Semi)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 3)
                self.state = 924
                self.match(CPP14Parser.For)
                self.state = 925
                self.match(CPP14Parser.LeftParen)
                self.state = 938
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
                if la_ == 1:
                    self.state = 926
                    self.forInitStatement()
                    self.state = 928
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((_la) & ~0x3f) == 0 and ((1 << _la) & -2856467045171013378) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295310619547) != 0 or _la==130 or _la==136:
                        self.state = 927
                        self.condition()


                    self.state = 930
                    self.match(CPP14Parser.Semi)
                    self.state = 932
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307924105) != 0 or _la==130 or _la==136:
                        self.state = 931
                        self.expression()


                    pass

                elif la_ == 2:
                    self.state = 934
                    self.forRangeDeclaration()
                    self.state = 935
                    self.match(CPP14Parser.Colon)
                    self.state = 936
                    self.forRangeInitializer()
                    pass


                self.state = 940
                self.match(CPP14Parser.RightParen)
                self.state = 941
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForInitStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expressionStatement(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionStatementContext,0)


        def simpleDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_forInitStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForInitStatement" ):
                listener.enterForInitStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForInitStatement" ):
                listener.exitForInitStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForInitStatement" ):
                return visitor.visitForInitStatement(self)
            else:
                return visitor.visitChildren(self)




    def forInitStatement(self):

        localctx = CPP14Parser.ForInitStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_forInitStatement)
        try:
            self.state = 947
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 945
                self.expressionStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 946
                self.simpleDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForRangeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_forRangeDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForRangeDeclaration" ):
                listener.enterForRangeDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForRangeDeclaration" ):
                listener.exitForRangeDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForRangeDeclaration" ):
                return visitor.visitForRangeDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def forRangeDeclaration(self):

        localctx = CPP14Parser.ForRangeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_forRangeDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 950
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 949
                self.attributeSpecifierSeq()


            self.state = 952
            self.declSpecifierSeq()
            self.state = 953
            self.declarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForRangeInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_forRangeInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForRangeInitializer" ):
                listener.enterForRangeInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForRangeInitializer" ):
                listener.exitForRangeInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitForRangeInitializer" ):
                return visitor.visitForRangeInitializer(self)
            else:
                return visitor.visitChildren(self)




    def forRangeInitializer(self):

        localctx = CPP14Parser.ForRangeInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_forRangeInitializer)
        try:
            self.state = 957
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 12, 14, 15, 19, 20, 21, 25, 27, 30, 32, 33, 41, 47, 48, 51, 52, 54, 60, 62, 63, 64, 67, 71, 73, 78, 79, 81, 84, 86, 88, 90, 94, 95, 96, 100, 101, 102, 103, 123, 124, 130, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 955
                self.expression()
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 2)
                self.state = 956
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JumpStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def Break(self):
            return self.getToken(CPP14Parser.Break, 0)

        def Continue(self):
            return self.getToken(CPP14Parser.Continue, 0)

        def Return(self):
            return self.getToken(CPP14Parser.Return, 0)

        def Goto(self):
            return self.getToken(CPP14Parser.Goto, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_jumpStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJumpStatement" ):
                listener.enterJumpStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJumpStatement" ):
                listener.exitJumpStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitJumpStatement" ):
                return visitor.visitJumpStatement(self)
            else:
                return visitor.visitChildren(self)




    def jumpStatement(self):

        localctx = CPP14Parser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_jumpStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 968
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [16]:
                self.state = 959
                self.match(CPP14Parser.Break)
                pass
            elif token in [26]:
                self.state = 960
                self.match(CPP14Parser.Continue)
                pass
            elif token in [61]:
                self.state = 961
                self.match(CPP14Parser.Return)
                self.state = 964
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [1, 2, 3, 4, 5, 6, 7, 12, 14, 15, 19, 20, 21, 25, 27, 30, 32, 33, 41, 47, 48, 51, 52, 54, 60, 62, 63, 64, 67, 71, 73, 78, 79, 81, 84, 86, 88, 90, 94, 95, 96, 100, 101, 102, 103, 123, 124, 130, 136]:
                    self.state = 962
                    self.expression()
                    pass
                elif token in [92]:
                    self.state = 963
                    self.bracedInitList()
                    pass
                elif token in [131]:
                    pass
                else:
                    pass
                pass
            elif token in [44]:
                self.state = 966
                self.match(CPP14Parser.Goto)
                self.state = 967
                self.match(CPP14Parser.Identifier)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 970
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def blockDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.BlockDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declarationStatement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclarationStatement" ):
                listener.enterDeclarationStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclarationStatement" ):
                listener.exitDeclarationStatement(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclarationStatement" ):
                return visitor.visitDeclarationStatement(self)
            else:
                return visitor.visitChildren(self)




    def declarationStatement(self):

        localctx = CPP14Parser.DeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_declarationStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 972
            self.blockDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationseqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.DeclarationContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.DeclarationContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declarationseq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclarationseq" ):
                listener.enterDeclarationseq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclarationseq" ):
                listener.exitDeclarationseq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclarationseq" ):
                return visitor.visitDeclarationseq(self)
            else:
                return visitor.visitChildren(self)




    def declarationseq(self):

        localctx = CPP14Parser.DeclarationseqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_declarationseq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 975 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 974
                self.declaration()
                self.state = 977 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 3087508886339534621) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 1035845506523737085) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def blockDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.BlockDeclarationContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionDefinitionContext,0)


        def templateDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateDeclarationContext,0)


        def explicitInstantiation(self):
            return self.getTypedRuleContext(CPP14Parser.ExplicitInstantiationContext,0)


        def explicitSpecialization(self):
            return self.getTypedRuleContext(CPP14Parser.ExplicitSpecializationContext,0)


        def linkageSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.LinkageSpecificationContext,0)


        def namespaceDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceDefinitionContext,0)


        def emptyDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.EmptyDeclarationContext,0)


        def attributeDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeDeclarationContext,0)


        def define(self):
            return self.getTypedRuleContext(CPP14Parser.DefineContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclaration" ):
                listener.enterDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclaration" ):
                listener.exitDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclaration" ):
                return visitor.visitDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def declaration(self):

        localctx = CPP14Parser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_declaration)
        try:
            self.state = 989
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 979
                self.blockDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 980
                self.functionDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 981
                self.templateDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 982
                self.explicitInstantiation()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 983
                self.explicitSpecialization()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 984
                self.linkageSpecification()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 985
                self.namespaceDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 986
                self.emptyDeclaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 987
                self.attributeDeclaration()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 988
                self.define()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleDeclarationContext,0)


        def asmDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.AsmDefinitionContext,0)


        def namespaceAliasDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceAliasDefinitionContext,0)


        def usingDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.UsingDeclarationContext,0)


        def usingDirective(self):
            return self.getTypedRuleContext(CPP14Parser.UsingDirectiveContext,0)


        def staticAssertDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.StaticAssertDeclarationContext,0)


        def aliasDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.AliasDeclarationContext,0)


        def opaqueEnumDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.OpaqueEnumDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_blockDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBlockDeclaration" ):
                listener.enterBlockDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBlockDeclaration" ):
                listener.exitBlockDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlockDeclaration" ):
                return visitor.visitBlockDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def blockDeclaration(self):

        localctx = CPP14Parser.BlockDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_blockDeclaration)
        try:
            self.state = 999
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 991
                self.simpleDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 992
                self.asmDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 993
                self.namespaceAliasDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 994
                self.usingDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 995
                self.usingDirective()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 996
                self.staticAssertDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 997
                self.aliasDeclaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 998
                self.opaqueEnumDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AliasDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Using(self):
            return self.getToken(CPP14Parser.Using, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_aliasDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAliasDeclaration" ):
                listener.enterAliasDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAliasDeclaration" ):
                listener.exitAliasDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAliasDeclaration" ):
                return visitor.visitAliasDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def aliasDeclaration(self):

        localctx = CPP14Parser.AliasDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_aliasDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1001
            self.match(CPP14Parser.Using)
            self.state = 1002
            self.match(CPP14Parser.Identifier)
            self.state = 1004
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1003
                self.attributeSpecifierSeq()


            self.state = 1006
            self.match(CPP14Parser.Assign)
            self.state = 1007
            self.theTypeId()
            self.state = 1008
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def initDeclaratorList(self):
            return self.getTypedRuleContext(CPP14Parser.InitDeclaratorListContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleDeclaration" ):
                listener.enterSimpleDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleDeclaration" ):
                listener.exitSimpleDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleDeclaration" ):
                return visitor.visitSimpleDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def simpleDeclaration(self):

        localctx = CPP14Parser.SimpleDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_simpleDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 1024
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14, 15, 19, 20, 21, 22, 23, 24, 27, 32, 35, 36, 38, 41, 43, 46, 47, 48, 49, 54, 59, 62, 63, 65, 68, 72, 77, 79, 80, 81, 83, 84, 85, 86, 88, 96, 100, 102, 121, 130, 131, 134, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1011
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
                if la_ == 1:
                    self.state = 1010
                    self.declSpecifierSeq()


                self.state = 1014
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==27 or _la==54 or (((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & 356250357354753) != 0:
                    self.state = 1013
                    self.initDeclaratorList()


                self.state = 1016
                self.match(CPP14Parser.Semi)
                pass
            elif token in [11, 90]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1017
                self.attributeSpecifierSeq()
                self.state = 1019
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
                if la_ == 1:
                    self.state = 1018
                    self.declSpecifierSeq()


                self.state = 1021
                self.initDeclaratorList()
                self.state = 1022
                self.match(CPP14Parser.Semi)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StaticAssertDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Static_assert(self):
            return self.getToken(CPP14Parser.Static_assert, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_staticAssertDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStaticAssertDeclaration" ):
                listener.enterStaticAssertDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStaticAssertDeclaration" ):
                listener.exitStaticAssertDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticAssertDeclaration" ):
                return visitor.visitStaticAssertDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def staticAssertDeclaration(self):

        localctx = CPP14Parser.StaticAssertDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_staticAssertDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1026
            self.match(CPP14Parser.Static_assert)
            self.state = 1027
            self.match(CPP14Parser.LeftParen)
            self.state = 1028
            self.constantExpression()
            self.state = 1029
            self.match(CPP14Parser.Comma)
            self.state = 1030
            self.match(CPP14Parser.StringLiteral)
            self.state = 1031
            self.match(CPP14Parser.RightParen)
            self.state = 1032
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmptyDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_emptyDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEmptyDeclaration" ):
                listener.enterEmptyDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEmptyDeclaration" ):
                listener.exitEmptyDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEmptyDeclaration" ):
                return visitor.visitEmptyDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def emptyDeclaration(self):

        localctx = CPP14Parser.EmptyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_emptyDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1034
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeDeclaration" ):
                listener.enterAttributeDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeDeclaration" ):
                listener.exitAttributeDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeDeclaration" ):
                return visitor.visitAttributeDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def attributeDeclaration(self):

        localctx = CPP14Parser.AttributeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_attributeDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1036
            self.attributeSpecifierSeq()
            self.state = 1037
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def storageClassSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.StorageClassSpecifierContext,0)


        def typeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierContext,0)


        def functionSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionSpecifierContext,0)


        def Friend(self):
            return self.getToken(CPP14Parser.Friend, 0)

        def Typedef(self):
            return self.getToken(CPP14Parser.Typedef, 0)

        def Constexpr(self):
            return self.getToken(CPP14Parser.Constexpr, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_declSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclSpecifier" ):
                listener.enterDeclSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclSpecifier" ):
                listener.exitDeclSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclSpecifier" ):
                return visitor.visitDeclSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def declSpecifier(self):

        localctx = CPP14Parser.DeclSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_declSpecifier)
        try:
            self.state = 1045
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [38, 49, 59, 65, 72]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1039
                self.storageClassSpecifier()
                pass
            elif token in [14, 15, 19, 20, 21, 22, 23, 27, 32, 35, 41, 47, 48, 62, 63, 68, 79, 80, 81, 84, 85, 86, 130, 136]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1040
                self.typeSpecifier()
                pass
            elif token in [36, 46, 83]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1041
                self.functionSpecifier()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1042
                self.match(CPP14Parser.Friend)
                pass
            elif token in [77]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1043
                self.match(CPP14Parser.Typedef)
                pass
            elif token in [24]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1044
                self.match(CPP14Parser.Constexpr)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.DeclSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.DeclSpecifierContext,i)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclSpecifierSeq" ):
                listener.enterDeclSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclSpecifierSeq" ):
                listener.exitDeclSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclSpecifierSeq" ):
                return visitor.visitDeclSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def declSpecifierSeq(self):

        localctx = CPP14Parser.DeclSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_declSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1048 
            self._errHandler.sync(self)
            _alt = 1+1
            while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1+1:
                    self.state = 1047
                    self.declSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1050 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,104,self._ctx)

            self.state = 1053
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 1052
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StorageClassSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Register(self):
            return self.getToken(CPP14Parser.Register, 0)

        def Static(self):
            return self.getToken(CPP14Parser.Static, 0)

        def Thread_local(self):
            return self.getToken(CPP14Parser.Thread_local, 0)

        def Extern(self):
            return self.getToken(CPP14Parser.Extern, 0)

        def Mutable(self):
            return self.getToken(CPP14Parser.Mutable, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_storageClassSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStorageClassSpecifier" ):
                listener.enterStorageClassSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStorageClassSpecifier" ):
                listener.exitStorageClassSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStorageClassSpecifier" ):
                return visitor.visitStorageClassSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def storageClassSpecifier(self):

        localctx = CPP14Parser.StorageClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_storageClassSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1055
            _la = self._input.LA(1)
            if not((((_la - 38)) & ~0x3f) == 0 and ((1 << (_la - 38)) & 17316186113) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Inline(self):
            return self.getToken(CPP14Parser.Inline, 0)

        def Virtual(self):
            return self.getToken(CPP14Parser.Virtual, 0)

        def Explicit(self):
            return self.getToken(CPP14Parser.Explicit, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_functionSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionSpecifier" ):
                listener.enterFunctionSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionSpecifier" ):
                listener.exitFunctionSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionSpecifier" ):
                return visitor.visitFunctionSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def functionSpecifier(self):

        localctx = CPP14Parser.FunctionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_functionSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1057
            _la = self._input.LA(1)
            if not((((_la - 36)) & ~0x3f) == 0 and ((1 << (_la - 36)) & 140737488356353) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypedefNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typedefName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypedefName" ):
                listener.enterTypedefName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypedefName" ):
                listener.exitTypedefName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypedefName" ):
                return visitor.visitTypedefName(self)
            else:
                return visitor.visitChildren(self)




    def typedefName(self):

        localctx = CPP14Parser.TypedefNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1059
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def trailingTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingTypeSpecifierContext,0)


        def classSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.ClassSpecifierContext,0)


        def enumSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.EnumSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_typeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeSpecifier" ):
                listener.enterTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeSpecifier" ):
                listener.exitTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSpecifier" ):
                return visitor.visitTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def typeSpecifier(self):

        localctx = CPP14Parser.TypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_typeSpecifier)
        try:
            self.state = 1064
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1061
                self.trailingTypeSpecifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1062
                self.classSpecifier()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1063
                self.enumSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailingTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTypeSpecifierContext,0)


        def elaboratedTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.ElaboratedTypeSpecifierContext,0)


        def typeNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.TypeNameSpecifierContext,0)


        def cvQualifier(self):
            return self.getTypedRuleContext(CPP14Parser.CvQualifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_trailingTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailingTypeSpecifier" ):
                listener.enterTrailingTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailingTypeSpecifier" ):
                listener.exitTrailingTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailingTypeSpecifier" ):
                return visitor.visitTrailingTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def trailingTypeSpecifier(self):

        localctx = CPP14Parser.TrailingTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_trailingTypeSpecifier)
        try:
            self.state = 1070
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14, 15, 19, 20, 21, 27, 32, 41, 47, 48, 62, 63, 81, 84, 86, 130, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1066
                self.simpleTypeSpecifier()
                pass
            elif token in [22, 35, 68]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1067
                self.elaboratedTypeSpecifier()
                pass
            elif token in [79]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1068
                self.typeNameSpecifier()
                pass
            elif token in [23, 85]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1069
                self.cvQualifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TypeSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TypeSpecifierContext,i)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_typeSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeSpecifierSeq" ):
                listener.enterTypeSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeSpecifierSeq" ):
                listener.exitTypeSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeSpecifierSeq" ):
                return visitor.visitTypeSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def typeSpecifierSeq(self):

        localctx = CPP14Parser.TypeSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_typeSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1073 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1072
                    self.typeSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1075 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,108,self._ctx)

            self.state = 1078
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
            if la_ == 1:
                self.state = 1077
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailingTypeSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def trailingTypeSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TrailingTypeSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TrailingTypeSpecifierContext,i)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_trailingTypeSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailingTypeSpecifierSeq" ):
                listener.enterTrailingTypeSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailingTypeSpecifierSeq" ):
                listener.exitTrailingTypeSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailingTypeSpecifierSeq" ):
                return visitor.visitTrailingTypeSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def trailingTypeSpecifierSeq(self):

        localctx = CPP14Parser.TrailingTypeSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_trailingTypeSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1081 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1080
                    self.trailingTypeSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1083 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,110,self._ctx)

            self.state = 1086
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                self.state = 1085
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTypeLengthModifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Short(self):
            return self.getToken(CPP14Parser.Short, 0)

        def Long(self):
            return self.getToken(CPP14Parser.Long, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTypeLengthModifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTypeLengthModifier" ):
                listener.enterSimpleTypeLengthModifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTypeLengthModifier" ):
                listener.exitSimpleTypeLengthModifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTypeLengthModifier" ):
                return visitor.visitSimpleTypeLengthModifier(self)
            else:
                return visitor.visitChildren(self)




    def simpleTypeLengthModifier(self):

        localctx = CPP14Parser.SimpleTypeLengthModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_simpleTypeLengthModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1088
            _la = self._input.LA(1)
            if not(_la==48 or _la==62):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTypeSignednessModifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Unsigned(self):
            return self.getToken(CPP14Parser.Unsigned, 0)

        def Signed(self):
            return self.getToken(CPP14Parser.Signed, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTypeSignednessModifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTypeSignednessModifier" ):
                listener.enterSimpleTypeSignednessModifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTypeSignednessModifier" ):
                listener.exitSimpleTypeSignednessModifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTypeSignednessModifier" ):
                return visitor.visitSimpleTypeSignednessModifier(self)
            else:
                return visitor.visitChildren(self)




    def simpleTypeSignednessModifier(self):

        localctx = CPP14Parser.SimpleTypeSignednessModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_simpleTypeSignednessModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1090
            _la = self._input.LA(1)
            if not(_la==63 or _la==81):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def theTypeName(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def simpleTypeSignednessModifier(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTypeSignednessModifierContext,0)


        def simpleTypeLengthModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.SimpleTypeLengthModifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.SimpleTypeLengthModifierContext,i)


        def Char(self):
            return self.getToken(CPP14Parser.Char, 0)

        def Char16(self):
            return self.getToken(CPP14Parser.Char16, 0)

        def Char32(self):
            return self.getToken(CPP14Parser.Char32, 0)

        def Wchar(self):
            return self.getToken(CPP14Parser.Wchar, 0)

        def Bool(self):
            return self.getToken(CPP14Parser.Bool, 0)

        def Int(self):
            return self.getToken(CPP14Parser.Int, 0)

        def Float(self):
            return self.getToken(CPP14Parser.Float, 0)

        def Double(self):
            return self.getToken(CPP14Parser.Double, 0)

        def Void(self):
            return self.getToken(CPP14Parser.Void, 0)

        def Auto(self):
            return self.getToken(CPP14Parser.Auto, 0)

        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTypeSpecifier" ):
                listener.enterSimpleTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTypeSpecifier" ):
                listener.exitSimpleTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTypeSpecifier" ):
                return visitor.visitSimpleTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def simpleTypeSpecifier(self):

        localctx = CPP14Parser.SimpleTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_simpleTypeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1144
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1093
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 1092
                    self.nestedNameSpecifier(0)


                self.state = 1095
                self.theTypeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1096
                self.nestedNameSpecifier(0)
                self.state = 1097
                self.match(CPP14Parser.Template)
                self.state = 1098
                self.simpleTemplateId()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1100
                self.simpleTypeSignednessModifier()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1102
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63 or _la==81:
                    self.state = 1101
                    self.simpleTypeSignednessModifier()


                self.state = 1105 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1104
                        self.simpleTypeLengthModifier()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1107 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,114,self._ctx)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1110
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63 or _la==81:
                    self.state = 1109
                    self.simpleTypeSignednessModifier()


                self.state = 1112
                self.match(CPP14Parser.Char)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1114
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63 or _la==81:
                    self.state = 1113
                    self.simpleTypeSignednessModifier()


                self.state = 1116
                self.match(CPP14Parser.Char16)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1118
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63 or _la==81:
                    self.state = 1117
                    self.simpleTypeSignednessModifier()


                self.state = 1120
                self.match(CPP14Parser.Char32)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1122
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63 or _la==81:
                    self.state = 1121
                    self.simpleTypeSignednessModifier()


                self.state = 1124
                self.match(CPP14Parser.Wchar)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1125
                self.match(CPP14Parser.Bool)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1127
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63 or _la==81:
                    self.state = 1126
                    self.simpleTypeSignednessModifier()


                self.state = 1132
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==48 or _la==62:
                    self.state = 1129
                    self.simpleTypeLengthModifier()
                    self.state = 1134
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1135
                self.match(CPP14Parser.Int)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1136
                self.match(CPP14Parser.Float)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1138
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==48 or _la==62:
                    self.state = 1137
                    self.simpleTypeLengthModifier()


                self.state = 1140
                self.match(CPP14Parser.Double)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1141
                self.match(CPP14Parser.Void)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1142
                self.match(CPP14Parser.Auto)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1143
                self.decltypeSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def enumName(self):
            return self.getTypedRuleContext(CPP14Parser.EnumNameContext,0)


        def typedefName(self):
            return self.getTypedRuleContext(CPP14Parser.TypedefNameContext,0)


        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_theTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTheTypeName" ):
                listener.enterTheTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTheTypeName" ):
                listener.exitTheTypeName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheTypeName" ):
                return visitor.visitTheTypeName(self)
            else:
                return visitor.visitChildren(self)




    def theTypeName(self):

        localctx = CPP14Parser.TheTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_theTypeName)
        try:
            self.state = 1150
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1146
                self.className()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1147
                self.enumName()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1148
                self.typedefName()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1149
                self.simpleTemplateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DecltypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Decltype(self):
            return self.getToken(CPP14Parser.Decltype, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def expression(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionContext,0)


        def Auto(self):
            return self.getToken(CPP14Parser.Auto, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_decltypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDecltypeSpecifier" ):
                listener.enterDecltypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDecltypeSpecifier" ):
                listener.exitDecltypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDecltypeSpecifier" ):
                return visitor.visitDecltypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def decltypeSpecifier(self):

        localctx = CPP14Parser.DecltypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_decltypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1152
            self.match(CPP14Parser.Decltype)
            self.state = 1153
            self.match(CPP14Parser.LeftParen)
            self.state = 1156
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.state = 1154
                self.expression()
                pass

            elif la_ == 2:
                self.state = 1155
                self.match(CPP14Parser.Auto)
                pass


            self.state = 1158
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElaboratedTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classKey(self):
            return self.getTypedRuleContext(CPP14Parser.ClassKeyContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Enum(self):
            return self.getToken(CPP14Parser.Enum, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_elaboratedTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElaboratedTypeSpecifier" ):
                listener.enterElaboratedTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElaboratedTypeSpecifier" ):
                listener.exitElaboratedTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElaboratedTypeSpecifier" ):
                return visitor.visitElaboratedTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def elaboratedTypeSpecifier(self):

        localctx = CPP14Parser.ElaboratedTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_elaboratedTypeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1182
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [22, 68]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1160
                self.classKey()
                self.state = 1175
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
                if la_ == 1:
                    self.state = 1162
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==11 or _la==90:
                        self.state = 1161
                        self.attributeSpecifierSeq()


                    self.state = 1165
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
                    if la_ == 1:
                        self.state = 1164
                        self.nestedNameSpecifier(0)


                    self.state = 1167
                    self.match(CPP14Parser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 1168
                    self.simpleTemplateId()
                    pass

                elif la_ == 3:
                    self.state = 1169
                    self.nestedNameSpecifier(0)
                    self.state = 1171
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==70:
                        self.state = 1170
                        self.match(CPP14Parser.Template)


                    self.state = 1173
                    self.simpleTemplateId()
                    pass


                pass
            elif token in [35]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1177
                self.match(CPP14Parser.Enum)
                self.state = 1179
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                if la_ == 1:
                    self.state = 1178
                    self.nestedNameSpecifier(0)


                self.state = 1181
                self.match(CPP14Parser.Identifier)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumName" ):
                listener.enterEnumName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumName" ):
                listener.exitEnumName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumName" ):
                return visitor.visitEnumName(self)
            else:
                return visitor.visitChildren(self)




    def enumName(self):

        localctx = CPP14Parser.EnumNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_enumName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1184
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumHead(self):
            return self.getTypedRuleContext(CPP14Parser.EnumHeadContext,0)


        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def enumeratorList(self):
            return self.getTypedRuleContext(CPP14Parser.EnumeratorListContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumSpecifier" ):
                listener.enterEnumSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumSpecifier" ):
                listener.exitEnumSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumSpecifier" ):
                return visitor.visitEnumSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def enumSpecifier(self):

        localctx = CPP14Parser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1186
            self.enumHead()
            self.state = 1187
            self.match(CPP14Parser.LeftBrace)
            self.state = 1192
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==136:
                self.state = 1188
                self.enumeratorList()
                self.state = 1190
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==125:
                    self.state = 1189
                    self.match(CPP14Parser.Comma)




            self.state = 1194
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumHeadContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumkey(self):
            return self.getTypedRuleContext(CPP14Parser.EnumkeyContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def enumbase(self):
            return self.getTypedRuleContext(CPP14Parser.EnumbaseContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_enumHead

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumHead" ):
                listener.enterEnumHead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumHead" ):
                listener.exitEnumHead(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumHead" ):
                return visitor.visitEnumHead(self)
            else:
                return visitor.visitChildren(self)




    def enumHead(self):

        localctx = CPP14Parser.EnumHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_enumHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1196
            self.enumkey()
            self.state = 1198
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1197
                self.attributeSpecifierSeq()


            self.state = 1204
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==27 or _la==130 or _la==136:
                self.state = 1201
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                if la_ == 1:
                    self.state = 1200
                    self.nestedNameSpecifier(0)


                self.state = 1203
                self.match(CPP14Parser.Identifier)


            self.state = 1207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==129:
                self.state = 1206
                self.enumbase()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OpaqueEnumDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumkey(self):
            return self.getTypedRuleContext(CPP14Parser.EnumkeyContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def enumbase(self):
            return self.getTypedRuleContext(CPP14Parser.EnumbaseContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_opaqueEnumDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOpaqueEnumDeclaration" ):
                listener.enterOpaqueEnumDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOpaqueEnumDeclaration" ):
                listener.exitOpaqueEnumDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOpaqueEnumDeclaration" ):
                return visitor.visitOpaqueEnumDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def opaqueEnumDeclaration(self):

        localctx = CPP14Parser.OpaqueEnumDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_opaqueEnumDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1209
            self.enumkey()
            self.state = 1211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1210
                self.attributeSpecifierSeq()


            self.state = 1213
            self.match(CPP14Parser.Identifier)
            self.state = 1215
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==129:
                self.state = 1214
                self.enumbase()


            self.state = 1217
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumkeyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Enum(self):
            return self.getToken(CPP14Parser.Enum, 0)

        def Class(self):
            return self.getToken(CPP14Parser.Class, 0)

        def Struct(self):
            return self.getToken(CPP14Parser.Struct, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumkey

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumkey" ):
                listener.enterEnumkey(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumkey" ):
                listener.exitEnumkey(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumkey" ):
                return visitor.visitEnumkey(self)
            else:
                return visitor.visitChildren(self)




    def enumkey(self):

        localctx = CPP14Parser.EnumkeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_enumkey)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1219
            self.match(CPP14Parser.Enum)
            self.state = 1221
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22 or _la==68:
                self.state = 1220
                _la = self._input.LA(1)
                if not(_la==22 or _la==68):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumbaseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_enumbase

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumbase" ):
                listener.enterEnumbase(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumbase" ):
                listener.exitEnumbase(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumbase" ):
                return visitor.visitEnumbase(self)
            else:
                return visitor.visitChildren(self)




    def enumbase(self):

        localctx = CPP14Parser.EnumbaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_enumbase)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1223
            self.match(CPP14Parser.Colon)
            self.state = 1224
            self.typeSpecifierSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumeratorListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumeratorDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.EnumeratorDefinitionContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.EnumeratorDefinitionContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumeratorList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumeratorList" ):
                listener.enterEnumeratorList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumeratorList" ):
                listener.exitEnumeratorList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumeratorList" ):
                return visitor.visitEnumeratorList(self)
            else:
                return visitor.visitChildren(self)




    def enumeratorList(self):

        localctx = CPP14Parser.EnumeratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_enumeratorList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1226
            self.enumeratorDefinition()
            self.state = 1231
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,140,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1227
                    self.match(CPP14Parser.Comma)
                    self.state = 1228
                    self.enumeratorDefinition() 
                self.state = 1233
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,140,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumeratorDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumerator(self):
            return self.getTypedRuleContext(CPP14Parser.EnumeratorContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_enumeratorDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumeratorDefinition" ):
                listener.enterEnumeratorDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumeratorDefinition" ):
                listener.exitEnumeratorDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumeratorDefinition" ):
                return visitor.visitEnumeratorDefinition(self)
            else:
                return visitor.visitChildren(self)




    def enumeratorDefinition(self):

        localctx = CPP14Parser.EnumeratorDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_enumeratorDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1234
            self.enumerator()
            self.state = 1237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==104:
                self.state = 1235
                self.match(CPP14Parser.Assign)
                self.state = 1236
                self.constantExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumeratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_enumerator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnumerator" ):
                listener.enterEnumerator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnumerator" ):
                listener.exitEnumerator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEnumerator" ):
                return visitor.visitEnumerator(self)
            else:
                return visitor.visitChildren(self)




    def enumerator(self):

        localctx = CPP14Parser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_enumerator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1239
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def originalNamespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.OriginalNamespaceNameContext,0)


        def namespaceAlias(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceAliasContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceName" ):
                listener.enterNamespaceName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceName" ):
                listener.exitNamespaceName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceName" ):
                return visitor.visitNamespaceName(self)
            else:
                return visitor.visitChildren(self)




    def namespaceName(self):

        localctx = CPP14Parser.NamespaceNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_namespaceName)
        try:
            self.state = 1243
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1241
                self.originalNamespaceName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1242
                self.namespaceAlias()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OriginalNamespaceNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_originalNamespaceName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOriginalNamespaceName" ):
                listener.enterOriginalNamespaceName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOriginalNamespaceName" ):
                listener.exitOriginalNamespaceName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOriginalNamespaceName" ):
                return visitor.visitOriginalNamespaceName(self)
            else:
                return visitor.visitChildren(self)




    def originalNamespaceName(self):

        localctx = CPP14Parser.OriginalNamespaceNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_originalNamespaceName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1245
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.namespaceBody = None # DeclarationseqContext

        def Namespace(self):
            return self.getToken(CPP14Parser.Namespace, 0)

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def Inline(self):
            return self.getToken(CPP14Parser.Inline, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def originalNamespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.OriginalNamespaceNameContext,0)


        def declarationseq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceDefinition" ):
                listener.enterNamespaceDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceDefinition" ):
                listener.exitNamespaceDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceDefinition" ):
                return visitor.visitNamespaceDefinition(self)
            else:
                return visitor.visitChildren(self)




    def namespaceDefinition(self):

        localctx = CPP14Parser.NamespaceDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_namespaceDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1248
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==46:
                self.state = 1247
                self.match(CPP14Parser.Inline)


            self.state = 1250
            self.match(CPP14Parser.Namespace)
            self.state = 1253
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1251
                self.match(CPP14Parser.Identifier)

            elif la_ == 2:
                self.state = 1252
                self.originalNamespaceName()


            self.state = 1255
            self.match(CPP14Parser.LeftBrace)
            self.state = 1257
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 3087508886339534621) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 1035845506523737085) != 0:
                self.state = 1256
                localctx.namespaceBody = self.declarationseq()


            self.state = 1259
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceAliasContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceAlias

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceAlias" ):
                listener.enterNamespaceAlias(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceAlias" ):
                listener.exitNamespaceAlias(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceAlias" ):
                return visitor.visitNamespaceAlias(self)
            else:
                return visitor.visitChildren(self)




    def namespaceAlias(self):

        localctx = CPP14Parser.NamespaceAliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_namespaceAlias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1261
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceAliasDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Namespace(self):
            return self.getToken(CPP14Parser.Namespace, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def qualifiednamespacespecifier(self):
            return self.getTypedRuleContext(CPP14Parser.QualifiednamespacespecifierContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_namespaceAliasDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespaceAliasDefinition" ):
                listener.enterNamespaceAliasDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespaceAliasDefinition" ):
                listener.exitNamespaceAliasDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamespaceAliasDefinition" ):
                return visitor.visitNamespaceAliasDefinition(self)
            else:
                return visitor.visitChildren(self)




    def namespaceAliasDefinition(self):

        localctx = CPP14Parser.NamespaceAliasDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_namespaceAliasDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1263
            self.match(CPP14Parser.Namespace)
            self.state = 1264
            self.match(CPP14Parser.Identifier)
            self.state = 1265
            self.match(CPP14Parser.Assign)
            self.state = 1266
            self.qualifiednamespacespecifier()
            self.state = 1267
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiednamespacespecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_qualifiednamespacespecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualifiednamespacespecifier" ):
                listener.enterQualifiednamespacespecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualifiednamespacespecifier" ):
                listener.exitQualifiednamespacespecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitQualifiednamespacespecifier" ):
                return visitor.visitQualifiednamespacespecifier(self)
            else:
                return visitor.visitChildren(self)




    def qualifiednamespacespecifier(self):

        localctx = CPP14Parser.QualifiednamespacespecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_qualifiednamespacespecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.state = 1269
                self.nestedNameSpecifier(0)


            self.state = 1272
            self.namespaceName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Using(self):
            return self.getToken(CPP14Parser.Using, 0)

        def unqualifiedId(self):
            return self.getTypedRuleContext(CPP14Parser.UnqualifiedIdContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Typename_(self):
            return self.getToken(CPP14Parser.Typename_, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_usingDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingDeclaration" ):
                listener.enterUsingDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingDeclaration" ):
                listener.exitUsingDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingDeclaration" ):
                return visitor.visitUsingDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def usingDeclaration(self):

        localctx = CPP14Parser.UsingDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_usingDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1274
            self.match(CPP14Parser.Using)
            self.state = 1280
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.state = 1276
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==79:
                    self.state = 1275
                    self.match(CPP14Parser.Typename_)


                self.state = 1278
                self.nestedNameSpecifier(0)
                pass

            elif la_ == 2:
                self.state = 1279
                self.match(CPP14Parser.Doublecolon)
                pass


            self.state = 1282
            self.unqualifiedId()
            self.state = 1283
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Using(self):
            return self.getToken(CPP14Parser.Using, 0)

        def Namespace(self):
            return self.getToken(CPP14Parser.Namespace, 0)

        def namespaceName(self):
            return self.getTypedRuleContext(CPP14Parser.NamespaceNameContext,0)


        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_usingDirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingDirective" ):
                listener.enterUsingDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingDirective" ):
                listener.exitUsingDirective(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUsingDirective" ):
                return visitor.visitUsingDirective(self)
            else:
                return visitor.visitChildren(self)




    def usingDirective(self):

        localctx = CPP14Parser.UsingDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_usingDirective)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1286
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1285
                self.attributeSpecifierSeq()


            self.state = 1288
            self.match(CPP14Parser.Using)
            self.state = 1289
            self.match(CPP14Parser.Namespace)
            self.state = 1291
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
            if la_ == 1:
                self.state = 1290
                self.nestedNameSpecifier(0)


            self.state = 1293
            self.namespaceName()
            self.state = 1294
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AsmDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Asm(self):
            return self.getToken(CPP14Parser.Asm, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_asmDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAsmDefinition" ):
                listener.enterAsmDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAsmDefinition" ):
                listener.exitAsmDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAsmDefinition" ):
                return visitor.visitAsmDefinition(self)
            else:
                return visitor.visitChildren(self)




    def asmDefinition(self):

        localctx = CPP14Parser.AsmDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_asmDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1296
            self.match(CPP14Parser.Asm)
            self.state = 1297
            self.match(CPP14Parser.LeftParen)
            self.state = 1298
            self.match(CPP14Parser.StringLiteral)
            self.state = 1299
            self.match(CPP14Parser.RightParen)
            self.state = 1300
            self.match(CPP14Parser.Semi)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LinkageSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Extern(self):
            return self.getToken(CPP14Parser.Extern, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def declarationseq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_linkageSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLinkageSpecification" ):
                listener.enterLinkageSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLinkageSpecification" ):
                listener.exitLinkageSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLinkageSpecification" ):
                return visitor.visitLinkageSpecification(self)
            else:
                return visitor.visitChildren(self)




    def linkageSpecification(self):

        localctx = CPP14Parser.LinkageSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_linkageSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1302
            self.match(CPP14Parser.Extern)
            self.state = 1303
            self.match(CPP14Parser.StringLiteral)
            self.state = 1310
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [92]:
                self.state = 1304
                self.match(CPP14Parser.LeftBrace)
                self.state = 1306
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 3087508886339534621) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 1035845506523737085) != 0:
                    self.state = 1305
                    self.declarationseq()


                self.state = 1308
                self.match(CPP14Parser.RightBrace)
                pass
            elif token in [11, 13, 14, 15, 19, 20, 21, 22, 23, 24, 27, 32, 35, 36, 38, 41, 43, 46, 47, 48, 49, 50, 54, 59, 62, 63, 65, 66, 68, 70, 72, 77, 79, 80, 81, 82, 83, 84, 85, 86, 88, 90, 96, 100, 102, 121, 130, 131, 134, 135, 136]:
                self.state = 1309
                self.declaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attributeSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AttributeSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeSpecifierSeq" ):
                listener.enterAttributeSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeSpecifierSeq" ):
                listener.exitAttributeSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeSpecifierSeq" ):
                return visitor.visitAttributeSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def attributeSpecifierSeq(self):

        localctx = CPP14Parser.AttributeSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_attributeSpecifierSeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1313 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1312
                    self.attributeSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1315 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftBracket)
            else:
                return self.getToken(CPP14Parser.LeftBracket, i)

        def RightBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightBracket)
            else:
                return self.getToken(CPP14Parser.RightBracket, i)

        def attributeList(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeListContext,0)


        def alignmentspecifier(self):
            return self.getTypedRuleContext(CPP14Parser.AlignmentspecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeSpecifier" ):
                listener.enterAttributeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeSpecifier" ):
                listener.exitAttributeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeSpecifier" ):
                return visitor.visitAttributeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def attributeSpecifier(self):

        localctx = CPP14Parser.AttributeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_attributeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1325
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [90]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1317
                self.match(CPP14Parser.LeftBracket)
                self.state = 1318
                self.match(CPP14Parser.LeftBracket)
                self.state = 1320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==136:
                    self.state = 1319
                    self.attributeList()


                self.state = 1322
                self.match(CPP14Parser.RightBracket)
                self.state = 1323
                self.match(CPP14Parser.RightBracket)
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1324
                self.alignmentspecifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AlignmentspecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Alignas(self):
            return self.getToken(CPP14Parser.Alignas, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_alignmentspecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAlignmentspecifier" ):
                listener.enterAlignmentspecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAlignmentspecifier" ):
                listener.exitAlignmentspecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAlignmentspecifier" ):
                return visitor.visitAlignmentspecifier(self)
            else:
                return visitor.visitChildren(self)




    def alignmentspecifier(self):

        localctx = CPP14Parser.AlignmentspecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_alignmentspecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1327
            self.match(CPP14Parser.Alignas)
            self.state = 1328
            self.match(CPP14Parser.LeftParen)
            self.state = 1331
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
            if la_ == 1:
                self.state = 1329
                self.theTypeId()
                pass

            elif la_ == 2:
                self.state = 1330
                self.constantExpression()
                pass


            self.state = 1334
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1333
                self.match(CPP14Parser.Ellipsis)


            self.state = 1336
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AttributeContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AttributeContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeList" ):
                listener.enterAttributeList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeList" ):
                listener.exitAttributeList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeList" ):
                return visitor.visitAttributeList(self)
            else:
                return visitor.visitChildren(self)




    def attributeList(self):

        localctx = CPP14Parser.AttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_attributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1338
            self.attribute()
            self.state = 1343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1339
                self.match(CPP14Parser.Comma)
                self.state = 1340
                self.attribute()
                self.state = 1345
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1347
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1346
                self.match(CPP14Parser.Ellipsis)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def attributeNamespace(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeNamespaceContext,0)


        def Doublecolon(self):
            return self.getToken(CPP14Parser.Doublecolon, 0)

        def attributeArgumentClause(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeArgumentClauseContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attribute

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute" ):
                listener.enterAttribute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute" ):
                listener.exitAttribute(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttribute" ):
                return visitor.visitAttribute(self)
            else:
                return visitor.visitChildren(self)




    def attribute(self):

        localctx = CPP14Parser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1352
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.state = 1349
                self.attributeNamespace()
                self.state = 1350
                self.match(CPP14Parser.Doublecolon)


            self.state = 1354
            self.match(CPP14Parser.Identifier)
            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==88:
                self.state = 1355
                self.attributeArgumentClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeNamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeNamespace

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeNamespace" ):
                listener.enterAttributeNamespace(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeNamespace" ):
                listener.exitAttributeNamespace(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeNamespace" ):
                return visitor.visitAttributeNamespace(self)
            else:
                return visitor.visitChildren(self)




    def attributeNamespace(self):

        localctx = CPP14Parser.AttributeNamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_attributeNamespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1358
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeArgumentClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def balancedTokenSeq(self):
            return self.getTypedRuleContext(CPP14Parser.BalancedTokenSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_attributeArgumentClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributeArgumentClause" ):
                listener.enterAttributeArgumentClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributeArgumentClause" ):
                listener.exitAttributeArgumentClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributeArgumentClause" ):
                return visitor.visitAttributeArgumentClause(self)
            else:
                return visitor.visitChildren(self)




    def attributeArgumentClause(self):

        localctx = CPP14Parser.AttributeArgumentClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_attributeArgumentClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1360
            self.match(CPP14Parser.LeftParen)
            self.state = 1362
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -704643073) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 4194303) != 0:
                self.state = 1361
                self.balancedTokenSeq()


            self.state = 1364
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BalancedTokenSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def balancedtoken(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.BalancedtokenContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.BalancedtokenContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_balancedTokenSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBalancedTokenSeq" ):
                listener.enterBalancedTokenSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBalancedTokenSeq" ):
                listener.exitBalancedTokenSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBalancedTokenSeq" ):
                return visitor.visitBalancedTokenSeq(self)
            else:
                return visitor.visitChildren(self)




    def balancedTokenSeq(self):

        localctx = CPP14Parser.BalancedTokenSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_balancedTokenSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1367 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1366
                self.balancedtoken()
                self.state = 1369 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -704643073) != 0 or (((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 4194303) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BalancedtokenContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftParen)
            else:
                return self.getToken(CPP14Parser.LeftParen, i)

        def balancedTokenSeq(self):
            return self.getTypedRuleContext(CPP14Parser.BalancedTokenSeqContext,0)


        def RightParen(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightParen)
            else:
                return self.getToken(CPP14Parser.RightParen, i)

        def LeftBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftBracket)
            else:
                return self.getToken(CPP14Parser.LeftBracket, i)

        def RightBracket(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightBracket)
            else:
                return self.getToken(CPP14Parser.RightBracket, i)

        def LeftBrace(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.LeftBrace)
            else:
                return self.getToken(CPP14Parser.LeftBrace, i)

        def RightBrace(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.RightBrace)
            else:
                return self.getToken(CPP14Parser.RightBrace, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_balancedtoken

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBalancedtoken" ):
                listener.enterBalancedtoken(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBalancedtoken" ):
                listener.exitBalancedtoken(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBalancedtoken" ):
                return visitor.visitBalancedtoken(self)
            else:
                return visitor.visitChildren(self)




    def balancedtoken(self):

        localctx = CPP14Parser.BalancedtokenContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_balancedtoken)
        self._la = 0 # Token type
        try:
            self.state = 1388
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [88]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1371
                self.match(CPP14Parser.LeftParen)
                self.state = 1372
                self.balancedTokenSeq()
                self.state = 1373
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1375
                self.match(CPP14Parser.LeftBracket)
                self.state = 1376
                self.balancedTokenSeq()
                self.state = 1377
                self.match(CPP14Parser.RightBracket)
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1379
                self.match(CPP14Parser.LeftBrace)
                self.state = 1380
                self.balancedTokenSeq()
                self.state = 1381
                self.match(CPP14Parser.RightBrace)
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1384 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1383
                        _la = self._input.LA(1)
                        if _la <= 0 or (((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & 63) != 0:
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1386 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,164,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def initDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.InitDeclaratorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.InitDeclaratorContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initDeclaratorList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitDeclaratorList" ):
                listener.enterInitDeclaratorList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitDeclaratorList" ):
                listener.exitInitDeclaratorList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitDeclaratorList" ):
                return visitor.visitInitDeclaratorList(self)
            else:
                return visitor.visitChildren(self)




    def initDeclaratorList(self):

        localctx = CPP14Parser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1390
            self.initDeclarator()
            self.state = 1395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1391
                self.match(CPP14Parser.Comma)
                self.state = 1392
                self.initDeclarator()
                self.state = 1397
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def initializer(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_initDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitDeclarator" ):
                listener.enterInitDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitDeclarator" ):
                listener.exitInitDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitDeclarator" ):
                return visitor.visitInitDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def initDeclarator(self):

        localctx = CPP14Parser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1398
            self.declarator()
            self.state = 1400
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & 65553) != 0:
                self.state = 1399
                self.initializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerDeclaratorContext,0)


        def noPointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def trailingReturnType(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingReturnTypeContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclarator" ):
                listener.enterDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclarator" ):
                listener.exitDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclarator" ):
                return visitor.visitDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def declarator(self):

        localctx = CPP14Parser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_declarator)
        try:
            self.state = 1407
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1402
                self.pointerDeclarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1403
                self.noPointerDeclarator(0)
                self.state = 1404
                self.parametersAndQualifiers()
                self.state = 1405
                self.trailingReturnType()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def noPointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerDeclaratorContext,0)


        def pointerOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,i)


        def Const(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Const)
            else:
                return self.getToken(CPP14Parser.Const, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerDeclarator" ):
                listener.enterPointerDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerDeclarator" ):
                listener.exitPointerDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerDeclarator" ):
                return visitor.visitPointerDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def pointerDeclarator(self):

        localctx = CPP14Parser.PointerDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_pointerDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1415
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,170,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1409
                    self.pointerOperator()
                    self.state = 1411
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==23:
                        self.state = 1410
                        self.match(CPP14Parser.Const)

             
                self.state = 1417
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,170,self._ctx)

            self.state = 1418
            self.noPointerDeclarator(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declaratorid(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratoridContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def pointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerDeclaratorContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def noPointerDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerDeclarator" ):
                listener.enterNoPointerDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerDeclarator" ):
                listener.exitNoPointerDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerDeclarator" ):
                return visitor.visitNoPointerDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 230
        self.enterRecursionRule(localctx, 230, self.RULE_noPointerDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1429
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [27, 54, 102, 130, 134, 136]:
                self.state = 1421
                self.declaratorid()
                self.state = 1423
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                if la_ == 1:
                    self.state = 1422
                    self.attributeSpecifierSeq()


                pass
            elif token in [88]:
                self.state = 1425
                self.match(CPP14Parser.LeftParen)
                self.state = 1426
                self.pointerDeclarator()
                self.state = 1427
                self.match(CPP14Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1445
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,176,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerDeclarator)
                    self.state = 1431
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1441
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [88]:
                        self.state = 1432
                        self.parametersAndQualifiers()
                        pass
                    elif token in [90]:
                        self.state = 1433
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 1435
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307923593) != 0 or _la==130 or _la==136:
                            self.state = 1434
                            self.constantExpression()


                        self.state = 1437
                        self.match(CPP14Parser.RightBracket)
                        self.state = 1439
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                        if la_ == 1:
                            self.state = 1438
                            self.attributeSpecifierSeq()


                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1447
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,176,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ParametersAndQualifiersContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def parameterDeclarationClause(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationClauseContext,0)


        def cvqualifierseq(self):
            return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)


        def refqualifier(self):
            return self.getTypedRuleContext(CPP14Parser.RefqualifierContext,0)


        def exceptionSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.ExceptionSpecificationContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_parametersAndQualifiers

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParametersAndQualifiers" ):
                listener.enterParametersAndQualifiers(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParametersAndQualifiers" ):
                listener.exitParametersAndQualifiers(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParametersAndQualifiers" ):
                return visitor.visitParametersAndQualifiers(self)
            else:
                return visitor.visitChildren(self)




    def parametersAndQualifiers(self):

        localctx = CPP14Parser.ParametersAndQualifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_parametersAndQualifiers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1448
            self.match(CPP14Parser.LeftParen)
            self.state = 1450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 2475009991168311065) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 585467951558173661) != 0:
                self.state = 1449
                self.parameterDeclarationClause()


            self.state = 1452
            self.match(CPP14Parser.RightParen)
            self.state = 1454
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.state = 1453
                self.cvqualifierseq()


            self.state = 1457
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
            if la_ == 1:
                self.state = 1456
                self.refqualifier()


            self.state = 1460
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 1459
                self.exceptionSpecification()


            self.state = 1463
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
            if la_ == 1:
                self.state = 1462
                self.attributeSpecifierSeq()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailingReturnTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Arrow(self):
            return self.getToken(CPP14Parser.Arrow, 0)

        def trailingTypeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingTypeSpecifierSeqContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_trailingReturnType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailingReturnType" ):
                listener.enterTrailingReturnType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailingReturnType" ):
                listener.exitTrailingReturnType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailingReturnType" ):
                return visitor.visitTrailingReturnType(self)
            else:
                return visitor.visitChildren(self)




    def trailingReturnType(self):

        localctx = CPP14Parser.TrailingReturnTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_trailingReturnType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1465
            self.match(CPP14Parser.Arrow)
            self.state = 1466
            self.trailingTypeSpecifierSeq()
            self.state = 1468
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
            if la_ == 1:
                self.state = 1467
                self.abstractDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def AndAnd(self):
            return self.getToken(CPP14Parser.AndAnd, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def Star(self):
            return self.getToken(CPP14Parser.Star, 0)

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def cvqualifierseq(self):
            return self.getTypedRuleContext(CPP14Parser.CvqualifierseqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerOperator" ):
                listener.enterPointerOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerOperator" ):
                listener.exitPointerOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerOperator" ):
                return visitor.visitPointerOperator(self)
            else:
                return visitor.visitChildren(self)




    def pointerOperator(self):

        localctx = CPP14Parser.PointerOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_pointerOperator)
        self._la = 0 # Token type
        try:
            self.state = 1484
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [100, 121]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1470
                _la = self._input.LA(1)
                if not(_la==100 or _la==121):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1472
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
                if la_ == 1:
                    self.state = 1471
                    self.attributeSpecifierSeq()


                pass
            elif token in [27, 96, 130, 136]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1475
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==27 or _la==130 or _la==136:
                    self.state = 1474
                    self.nestedNameSpecifier(0)


                self.state = 1477
                self.match(CPP14Parser.Star)
                self.state = 1479
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
                if la_ == 1:
                    self.state = 1478
                    self.attributeSpecifierSeq()


                self.state = 1482
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1481
                    self.cvqualifierseq()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CvqualifierseqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def cvQualifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.CvQualifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.CvQualifierContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_cvqualifierseq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCvqualifierseq" ):
                listener.enterCvqualifierseq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCvqualifierseq" ):
                listener.exitCvqualifierseq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCvqualifierseq" ):
                return visitor.visitCvqualifierseq(self)
            else:
                return visitor.visitChildren(self)




    def cvqualifierseq(self):

        localctx = CPP14Parser.CvqualifierseqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_cvqualifierseq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1487 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1486
                    self.cvQualifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1489 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,188,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CvQualifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Const(self):
            return self.getToken(CPP14Parser.Const, 0)

        def Volatile(self):
            return self.getToken(CPP14Parser.Volatile, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_cvQualifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCvQualifier" ):
                listener.enterCvQualifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCvQualifier" ):
                listener.exitCvQualifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCvQualifier" ):
                return visitor.visitCvQualifier(self)
            else:
                return visitor.visitChildren(self)




    def cvQualifier(self):

        localctx = CPP14Parser.CvQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_cvQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1491
            _la = self._input.LA(1)
            if not(_la==23 or _la==85):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RefqualifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def AndAnd(self):
            return self.getToken(CPP14Parser.AndAnd, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_refqualifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRefqualifier" ):
                listener.enterRefqualifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRefqualifier" ):
                listener.exitRefqualifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRefqualifier" ):
                return visitor.visitRefqualifier(self)
            else:
                return visitor.visitChildren(self)




    def refqualifier(self):

        localctx = CPP14Parser.RefqualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_refqualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1493
            _la = self._input.LA(1)
            if not(_la==100 or _la==121):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclaratoridContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_declaratorid

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclaratorid" ):
                listener.enterDeclaratorid(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclaratorid" ):
                listener.exitDeclaratorid(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDeclaratorid" ):
                return visitor.visitDeclaratorid(self)
            else:
                return visitor.visitChildren(self)




    def declaratorid(self):

        localctx = CPP14Parser.DeclaratoridContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_declaratorid)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1496
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1495
                self.match(CPP14Parser.Ellipsis)


            self.state = 1498
            self.idExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_theTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTheTypeId" ):
                listener.enterTheTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTheTypeId" ):
                listener.exitTheTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheTypeId" ):
                return visitor.visitTheTypeId(self)
            else:
                return visitor.visitChildren(self)




    def theTypeId(self):

        localctx = CPP14Parser.TheTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_theTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1500
            self.typeSpecifierSeq()
            self.state = 1502
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.state = 1501
                self.abstractDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerAbstractDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def trailingReturnType(self):
            return self.getTypedRuleContext(CPP14Parser.TrailingReturnTypeContext,0)


        def noPointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractDeclaratorContext,0)


        def abstractPackDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractPackDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_abstractDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAbstractDeclarator" ):
                listener.enterAbstractDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAbstractDeclarator" ):
                listener.exitAbstractDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAbstractDeclarator" ):
                return visitor.visitAbstractDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def abstractDeclarator(self):

        localctx = CPP14Parser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_abstractDeclarator)
        try:
            self.state = 1512
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1504
                self.pointerAbstractDeclarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1506
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
                if la_ == 1:
                    self.state = 1505
                    self.noPointerAbstractDeclarator(0)


                self.state = 1508
                self.parametersAndQualifiers()
                self.state = 1509
                self.trailingReturnType()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1511
                self.abstractPackDeclarator()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PointerAbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def noPointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractDeclaratorContext,0)


        def pointerOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_pointerAbstractDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointerAbstractDeclarator" ):
                listener.enterPointerAbstractDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointerAbstractDeclarator" ):
                listener.exitPointerAbstractDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPointerAbstractDeclarator" ):
                return visitor.visitPointerAbstractDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def pointerAbstractDeclarator(self):

        localctx = CPP14Parser.PointerAbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_pointerAbstractDeclarator)
        try:
            self.state = 1523
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [88, 90]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1514
                self.noPointerAbstractDeclarator(0)
                pass
            elif token in [27, 96, 100, 121, 130, 136]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1516 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1515
                        self.pointerOperator()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1518 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,193,self._ctx)

                self.state = 1521
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
                if la_ == 1:
                    self.state = 1520
                    self.noPointerAbstractDeclarator(0)


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerAbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def pointerAbstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerAbstractDeclaratorContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def noPointerAbstractDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.NoPointerAbstractDeclaratorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractDeclaratorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerAbstractDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerAbstractDeclarator" ):
                listener.enterNoPointerAbstractDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerAbstractDeclarator" ):
                listener.exitNoPointerAbstractDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerAbstractDeclarator" ):
                return visitor.visitNoPointerAbstractDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerAbstractDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerAbstractDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 252
        self.enterRecursionRule(localctx, 252, self.RULE_noPointerAbstractDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1539
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1526
                self.parametersAndQualifiers()
                pass

            elif la_ == 2:
                self.state = 1527
                self.match(CPP14Parser.LeftBracket)
                self.state = 1529
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307923593) != 0 or _la==130 or _la==136:
                    self.state = 1528
                    self.constantExpression()


                self.state = 1531
                self.match(CPP14Parser.RightBracket)
                self.state = 1533
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
                if la_ == 1:
                    self.state = 1532
                    self.attributeSpecifierSeq()


                pass

            elif la_ == 3:
                self.state = 1535
                self.match(CPP14Parser.LeftParen)
                self.state = 1536
                self.pointerAbstractDeclarator()
                self.state = 1537
                self.match(CPP14Parser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1556
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,202,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerAbstractDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerAbstractDeclarator)
                    self.state = 1541
                    if not self.precpred(self._ctx, 4):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                    self.state = 1552
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                    if la_ == 1:
                        self.state = 1542
                        self.parametersAndQualifiers()
                        pass

                    elif la_ == 2:
                        self.state = 1543
                        self.noPointerAbstractDeclarator(0)
                        self.state = 1544
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 1546
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307923593) != 0 or _la==130 or _la==136:
                            self.state = 1545
                            self.constantExpression()


                        self.state = 1548
                        self.match(CPP14Parser.RightBracket)
                        self.state = 1550
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
                        if la_ == 1:
                            self.state = 1549
                            self.attributeSpecifierSeq()


                        pass

             
                self.state = 1558
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,202,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class AbstractPackDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def noPointerAbstractPackDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractPackDeclaratorContext,0)


        def pointerOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.PointerOperatorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_abstractPackDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAbstractPackDeclarator" ):
                listener.enterAbstractPackDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAbstractPackDeclarator" ):
                listener.exitAbstractPackDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAbstractPackDeclarator" ):
                return visitor.visitAbstractPackDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def abstractPackDeclarator(self):

        localctx = CPP14Parser.AbstractPackDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_abstractPackDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1562
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==27 or (((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & 1116725051409) != 0:
                self.state = 1559
                self.pointerOperator()
                self.state = 1564
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1565
            self.noPointerAbstractPackDeclarator(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoPointerAbstractPackDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def noPointerAbstractPackDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.NoPointerAbstractPackDeclaratorContext,0)


        def parametersAndQualifiers(self):
            return self.getTypedRuleContext(CPP14Parser.ParametersAndQualifiersContext,0)


        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_noPointerAbstractPackDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoPointerAbstractPackDeclarator" ):
                listener.enterNoPointerAbstractPackDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoPointerAbstractPackDeclarator" ):
                listener.exitNoPointerAbstractPackDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoPointerAbstractPackDeclarator" ):
                return visitor.visitNoPointerAbstractPackDeclarator(self)
            else:
                return visitor.visitChildren(self)



    def noPointerAbstractPackDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CPP14Parser.NoPointerAbstractPackDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 256
        self.enterRecursionRule(localctx, 256, self.RULE_noPointerAbstractPackDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1568
            self.match(CPP14Parser.Ellipsis)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1584
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,207,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CPP14Parser.NoPointerAbstractPackDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_noPointerAbstractPackDeclarator)
                    self.state = 1570
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1580
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [88]:
                        self.state = 1571
                        self.parametersAndQualifiers()
                        pass
                    elif token in [90]:
                        self.state = 1572
                        self.match(CPP14Parser.LeftBracket)
                        self.state = 1574
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307923593) != 0 or _la==130 or _la==136:
                            self.state = 1573
                            self.constantExpression()


                        self.state = 1576
                        self.match(CPP14Parser.RightBracket)
                        self.state = 1578
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
                        if la_ == 1:
                            self.state = 1577
                            self.attributeSpecifierSeq()


                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1586
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,207,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ParameterDeclarationClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterDeclarationList(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationListContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_parameterDeclarationClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterDeclarationClause" ):
                listener.enterParameterDeclarationClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterDeclarationClause" ):
                listener.exitParameterDeclarationClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterDeclarationClause" ):
                return visitor.visitParameterDeclarationClause(self)
            else:
                return visitor.visitChildren(self)




    def parameterDeclarationClause(self):

        localctx = CPP14Parser.ParameterDeclarationClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_parameterDeclarationClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1587
            self.parameterDeclarationList()
            self.state = 1592
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==125 or _la==134:
                self.state = 1589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==125:
                    self.state = 1588
                    self.match(CPP14Parser.Comma)


                self.state = 1591
                self.match(CPP14Parser.Ellipsis)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameterDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.ParameterDeclarationContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_parameterDeclarationList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterDeclarationList" ):
                listener.enterParameterDeclarationList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterDeclarationList" ):
                listener.exitParameterDeclarationList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterDeclarationList" ):
                return visitor.visitParameterDeclarationList(self)
            else:
                return visitor.visitChildren(self)




    def parameterDeclarationList(self):

        localctx = CPP14Parser.ParameterDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_parameterDeclarationList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1594
            self.parameterDeclaration()
            self.state = 1599
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,210,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1595
                    self.match(CPP14Parser.Comma)
                    self.state = 1596
                    self.parameterDeclaration() 
                self.state = 1601
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,210,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_parameterDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameterDeclaration" ):
                listener.enterParameterDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameterDeclaration" ):
                listener.exitParameterDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParameterDeclaration" ):
                return visitor.visitParameterDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def parameterDeclaration(self):

        localctx = CPP14Parser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_parameterDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1603
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1602
                self.attributeSpecifierSeq()


            self.state = 1605
            self.declSpecifierSeq()

            self.state = 1610
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.state = 1606
                self.declarator()
                pass

            elif la_ == 2:
                self.state = 1608
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1607
                    self.abstractDeclarator()


                pass


            self.state = 1614
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==104:
                self.state = 1612
                self.match(CPP14Parser.Assign)
                self.state = 1613
                self.initializerClause()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def functionBody(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionBodyContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def virtualSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.VirtualSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_functionDefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionDefinition" ):
                listener.enterFunctionDefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionDefinition" ):
                listener.exitFunctionDefinition(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionDefinition" ):
                return visitor.visitFunctionDefinition(self)
            else:
                return visitor.visitChildren(self)




    def functionDefinition(self):

        localctx = CPP14Parser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1617
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1616
                self.attributeSpecifierSeq()


            self.state = 1620
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
            if la_ == 1:
                self.state = 1619
                self.declSpecifierSeq()


            self.state = 1622
            self.declarator()
            self.state = 1624
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==40 or _la==55:
                self.state = 1623
                self.virtualSpecifierSeq()


            self.state = 1626
            self.functionBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionBodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def constructorInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.ConstructorInitializerContext,0)


        def functionTryBlock(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionTryBlockContext,0)


        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def Default(self):
            return self.getToken(CPP14Parser.Default, 0)

        def Delete(self):
            return self.getToken(CPP14Parser.Delete, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_functionBody

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionBody" ):
                listener.enterFunctionBody(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionBody" ):
                listener.exitFunctionBody(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionBody" ):
                return visitor.visitFunctionBody(self)
            else:
                return visitor.visitChildren(self)




    def functionBody(self):

        localctx = CPP14Parser.FunctionBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_functionBody)
        self._la = 0 # Token type
        try:
            self.state = 1636
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [92, 129]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1629
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==129:
                    self.state = 1628
                    self.constructorInitializer()


                self.state = 1631
                self.compoundStatement()
                pass
            elif token in [76]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1632
                self.functionTryBlock()
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1633
                self.match(CPP14Parser.Assign)
                self.state = 1634
                _la = self._input.LA(1)
                if not(_la==28 or _la==30):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1635
                self.match(CPP14Parser.Semi)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def braceOrEqualInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.BraceOrEqualInitializerContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitializer" ):
                listener.enterInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitializer" ):
                listener.exitInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitializer" ):
                return visitor.visitInitializer(self)
            else:
                return visitor.visitChildren(self)




    def initializer(self):

        localctx = CPP14Parser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_initializer)
        try:
            self.state = 1643
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [92, 104]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1638
                self.braceOrEqualInitializer()
                pass
            elif token in [88]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1639
                self.match(CPP14Parser.LeftParen)
                self.state = 1640
                self.expressionList()
                self.state = 1641
                self.match(CPP14Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BraceOrEqualInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def initializerClause(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_braceOrEqualInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBraceOrEqualInitializer" ):
                listener.enterBraceOrEqualInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBraceOrEqualInitializer" ):
                listener.exitBraceOrEqualInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBraceOrEqualInitializer" ):
                return visitor.visitBraceOrEqualInitializer(self)
            else:
                return visitor.visitChildren(self)




    def braceOrEqualInitializer(self):

        localctx = CPP14Parser.BraceOrEqualInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_braceOrEqualInitializer)
        try:
            self.state = 1648
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [104]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1645
                self.match(CPP14Parser.Assign)
                self.state = 1646
                self.initializerClause()
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1647
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def assignmentExpression(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,0)


        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_initializerClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitializerClause" ):
                listener.enterInitializerClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitializerClause" ):
                listener.exitInitializerClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitializerClause" ):
                return visitor.visitInitializerClause(self)
            else:
                return visitor.visitChildren(self)




    def initializerClause(self):

        localctx = CPP14Parser.InitializerClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_initializerClause)
        try:
            self.state = 1652
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 12, 14, 15, 19, 20, 21, 25, 27, 30, 32, 33, 41, 47, 48, 51, 52, 54, 60, 62, 63, 64, 67, 71, 73, 78, 79, 81, 84, 86, 88, 90, 94, 95, 96, 100, 101, 102, 103, 123, 124, 130, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1650
                self.assignmentExpression()
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1651
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def initializerClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.InitializerClauseContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.InitializerClauseContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_initializerList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInitializerList" ):
                listener.enterInitializerList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInitializerList" ):
                listener.exitInitializerList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInitializerList" ):
                return visitor.visitInitializerList(self)
            else:
                return visitor.visitChildren(self)




    def initializerList(self):

        localctx = CPP14Parser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1654
            self.initializerClause()
            self.state = 1656
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1655
                self.match(CPP14Parser.Ellipsis)


            self.state = 1665
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,225,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1658
                    self.match(CPP14Parser.Comma)
                    self.state = 1659
                    self.initializerClause()
                    self.state = 1661
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==134:
                        self.state = 1660
                        self.match(CPP14Parser.Ellipsis)

             
                self.state = 1667
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,225,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BracedInitListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def initializerList(self):
            return self.getTypedRuleContext(CPP14Parser.InitializerListContext,0)


        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_bracedInitList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBracedInitList" ):
                listener.enterBracedInitList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBracedInitList" ):
                listener.exitBracedInitList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBracedInitList" ):
                return visitor.visitBracedInitList(self)
            else:
                return visitor.visitChildren(self)




    def bracedInitList(self):

        localctx = CPP14Parser.BracedInitListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_bracedInitList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1668
            self.match(CPP14Parser.LeftBrace)
            self.state = 1673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295576359561) != 0 or _la==130 or _la==136:
                self.state = 1669
                self.initializerList()
                self.state = 1671
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==125:
                    self.state = 1670
                    self.match(CPP14Parser.Comma)




            self.state = 1675
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_className

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassName" ):
                listener.enterClassName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassName" ):
                listener.exitClassName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassName" ):
                return visitor.visitClassName(self)
            else:
                return visitor.visitChildren(self)




    def className(self):

        localctx = CPP14Parser.ClassNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_className)
        try:
            self.state = 1679
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,228,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1677
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1678
                self.simpleTemplateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classHead(self):
            return self.getTypedRuleContext(CPP14Parser.ClassHeadContext,0)


        def LeftBrace(self):
            return self.getToken(CPP14Parser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CPP14Parser.RightBrace, 0)

        def memberSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.MemberSpecificationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_classSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassSpecifier" ):
                listener.enterClassSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassSpecifier" ):
                listener.exitClassSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassSpecifier" ):
                return visitor.visitClassSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def classSpecifier(self):

        localctx = CPP14Parser.ClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_classSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1681
            self.classHead()
            self.state = 1682
            self.match(CPP14Parser.LeftBrace)
            self.state = 1684
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 3087754627188342553) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 752118729999395837) != 0:
                self.state = 1683
                self.memberSpecification()


            self.state = 1686
            self.match(CPP14Parser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassHeadContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classKey(self):
            return self.getTypedRuleContext(CPP14Parser.ClassKeyContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def classHeadName(self):
            return self.getTypedRuleContext(CPP14Parser.ClassHeadNameContext,0)


        def baseClause(self):
            return self.getTypedRuleContext(CPP14Parser.BaseClauseContext,0)


        def classVirtSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.ClassVirtSpecifierContext,0)


        def Union(self):
            return self.getToken(CPP14Parser.Union, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_classHead

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassHead" ):
                listener.enterClassHead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassHead" ):
                listener.exitClassHead(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassHead" ):
                return visitor.visitClassHead(self)
            else:
                return visitor.visitChildren(self)




    def classHead(self):

        localctx = CPP14Parser.ClassHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_classHead)
        self._la = 0 # Token type
        try:
            self.state = 1711
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [22, 68]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1688
                self.classKey()
                self.state = 1690
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11 or _la==90:
                    self.state = 1689
                    self.attributeSpecifierSeq()


                self.state = 1696
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==27 or _la==130 or _la==136:
                    self.state = 1692
                    self.classHeadName()
                    self.state = 1694
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==40:
                        self.state = 1693
                        self.classVirtSpecifier()




                self.state = 1699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==129:
                    self.state = 1698
                    self.baseClause()


                pass
            elif token in [80]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1701
                self.match(CPP14Parser.Union)
                self.state = 1703
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11 or _la==90:
                    self.state = 1702
                    self.attributeSpecifierSeq()


                self.state = 1709
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==27 or _la==130 or _la==136:
                    self.state = 1705
                    self.classHeadName()
                    self.state = 1707
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==40:
                        self.state = 1706
                        self.classVirtSpecifier()




                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassHeadNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_classHeadName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassHeadName" ):
                listener.enterClassHeadName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassHeadName" ):
                listener.exitClassHeadName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassHeadName" ):
                return visitor.visitClassHeadName(self)
            else:
                return visitor.visitChildren(self)




    def classHeadName(self):

        localctx = CPP14Parser.ClassHeadNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_classHeadName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1714
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                self.state = 1713
                self.nestedNameSpecifier(0)


            self.state = 1716
            self.className()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassVirtSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Final(self):
            return self.getToken(CPP14Parser.Final, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_classVirtSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassVirtSpecifier" ):
                listener.enterClassVirtSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassVirtSpecifier" ):
                listener.exitClassVirtSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassVirtSpecifier" ):
                return visitor.visitClassVirtSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def classVirtSpecifier(self):

        localctx = CPP14Parser.ClassVirtSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_classVirtSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1718
            self.match(CPP14Parser.Final)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassKeyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Class(self):
            return self.getToken(CPP14Parser.Class, 0)

        def Struct(self):
            return self.getToken(CPP14Parser.Struct, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_classKey

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassKey" ):
                listener.enterClassKey(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassKey" ):
                listener.exitClassKey(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassKey" ):
                return visitor.visitClassKey(self)
            else:
                return visitor.visitChildren(self)




    def classKey(self):

        localctx = CPP14Parser.ClassKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_classKey)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1720
            _la = self._input.LA(1)
            if not(_la==22 or _la==68):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def memberdeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MemberdeclarationContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MemberdeclarationContext,i)


        def accessSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.AccessSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.AccessSpecifierContext,i)


        def Colon(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Colon)
            else:
                return self.getToken(CPP14Parser.Colon, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_memberSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberSpecification" ):
                listener.enterMemberSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberSpecification" ):
                listener.exitMemberSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberSpecification" ):
                return visitor.visitMemberSpecification(self)
            else:
                return visitor.visitChildren(self)




    def memberSpecification(self):

        localctx = CPP14Parser.MemberSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_memberSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1726 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1726
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [11, 14, 15, 19, 20, 21, 22, 23, 24, 27, 32, 35, 36, 38, 41, 43, 46, 47, 48, 49, 54, 59, 62, 63, 65, 66, 68, 70, 72, 77, 79, 80, 81, 82, 83, 84, 85, 86, 88, 90, 96, 100, 102, 121, 129, 130, 131, 134, 136]:
                    self.state = 1722
                    self.memberdeclaration()
                    pass
                elif token in [56, 57, 58]:
                    self.state = 1723
                    self.accessSpecifier()
                    self.state = 1724
                    self.match(CPP14Parser.Colon)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1728 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la - 11)) & ~0x3f) == 0 and ((1 << (_la - 11)) & 3087754627188342553) != 0 or (((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 752118729999395837) != 0):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberdeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Semi(self):
            return self.getToken(CPP14Parser.Semi, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.DeclSpecifierSeqContext,0)


        def memberDeclaratorList(self):
            return self.getTypedRuleContext(CPP14Parser.MemberDeclaratorListContext,0)


        def functionDefinition(self):
            return self.getTypedRuleContext(CPP14Parser.FunctionDefinitionContext,0)


        def usingDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.UsingDeclarationContext,0)


        def staticAssertDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.StaticAssertDeclarationContext,0)


        def templateDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateDeclarationContext,0)


        def aliasDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.AliasDeclarationContext,0)


        def emptyDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.EmptyDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_memberdeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberdeclaration" ):
                listener.enterMemberdeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberdeclaration" ):
                listener.exitMemberdeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberdeclaration" ):
                return visitor.visitMemberdeclaration(self)
            else:
                return visitor.visitChildren(self)




    def memberdeclaration(self):

        localctx = CPP14Parser.MemberdeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_memberdeclaration)
        self._la = 0 # Token type
        try:
            self.state = 1746
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,244,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1731
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
                if la_ == 1:
                    self.state = 1730
                    self.attributeSpecifierSeq()


                self.state = 1734
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
                if la_ == 1:
                    self.state = 1733
                    self.declSpecifierSeq()


                self.state = 1737
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 18014398643701760) != 0 or (((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & 358449380610309) != 0:
                    self.state = 1736
                    self.memberDeclaratorList()


                self.state = 1739
                self.match(CPP14Parser.Semi)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1740
                self.functionDefinition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1741
                self.usingDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1742
                self.staticAssertDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1743
                self.templateDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1744
                self.aliasDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1745
                self.emptyDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def memberDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MemberDeclaratorContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MemberDeclaratorContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_memberDeclaratorList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberDeclaratorList" ):
                listener.enterMemberDeclaratorList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberDeclaratorList" ):
                listener.exitMemberDeclaratorList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberDeclaratorList" ):
                return visitor.visitMemberDeclaratorList(self)
            else:
                return visitor.visitChildren(self)




    def memberDeclaratorList(self):

        localctx = CPP14Parser.MemberDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_memberDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1748
            self.memberDeclarator()
            self.state = 1753
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1749
                self.match(CPP14Parser.Comma)
                self.state = 1750
                self.memberDeclarator()
                self.state = 1755
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemberDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def virtualSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.VirtualSpecifierSeqContext,0)


        def pureSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.PureSpecifierContext,0)


        def braceOrEqualInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.BraceOrEqualInitializerContext,0)


        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_memberDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemberDeclarator" ):
                listener.enterMemberDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemberDeclarator" ):
                listener.exitMemberDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemberDeclarator" ):
                return visitor.visitMemberDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def memberDeclarator(self):

        localctx = CPP14Parser.MemberDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_memberDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1776
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1756
                self.declarator()
                self.state = 1766
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,249,self._ctx)
                if la_ == 1:
                    self.state = 1758
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==40 or _la==55:
                        self.state = 1757
                        self.virtualSpecifierSeq()


                    self.state = 1761
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==104:
                        self.state = 1760
                        self.pureSpecifier()


                    pass

                elif la_ == 2:
                    self.state = 1764
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==92 or _la==104:
                        self.state = 1763
                        self.braceOrEqualInitializer()


                    pass


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1769
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==136:
                    self.state = 1768
                    self.match(CPP14Parser.Identifier)


                self.state = 1772
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11 or _la==90:
                    self.state = 1771
                    self.attributeSpecifierSeq()


                self.state = 1774
                self.match(CPP14Parser.Colon)
                self.state = 1775
                self.constantExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VirtualSpecifierSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def virtualSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.VirtualSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.VirtualSpecifierContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_virtualSpecifierSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtualSpecifierSeq" ):
                listener.enterVirtualSpecifierSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtualSpecifierSeq" ):
                listener.exitVirtualSpecifierSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVirtualSpecifierSeq" ):
                return visitor.visitVirtualSpecifierSeq(self)
            else:
                return visitor.visitChildren(self)




    def virtualSpecifierSeq(self):

        localctx = CPP14Parser.VirtualSpecifierSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_virtualSpecifierSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1779 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1778
                self.virtualSpecifier()
                self.state = 1781 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==40 or _la==55):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VirtualSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Override(self):
            return self.getToken(CPP14Parser.Override, 0)

        def Final(self):
            return self.getToken(CPP14Parser.Final, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_virtualSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVirtualSpecifier" ):
                listener.enterVirtualSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVirtualSpecifier" ):
                listener.exitVirtualSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVirtualSpecifier" ):
                return visitor.visitVirtualSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def virtualSpecifier(self):

        localctx = CPP14Parser.VirtualSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_virtualSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1783
            _la = self._input.LA(1)
            if not(_la==40 or _la==55):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PureSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def Zero(self):
            return self.getToken(CPP14Parser.Zero, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_pureSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPureSpecifier" ):
                listener.enterPureSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPureSpecifier" ):
                listener.exitPureSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPureSpecifier" ):
                return visitor.visitPureSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def pureSpecifier(self):

        localctx = CPP14Parser.PureSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_pureSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1785
            self.match(CPP14Parser.Assign)
            self.state = 1786
            self.match(CPP14Parser.Zero)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def baseSpecifierList(self):
            return self.getTypedRuleContext(CPP14Parser.BaseSpecifierListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_baseClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseClause" ):
                listener.enterBaseClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseClause" ):
                listener.exitBaseClause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseClause" ):
                return visitor.visitBaseClause(self)
            else:
                return visitor.visitChildren(self)




    def baseClause(self):

        localctx = CPP14Parser.BaseClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_baseClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1788
            self.match(CPP14Parser.Colon)
            self.state = 1789
            self.baseSpecifierList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseSpecifierListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def baseSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.BaseSpecifierContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.BaseSpecifierContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_baseSpecifierList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseSpecifierList" ):
                listener.enterBaseSpecifierList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseSpecifierList" ):
                listener.exitBaseSpecifierList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseSpecifierList" ):
                return visitor.visitBaseSpecifierList(self)
            else:
                return visitor.visitChildren(self)




    def baseSpecifierList(self):

        localctx = CPP14Parser.BaseSpecifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_baseSpecifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1791
            self.baseSpecifier()
            self.state = 1793
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1792
                self.match(CPP14Parser.Ellipsis)


            self.state = 1802
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1795
                self.match(CPP14Parser.Comma)
                self.state = 1796
                self.baseSpecifier()
                self.state = 1798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==134:
                    self.state = 1797
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1804
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def baseTypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.BaseTypeSpecifierContext,0)


        def Virtual(self):
            return self.getToken(CPP14Parser.Virtual, 0)

        def accessSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.AccessSpecifierContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_baseSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseSpecifier" ):
                listener.enterBaseSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseSpecifier" ):
                listener.exitBaseSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseSpecifier" ):
                return visitor.visitBaseSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def baseSpecifier(self):

        localctx = CPP14Parser.BaseSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_baseSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11 or _la==90:
                self.state = 1805
                self.attributeSpecifierSeq()


            self.state = 1820
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [27, 130, 136]:
                self.state = 1808
                self.baseTypeSpecifier()
                pass
            elif token in [83]:
                self.state = 1809
                self.match(CPP14Parser.Virtual)
                self.state = 1811
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & 504403158265495552) != 0:
                    self.state = 1810
                    self.accessSpecifier()


                self.state = 1813
                self.baseTypeSpecifier()
                pass
            elif token in [56, 57, 58]:
                self.state = 1814
                self.accessSpecifier()
                self.state = 1816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==83:
                    self.state = 1815
                    self.match(CPP14Parser.Virtual)


                self.state = 1818
                self.baseTypeSpecifier()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassOrDeclTypeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def className(self):
            return self.getTypedRuleContext(CPP14Parser.ClassNameContext,0)


        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def decltypeSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.DecltypeSpecifierContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_classOrDeclType

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassOrDeclType" ):
                listener.enterClassOrDeclType(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassOrDeclType" ):
                listener.exitClassOrDeclType(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassOrDeclType" ):
                return visitor.visitClassOrDeclType(self)
            else:
                return visitor.visitChildren(self)




    def classOrDeclType(self):

        localctx = CPP14Parser.ClassOrDeclTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_classOrDeclType)
        try:
            self.state = 1827
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1823
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
                if la_ == 1:
                    self.state = 1822
                    self.nestedNameSpecifier(0)


                self.state = 1825
                self.className()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1826
                self.decltypeSpecifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrDeclType(self):
            return self.getTypedRuleContext(CPP14Parser.ClassOrDeclTypeContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_baseTypeSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBaseTypeSpecifier" ):
                listener.enterBaseTypeSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBaseTypeSpecifier" ):
                listener.exitBaseTypeSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBaseTypeSpecifier" ):
                return visitor.visitBaseTypeSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def baseTypeSpecifier(self):

        localctx = CPP14Parser.BaseTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_baseTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1829
            self.classOrDeclType()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AccessSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Private(self):
            return self.getToken(CPP14Parser.Private, 0)

        def Protected(self):
            return self.getToken(CPP14Parser.Protected, 0)

        def Public(self):
            return self.getToken(CPP14Parser.Public, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_accessSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAccessSpecifier" ):
                listener.enterAccessSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAccessSpecifier" ):
                listener.exitAccessSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAccessSpecifier" ):
                return visitor.visitAccessSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def accessSpecifier(self):

        localctx = CPP14Parser.AccessSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_accessSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1831
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 504403158265495552) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConversionFunctionIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Operator(self):
            return self.getToken(CPP14Parser.Operator, 0)

        def conversionTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionTypeIdContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conversionFunctionId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversionFunctionId" ):
                listener.enterConversionFunctionId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversionFunctionId" ):
                listener.exitConversionFunctionId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConversionFunctionId" ):
                return visitor.visitConversionFunctionId(self)
            else:
                return visitor.visitChildren(self)




    def conversionFunctionId(self):

        localctx = CPP14Parser.ConversionFunctionIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_conversionFunctionId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1833
            self.match(CPP14Parser.Operator)
            self.state = 1834
            self.conversionTypeId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConversionTypeIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def conversionDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conversionTypeId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversionTypeId" ):
                listener.enterConversionTypeId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversionTypeId" ):
                listener.exitConversionTypeId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConversionTypeId" ):
                return visitor.visitConversionTypeId(self)
            else:
                return visitor.visitChildren(self)




    def conversionTypeId(self):

        localctx = CPP14Parser.ConversionTypeIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_conversionTypeId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1836
            self.typeSpecifierSeq()
            self.state = 1838
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
            if la_ == 1:
                self.state = 1837
                self.conversionDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConversionDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pointerOperator(self):
            return self.getTypedRuleContext(CPP14Parser.PointerOperatorContext,0)


        def conversionDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.ConversionDeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_conversionDeclarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversionDeclarator" ):
                listener.enterConversionDeclarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversionDeclarator" ):
                listener.exitConversionDeclarator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConversionDeclarator" ):
                return visitor.visitConversionDeclarator(self)
            else:
                return visitor.visitChildren(self)




    def conversionDeclarator(self):

        localctx = CPP14Parser.ConversionDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_conversionDeclarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1840
            self.pointerOperator()
            self.state = 1842
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,264,self._ctx)
            if la_ == 1:
                self.state = 1841
                self.conversionDeclarator()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstructorInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Colon(self):
            return self.getToken(CPP14Parser.Colon, 0)

        def memInitializerList(self):
            return self.getTypedRuleContext(CPP14Parser.MemInitializerListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_constructorInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructorInitializer" ):
                listener.enterConstructorInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructorInitializer" ):
                listener.exitConstructorInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstructorInitializer" ):
                return visitor.visitConstructorInitializer(self)
            else:
                return visitor.visitChildren(self)




    def constructorInitializer(self):

        localctx = CPP14Parser.ConstructorInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_constructorInitializer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1844
            self.match(CPP14Parser.Colon)
            self.state = 1845
            self.memInitializerList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemInitializerListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def memInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.MemInitializerContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.MemInitializerContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_memInitializerList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemInitializerList" ):
                listener.enterMemInitializerList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemInitializerList" ):
                listener.exitMemInitializerList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemInitializerList" ):
                return visitor.visitMemInitializerList(self)
            else:
                return visitor.visitChildren(self)




    def memInitializerList(self):

        localctx = CPP14Parser.MemInitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_memInitializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1847
            self.memInitializer()
            self.state = 1849
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1848
                self.match(CPP14Parser.Ellipsis)


            self.state = 1858
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1851
                self.match(CPP14Parser.Comma)
                self.state = 1852
                self.memInitializer()
                self.state = 1854
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==134:
                    self.state = 1853
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1860
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MemInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def meminitializerid(self):
            return self.getTypedRuleContext(CPP14Parser.MeminitializeridContext,0)


        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def bracedInitList(self):
            return self.getTypedRuleContext(CPP14Parser.BracedInitListContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(CPP14Parser.ExpressionListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_memInitializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMemInitializer" ):
                listener.enterMemInitializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMemInitializer" ):
                listener.exitMemInitializer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMemInitializer" ):
                return visitor.visitMemInitializer(self)
            else:
                return visitor.visitChildren(self)




    def memInitializer(self):

        localctx = CPP14Parser.MemInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_memInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1861
            self.meminitializerid()
            self.state = 1868
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [88]:
                self.state = 1862
                self.match(CPP14Parser.LeftParen)
                self.state = 1864
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295576359561) != 0 or _la==130 or _la==136:
                    self.state = 1863
                    self.expressionList()


                self.state = 1866
                self.match(CPP14Parser.RightParen)
                pass
            elif token in [92]:
                self.state = 1867
                self.bracedInitList()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MeminitializeridContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrDeclType(self):
            return self.getTypedRuleContext(CPP14Parser.ClassOrDeclTypeContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_meminitializerid

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMeminitializerid" ):
                listener.enterMeminitializerid(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMeminitializerid" ):
                listener.exitMeminitializerid(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMeminitializerid" ):
                return visitor.visitMeminitializerid(self)
            else:
                return visitor.visitChildren(self)




    def meminitializerid(self):

        localctx = CPP14Parser.MeminitializeridContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_meminitializerid)
        try:
            self.state = 1872
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1870
                self.classOrDeclType()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1871
                self.match(CPP14Parser.Identifier)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperatorFunctionIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Operator(self):
            return self.getToken(CPP14Parser.Operator, 0)

        def theOperator(self):
            return self.getTypedRuleContext(CPP14Parser.TheOperatorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_operatorFunctionId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOperatorFunctionId" ):
                listener.enterOperatorFunctionId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOperatorFunctionId" ):
                listener.exitOperatorFunctionId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOperatorFunctionId" ):
                return visitor.visitOperatorFunctionId(self)
            else:
                return visitor.visitChildren(self)




    def operatorFunctionId(self):

        localctx = CPP14Parser.OperatorFunctionIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_operatorFunctionId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1874
            self.match(CPP14Parser.Operator)
            self.state = 1875
            self.theOperator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralOperatorIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Operator(self):
            return self.getToken(CPP14Parser.Operator, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def UserDefinedStringLiteral(self):
            return self.getToken(CPP14Parser.UserDefinedStringLiteral, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_literalOperatorId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteralOperatorId" ):
                listener.enterLiteralOperatorId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteralOperatorId" ):
                listener.exitLiteralOperatorId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteralOperatorId" ):
                return visitor.visitLiteralOperatorId(self)
            else:
                return visitor.visitChildren(self)




    def literalOperatorId(self):

        localctx = CPP14Parser.LiteralOperatorIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_literalOperatorId)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1877
            self.match(CPP14Parser.Operator)
            self.state = 1881
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.state = 1878
                self.match(CPP14Parser.StringLiteral)
                self.state = 1879
                self.match(CPP14Parser.Identifier)
                pass
            elif token in [144]:
                self.state = 1880
                self.match(CPP14Parser.UserDefinedStringLiteral)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def templateparameterList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateparameterListContext,0)


        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateDeclaration" ):
                listener.enterTemplateDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateDeclaration" ):
                listener.exitTemplateDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateDeclaration" ):
                return visitor.visitTemplateDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def templateDeclaration(self):

        localctx = CPP14Parser.TemplateDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_templateDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1883
            self.match(CPP14Parser.Template)
            self.state = 1884
            self.match(CPP14Parser.Less)
            self.state = 1885
            self.templateparameterList()
            self.state = 1886
            self.match(CPP14Parser.Greater)
            self.state = 1887
            self.declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateparameterListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def templateParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TemplateParameterContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TemplateParameterContext,i)


        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_templateparameterList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateparameterList" ):
                listener.enterTemplateparameterList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateparameterList" ):
                listener.exitTemplateparameterList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateparameterList" ):
                return visitor.visitTemplateparameterList(self)
            else:
                return visitor.visitChildren(self)




    def templateparameterList(self):

        localctx = CPP14Parser.TemplateparameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_templateparameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1889
            self.templateParameter()
            self.state = 1894
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1890
                self.match(CPP14Parser.Comma)
                self.state = 1891
                self.templateParameter()
                self.state = 1896
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeParameter(self):
            return self.getTypedRuleContext(CPP14Parser.TypeParameterContext,0)


        def parameterDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.ParameterDeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateParameter" ):
                listener.enterTemplateParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateParameter" ):
                listener.exitTemplateParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateParameter" ):
                return visitor.visitTemplateParameter(self)
            else:
                return visitor.visitChildren(self)




    def templateParameter(self):

        localctx = CPP14Parser.TemplateParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_templateParameter)
        try:
            self.state = 1899
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1897
                self.typeParameter()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1898
                self.parameterDeclaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Class(self):
            return self.getToken(CPP14Parser.Class, 0)

        def Typename_(self):
            return self.getToken(CPP14Parser.Typename_, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def templateparameterList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateparameterListContext,0)


        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeParameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeParameter" ):
                listener.enterTypeParameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeParameter" ):
                listener.exitTypeParameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeParameter" ):
                return visitor.visitTypeParameter(self)
            else:
                return visitor.visitChildren(self)




    def typeParameter(self):

        localctx = CPP14Parser.TypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_typeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1910
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [22, 70]:
                self.state = 1906
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==70:
                    self.state = 1901
                    self.match(CPP14Parser.Template)
                    self.state = 1902
                    self.match(CPP14Parser.Less)
                    self.state = 1903
                    self.templateparameterList()
                    self.state = 1904
                    self.match(CPP14Parser.Greater)


                self.state = 1908
                self.match(CPP14Parser.Class)
                pass
            elif token in [79]:
                self.state = 1909
                self.match(CPP14Parser.Typename_)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1923
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,279,self._ctx)
            if la_ == 1:
                self.state = 1913
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==134:
                    self.state = 1912
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1916
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==136:
                    self.state = 1915
                    self.match(CPP14Parser.Identifier)


                pass

            elif la_ == 2:
                self.state = 1919
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==136:
                    self.state = 1918
                    self.match(CPP14Parser.Identifier)


                self.state = 1921
                self.match(CPP14Parser.Assign)
                self.state = 1922
                self.theTypeId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleTemplateIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def templateName(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateNameContext,0)


        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def templateArgumentList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateArgumentListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_simpleTemplateId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimpleTemplateId" ):
                listener.enterSimpleTemplateId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimpleTemplateId" ):
                listener.exitSimpleTemplateId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimpleTemplateId" ):
                return visitor.visitSimpleTemplateId(self)
            else:
                return visitor.visitChildren(self)




    def simpleTemplateId(self):

        localctx = CPP14Parser.SimpleTemplateIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_simpleTemplateId)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1925
            self.templateName()
            self.state = 1926
            self.match(CPP14Parser.Less)
            self.state = 1928
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570255879220994) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295310086297) != 0 or _la==130 or _la==136:
                self.state = 1927
                self.templateArgumentList()


            self.state = 1930
            self.match(CPP14Parser.Greater)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateIdContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def operatorFunctionId(self):
            return self.getTypedRuleContext(CPP14Parser.OperatorFunctionIdContext,0)


        def literalOperatorId(self):
            return self.getTypedRuleContext(CPP14Parser.LiteralOperatorIdContext,0)


        def templateArgumentList(self):
            return self.getTypedRuleContext(CPP14Parser.TemplateArgumentListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateId

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateId" ):
                listener.enterTemplateId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateId" ):
                listener.exitTemplateId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateId" ):
                return visitor.visitTemplateId(self)
            else:
                return visitor.visitChildren(self)




    def templateId(self):

        localctx = CPP14Parser.TemplateIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_templateId)
        self._la = 0 # Token type
        try:
            self.state = 1943
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1932
                self.simpleTemplateId()
                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1935
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,281,self._ctx)
                if la_ == 1:
                    self.state = 1933
                    self.operatorFunctionId()
                    pass

                elif la_ == 2:
                    self.state = 1934
                    self.literalOperatorId()
                    pass


                self.state = 1937
                self.match(CPP14Parser.Less)
                self.state = 1939
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570255879220994) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295310086297) != 0 or _la==130 or _la==136:
                    self.state = 1938
                    self.templateArgumentList()


                self.state = 1941
                self.match(CPP14Parser.Greater)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_templateName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateName" ):
                listener.enterTemplateName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateName" ):
                listener.exitTemplateName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateName" ):
                return visitor.visitTemplateName(self)
            else:
                return visitor.visitChildren(self)




    def templateName(self):

        localctx = CPP14Parser.TemplateNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_templateName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1945
            self.match(CPP14Parser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateArgumentListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def templateArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TemplateArgumentContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TemplateArgumentContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_templateArgumentList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateArgumentList" ):
                listener.enterTemplateArgumentList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateArgumentList" ):
                listener.exitTemplateArgumentList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateArgumentList" ):
                return visitor.visitTemplateArgumentList(self)
            else:
                return visitor.visitChildren(self)




    def templateArgumentList(self):

        localctx = CPP14Parser.TemplateArgumentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_templateArgumentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1947
            self.templateArgument()
            self.state = 1949
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 1948
                self.match(CPP14Parser.Ellipsis)


            self.state = 1958
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 1951
                self.match(CPP14Parser.Comma)
                self.state = 1952
                self.templateArgument()
                self.state = 1954
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==134:
                    self.state = 1953
                    self.match(CPP14Parser.Ellipsis)


                self.state = 1960
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TemplateArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def theTypeId(self):
            return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,0)


        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def idExpression(self):
            return self.getTypedRuleContext(CPP14Parser.IdExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_templateArgument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTemplateArgument" ):
                listener.enterTemplateArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTemplateArgument" ):
                listener.exitTemplateArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTemplateArgument" ):
                return visitor.visitTemplateArgument(self)
            else:
                return visitor.visitChildren(self)




    def templateArgument(self):

        localctx = CPP14Parser.TemplateArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_templateArgument)
        try:
            self.state = 1964
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,287,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1961
                self.theTypeId()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1962
                self.constantExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1963
                self.idExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeNameSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Typename_(self):
            return self.getToken(CPP14Parser.Typename_, 0)

        def nestedNameSpecifier(self):
            return self.getTypedRuleContext(CPP14Parser.NestedNameSpecifierContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def simpleTemplateId(self):
            return self.getTypedRuleContext(CPP14Parser.SimpleTemplateIdContext,0)


        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeNameSpecifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeNameSpecifier" ):
                listener.enterTypeNameSpecifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeNameSpecifier" ):
                listener.exitTypeNameSpecifier(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeNameSpecifier" ):
                return visitor.visitTypeNameSpecifier(self)
            else:
                return visitor.visitChildren(self)




    def typeNameSpecifier(self):

        localctx = CPP14Parser.TypeNameSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_typeNameSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1966
            self.match(CPP14Parser.Typename_)
            self.state = 1967
            self.nestedNameSpecifier(0)
            self.state = 1973
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
            if la_ == 1:
                self.state = 1968
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.state = 1970
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==70:
                    self.state = 1969
                    self.match(CPP14Parser.Template)


                self.state = 1972
                self.simpleTemplateId()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExplicitInstantiationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def Extern(self):
            return self.getToken(CPP14Parser.Extern, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_explicitInstantiation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitInstantiation" ):
                listener.enterExplicitInstantiation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitInstantiation" ):
                listener.exitExplicitInstantiation(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplicitInstantiation" ):
                return visitor.visitExplicitInstantiation(self)
            else:
                return visitor.visitChildren(self)




    def explicitInstantiation(self):

        localctx = CPP14Parser.ExplicitInstantiationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_explicitInstantiation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1976
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==38:
                self.state = 1975
                self.match(CPP14Parser.Extern)


            self.state = 1978
            self.match(CPP14Parser.Template)
            self.state = 1979
            self.declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExplicitSpecializationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Template(self):
            return self.getToken(CPP14Parser.Template, 0)

        def Less(self):
            return self.getToken(CPP14Parser.Less, 0)

        def Greater(self):
            return self.getToken(CPP14Parser.Greater, 0)

        def declaration(self):
            return self.getTypedRuleContext(CPP14Parser.DeclarationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_explicitSpecialization

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitSpecialization" ):
                listener.enterExplicitSpecialization(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitSpecialization" ):
                listener.exitExplicitSpecialization(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExplicitSpecialization" ):
                return visitor.visitExplicitSpecialization(self)
            else:
                return visitor.visitChildren(self)




    def explicitSpecialization(self):

        localctx = CPP14Parser.ExplicitSpecializationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_explicitSpecialization)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1981
            self.match(CPP14Parser.Template)
            self.state = 1982
            self.match(CPP14Parser.Less)
            self.state = 1983
            self.match(CPP14Parser.Greater)
            self.state = 1984
            self.declaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TryBlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Try(self):
            return self.getToken(CPP14Parser.Try, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def handlerSeq(self):
            return self.getTypedRuleContext(CPP14Parser.HandlerSeqContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_tryBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTryBlock" ):
                listener.enterTryBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTryBlock" ):
                listener.exitTryBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTryBlock" ):
                return visitor.visitTryBlock(self)
            else:
                return visitor.visitChildren(self)




    def tryBlock(self):

        localctx = CPP14Parser.TryBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_tryBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1986
            self.match(CPP14Parser.Try)
            self.state = 1987
            self.compoundStatement()
            self.state = 1988
            self.handlerSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTryBlockContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Try(self):
            return self.getToken(CPP14Parser.Try, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def handlerSeq(self):
            return self.getTypedRuleContext(CPP14Parser.HandlerSeqContext,0)


        def constructorInitializer(self):
            return self.getTypedRuleContext(CPP14Parser.ConstructorInitializerContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_functionTryBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunctionTryBlock" ):
                listener.enterFunctionTryBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunctionTryBlock" ):
                listener.exitFunctionTryBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionTryBlock" ):
                return visitor.visitFunctionTryBlock(self)
            else:
                return visitor.visitChildren(self)




    def functionTryBlock(self):

        localctx = CPP14Parser.FunctionTryBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_functionTryBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1990
            self.match(CPP14Parser.Try)
            self.state = 1992
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==129:
                self.state = 1991
                self.constructorInitializer()


            self.state = 1994
            self.compoundStatement()
            self.state = 1995
            self.handlerSeq()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HandlerSeqContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def handler(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.HandlerContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.HandlerContext,i)


        def getRuleIndex(self):
            return CPP14Parser.RULE_handlerSeq

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHandlerSeq" ):
                listener.enterHandlerSeq(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHandlerSeq" ):
                listener.exitHandlerSeq(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHandlerSeq" ):
                return visitor.visitHandlerSeq(self)
            else:
                return visitor.visitChildren(self)




    def handlerSeq(self):

        localctx = CPP14Parser.HandlerSeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_handlerSeq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1998 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1997
                self.handler()
                self.state = 2000 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==18):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class HandlerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Catch(self):
            return self.getToken(CPP14Parser.Catch, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def exceptionDeclaration(self):
            return self.getTypedRuleContext(CPP14Parser.ExceptionDeclarationContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CPP14Parser.CompoundStatementContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_handler

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHandler" ):
                listener.enterHandler(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHandler" ):
                listener.exitHandler(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitHandler" ):
                return visitor.visitHandler(self)
            else:
                return visitor.visitChildren(self)




    def handler(self):

        localctx = CPP14Parser.HandlerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_handler)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2002
            self.match(CPP14Parser.Catch)
            self.state = 2003
            self.match(CPP14Parser.LeftParen)
            self.state = 2004
            self.exceptionDeclaration()
            self.state = 2005
            self.match(CPP14Parser.RightParen)
            self.state = 2006
            self.compoundStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExceptionDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.TypeSpecifierSeqContext,0)


        def attributeSpecifierSeq(self):
            return self.getTypedRuleContext(CPP14Parser.AttributeSpecifierSeqContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CPP14Parser.AbstractDeclaratorContext,0)


        def Ellipsis(self):
            return self.getToken(CPP14Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_exceptionDeclaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExceptionDeclaration" ):
                listener.enterExceptionDeclaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExceptionDeclaration" ):
                listener.exitExceptionDeclaration(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExceptionDeclaration" ):
                return visitor.visitExceptionDeclaration(self)
            else:
                return visitor.visitChildren(self)




    def exceptionDeclaration(self):

        localctx = CPP14Parser.ExceptionDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_exceptionDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 2017
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [11, 14, 15, 19, 20, 21, 22, 23, 27, 32, 35, 41, 47, 48, 62, 63, 68, 79, 80, 81, 84, 85, 86, 90, 130, 136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2009
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==11 or _la==90:
                    self.state = 2008
                    self.attributeSpecifierSeq()


                self.state = 2011
                self.typeSpecifierSeq()
                self.state = 2014
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,294,self._ctx)
                if la_ == 1:
                    self.state = 2012
                    self.declarator()

                elif la_ == 2:
                    self.state = 2013
                    self.abstractDeclarator()


                pass
            elif token in [134]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2016
                self.match(CPP14Parser.Ellipsis)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ThrowExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Throw(self):
            return self.getToken(CPP14Parser.Throw, 0)

        def assignmentExpression(self):
            return self.getTypedRuleContext(CPP14Parser.AssignmentExpressionContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_throwExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterThrowExpression" ):
                listener.enterThrowExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitThrowExpression" ):
                listener.exitThrowExpression(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitThrowExpression" ):
                return visitor.visitThrowExpression(self)
            else:
                return visitor.visitChildren(self)




    def throwExpression(self):

        localctx = CPP14Parser.ThrowExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_throwExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2019
            self.match(CPP14Parser.Throw)
            self.state = 2021
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((_la) & ~0x3f) == 0 and ((1 << _la) & -3433570290251542274) != 0 or (((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1729383295307924105) != 0 or _la==130 or _la==136:
                self.state = 2020
                self.assignmentExpression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExceptionSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dynamicExceptionSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.DynamicExceptionSpecificationContext,0)


        def noeExceptSpecification(self):
            return self.getTypedRuleContext(CPP14Parser.NoeExceptSpecificationContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_exceptionSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExceptionSpecification" ):
                listener.enterExceptionSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExceptionSpecification" ):
                listener.exitExceptionSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExceptionSpecification" ):
                return visitor.visitExceptionSpecification(self)
            else:
                return visitor.visitChildren(self)




    def exceptionSpecification(self):

        localctx = CPP14Parser.ExceptionSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_exceptionSpecification)
        try:
            self.state = 2025
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [73]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2023
                self.dynamicExceptionSpecification()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2024
                self.noeExceptSpecification()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DynamicExceptionSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Throw(self):
            return self.getToken(CPP14Parser.Throw, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def typeIdList(self):
            return self.getTypedRuleContext(CPP14Parser.TypeIdListContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_dynamicExceptionSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDynamicExceptionSpecification" ):
                listener.enterDynamicExceptionSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDynamicExceptionSpecification" ):
                listener.exitDynamicExceptionSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDynamicExceptionSpecification" ):
                return visitor.visitDynamicExceptionSpecification(self)
            else:
                return visitor.visitChildren(self)




    def dynamicExceptionSpecification(self):

        localctx = CPP14Parser.DynamicExceptionSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_dynamicExceptionSpecification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2027
            self.match(CPP14Parser.Throw)
            self.state = 2028
            self.match(CPP14Parser.LeftParen)
            self.state = 2030
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la - 14)) & ~0x3f) == 0 and ((1 << (_la - 14)) & 18858849346003939) != 0 or (((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & 146366987889541351) != 0:
                self.state = 2029
                self.typeIdList()


            self.state = 2032
            self.match(CPP14Parser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeIdListContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def theTypeId(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CPP14Parser.TheTypeIdContext)
            else:
                return self.getTypedRuleContext(CPP14Parser.TheTypeIdContext,i)


        def Ellipsis(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Ellipsis)
            else:
                return self.getToken(CPP14Parser.Ellipsis, i)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Comma)
            else:
                return self.getToken(CPP14Parser.Comma, i)

        def getRuleIndex(self):
            return CPP14Parser.RULE_typeIdList

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypeIdList" ):
                listener.enterTypeIdList(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypeIdList" ):
                listener.exitTypeIdList(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypeIdList" ):
                return visitor.visitTypeIdList(self)
            else:
                return visitor.visitChildren(self)




    def typeIdList(self):

        localctx = CPP14Parser.TypeIdListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_typeIdList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2034
            self.theTypeId()
            self.state = 2036
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==134:
                self.state = 2035
                self.match(CPP14Parser.Ellipsis)


            self.state = 2045
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==125:
                self.state = 2038
                self.match(CPP14Parser.Comma)
                self.state = 2039
                self.theTypeId()
                self.state = 2041
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==134:
                    self.state = 2040
                    self.match(CPP14Parser.Ellipsis)


                self.state = 2047
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NoeExceptSpecificationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Noexcept(self):
            return self.getToken(CPP14Parser.Noexcept, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CPP14Parser.ConstantExpressionContext,0)


        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_noeExceptSpecification

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNoeExceptSpecification" ):
                listener.enterNoeExceptSpecification(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNoeExceptSpecification" ):
                listener.exitNoeExceptSpecification(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoeExceptSpecification" ):
                return visitor.visitNoeExceptSpecification(self)
            else:
                return visitor.visitChildren(self)




    def noeExceptSpecification(self):

        localctx = CPP14Parser.NoeExceptSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_noeExceptSpecification)
        try:
            self.state = 2054
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,302,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2048
                self.match(CPP14Parser.Noexcept)
                self.state = 2049
                self.match(CPP14Parser.LeftParen)
                self.state = 2050
                self.constantExpression()
                self.state = 2051
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2053
                self.match(CPP14Parser.Noexcept)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefineContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Pound(self):
            return self.getToken(CPP14Parser.Pound, 0)

        def Define(self):
            return self.getToken(CPP14Parser.Define, 0)

        def primaryExpression(self):
            return self.getTypedRuleContext(CPP14Parser.PrimaryExpressionContext,0)


        def Identifier(self):
            return self.getToken(CPP14Parser.Identifier, 0)

        def declarator(self):
            return self.getTypedRuleContext(CPP14Parser.DeclaratorContext,0)


        def getRuleIndex(self):
            return CPP14Parser.RULE_define

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefine" ):
                listener.enterDefine(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefine" ):
                listener.exitDefine(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefine" ):
                return visitor.visitDefine(self)
            else:
                return visitor.visitChildren(self)




    def define(self):

        localctx = CPP14Parser.DefineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_define)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2056
            self.match(CPP14Parser.Pound)
            self.state = 2057
            self.match(CPP14Parser.Define)
            self.state = 2060
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,303,self._ctx)
            if la_ == 1:
                self.state = 2058
                self.match(CPP14Parser.Identifier)
                pass

            elif la_ == 2:
                self.state = 2059
                self.declarator()
                pass


            self.state = 2062
            self.primaryExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TheOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def New(self):
            return self.getToken(CPP14Parser.New, 0)

        def LeftBracket(self):
            return self.getToken(CPP14Parser.LeftBracket, 0)

        def RightBracket(self):
            return self.getToken(CPP14Parser.RightBracket, 0)

        def Delete(self):
            return self.getToken(CPP14Parser.Delete, 0)

        def Plus(self):
            return self.getToken(CPP14Parser.Plus, 0)

        def Minus(self):
            return self.getToken(CPP14Parser.Minus, 0)

        def Star(self):
            return self.getToken(CPP14Parser.Star, 0)

        def Div(self):
            return self.getToken(CPP14Parser.Div, 0)

        def Mod(self):
            return self.getToken(CPP14Parser.Mod, 0)

        def Caret(self):
            return self.getToken(CPP14Parser.Caret, 0)

        def And(self):
            return self.getToken(CPP14Parser.And, 0)

        def Or(self):
            return self.getToken(CPP14Parser.Or, 0)

        def Tilde(self):
            return self.getToken(CPP14Parser.Tilde, 0)

        def Not(self):
            return self.getToken(CPP14Parser.Not, 0)

        def Assign(self):
            return self.getToken(CPP14Parser.Assign, 0)

        def Greater(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Greater)
            else:
                return self.getToken(CPP14Parser.Greater, i)

        def Less(self, i:int=None):
            if i is None:
                return self.getTokens(CPP14Parser.Less)
            else:
                return self.getToken(CPP14Parser.Less, i)

        def GreaterEqual(self):
            return self.getToken(CPP14Parser.GreaterEqual, 0)

        def PlusAssign(self):
            return self.getToken(CPP14Parser.PlusAssign, 0)

        def MinusAssign(self):
            return self.getToken(CPP14Parser.MinusAssign, 0)

        def StarAssign(self):
            return self.getToken(CPP14Parser.StarAssign, 0)

        def ModAssign(self):
            return self.getToken(CPP14Parser.ModAssign, 0)

        def XorAssign(self):
            return self.getToken(CPP14Parser.XorAssign, 0)

        def AndAssign(self):
            return self.getToken(CPP14Parser.AndAssign, 0)

        def OrAssign(self):
            return self.getToken(CPP14Parser.OrAssign, 0)

        def RightShiftAssign(self):
            return self.getToken(CPP14Parser.RightShiftAssign, 0)

        def LeftShiftAssign(self):
            return self.getToken(CPP14Parser.LeftShiftAssign, 0)

        def Equal(self):
            return self.getToken(CPP14Parser.Equal, 0)

        def NotEqual(self):
            return self.getToken(CPP14Parser.NotEqual, 0)

        def LessEqual(self):
            return self.getToken(CPP14Parser.LessEqual, 0)

        def AndAnd(self):
            return self.getToken(CPP14Parser.AndAnd, 0)

        def OrOr(self):
            return self.getToken(CPP14Parser.OrOr, 0)

        def PlusPlus(self):
            return self.getToken(CPP14Parser.PlusPlus, 0)

        def MinusMinus(self):
            return self.getToken(CPP14Parser.MinusMinus, 0)

        def Comma(self):
            return self.getToken(CPP14Parser.Comma, 0)

        def ArrowStar(self):
            return self.getToken(CPP14Parser.ArrowStar, 0)

        def Arrow(self):
            return self.getToken(CPP14Parser.Arrow, 0)

        def LeftParen(self):
            return self.getToken(CPP14Parser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CPP14Parser.RightParen, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_theOperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTheOperator" ):
                listener.enterTheOperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTheOperator" ):
                listener.exitTheOperator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTheOperator" ):
                return visitor.visitTheOperator(self)
            else:
                return visitor.visitChildren(self)




    def theOperator(self):

        localctx = CPP14Parser.TheOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_theOperator)
        try:
            self.state = 2115
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,306,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2064
                self.match(CPP14Parser.New)
                self.state = 2067
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,304,self._ctx)
                if la_ == 1:
                    self.state = 2065
                    self.match(CPP14Parser.LeftBracket)
                    self.state = 2066
                    self.match(CPP14Parser.RightBracket)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2069
                self.match(CPP14Parser.Delete)
                self.state = 2072
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,305,self._ctx)
                if la_ == 1:
                    self.state = 2070
                    self.match(CPP14Parser.LeftBracket)
                    self.state = 2071
                    self.match(CPP14Parser.RightBracket)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2074
                self.match(CPP14Parser.Plus)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2075
                self.match(CPP14Parser.Minus)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2076
                self.match(CPP14Parser.Star)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2077
                self.match(CPP14Parser.Div)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2078
                self.match(CPP14Parser.Mod)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2079
                self.match(CPP14Parser.Caret)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 2080
                self.match(CPP14Parser.And)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 2081
                self.match(CPP14Parser.Or)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 2082
                self.match(CPP14Parser.Tilde)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 2083
                self.match(CPP14Parser.Not)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 2084
                self.match(CPP14Parser.Assign)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 2085
                self.match(CPP14Parser.Greater)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 2086
                self.match(CPP14Parser.Less)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 2087
                self.match(CPP14Parser.GreaterEqual)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 2088
                self.match(CPP14Parser.PlusAssign)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 2089
                self.match(CPP14Parser.MinusAssign)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 2090
                self.match(CPP14Parser.StarAssign)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 2091
                self.match(CPP14Parser.ModAssign)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 2092
                self.match(CPP14Parser.XorAssign)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 2093
                self.match(CPP14Parser.AndAssign)
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 2094
                self.match(CPP14Parser.OrAssign)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 2095
                self.match(CPP14Parser.Less)
                self.state = 2096
                self.match(CPP14Parser.Less)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 2097
                self.match(CPP14Parser.Greater)
                self.state = 2098
                self.match(CPP14Parser.Greater)
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 2099
                self.match(CPP14Parser.RightShiftAssign)
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 2100
                self.match(CPP14Parser.LeftShiftAssign)
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 2101
                self.match(CPP14Parser.Equal)
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 2102
                self.match(CPP14Parser.NotEqual)
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 2103
                self.match(CPP14Parser.LessEqual)
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 2104
                self.match(CPP14Parser.AndAnd)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 2105
                self.match(CPP14Parser.OrOr)
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 2106
                self.match(CPP14Parser.PlusPlus)
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 2107
                self.match(CPP14Parser.MinusMinus)
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 2108
                self.match(CPP14Parser.Comma)
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 2109
                self.match(CPP14Parser.ArrowStar)
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 2110
                self.match(CPP14Parser.Arrow)
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 2111
                self.match(CPP14Parser.LeftParen)
                self.state = 2112
                self.match(CPP14Parser.RightParen)
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 2113
                self.match(CPP14Parser.LeftBracket)
                self.state = 2114
                self.match(CPP14Parser.RightBracket)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IntegerLiteral(self):
            return self.getToken(CPP14Parser.IntegerLiteral, 0)

        def CharacterLiteral(self):
            return self.getToken(CPP14Parser.CharacterLiteral, 0)

        def FloatingLiteral(self):
            return self.getToken(CPP14Parser.FloatingLiteral, 0)

        def StringLiteral(self):
            return self.getToken(CPP14Parser.StringLiteral, 0)

        def BooleanLiteral(self):
            return self.getToken(CPP14Parser.BooleanLiteral, 0)

        def PointerLiteral(self):
            return self.getToken(CPP14Parser.PointerLiteral, 0)

        def UserDefinedLiteral(self):
            return self.getToken(CPP14Parser.UserDefinedLiteral, 0)

        def getRuleIndex(self):
            return CPP14Parser.RULE_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteral" ):
                listener.enterLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteral" ):
                listener.exitLiteral(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral" ):
                return visitor.visitLiteral(self)
            else:
                return visitor.visitChildren(self)




    def literal(self):

        localctx = CPP14Parser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2117
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 254) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[5] = self.nestedNameSpecifier_sempred
        self._predicates[15] = self.postfixExpression_sempred
        self._predicates[25] = self.noPointerNewDeclarator_sempred
        self._predicates[115] = self.noPointerDeclarator_sempred
        self._predicates[126] = self.noPointerAbstractDeclarator_sempred
        self._predicates[128] = self.noPointerAbstractPackDeclarator_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def nestedNameSpecifier_sempred(self, localctx:NestedNameSpecifierContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def postfixExpression_sempred(self, localctx:PostfixExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 3)
         

    def noPointerNewDeclarator_sempred(self, localctx:NoPointerNewDeclaratorContext, predIndex:int):
            if predIndex == 5:
                return self.precpred(self._ctx, 1)
         

    def noPointerDeclarator_sempred(self, localctx:NoPointerDeclaratorContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

    def noPointerAbstractDeclarator_sempred(self, localctx:NoPointerAbstractDeclaratorContext, predIndex:int):
            if predIndex == 7:
                return self.precpred(self._ctx, 4)
         

    def noPointerAbstractPackDeclarator_sempred(self, localctx:NoPointerAbstractPackDeclaratorContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 2)
         




