# Generated from /home/g/PycharmProjects/mccode-antlr/src/grammar/C.g4 by ANTLR 4.13.2
# 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,120,1134,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,1,0,1,0,1,0,1,0,
        1,0,1,1,1,1,1,1,4,1,189,8,1,11,1,12,1,190,1,1,1,1,1,1,1,1,1,1,1,
        1,3,1,199,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,3,1,219,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
        3,1,3,1,3,5,3,231,8,3,10,3,12,3,234,9,3,1,4,1,4,3,4,238,8,4,1,4,
        1,4,1,4,1,5,1,5,3,5,245,8,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,253,8,5,
        1,5,1,5,3,5,257,8,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,265,8,5,1,5,1,5,
        1,5,1,5,1,5,5,5,272,8,5,10,5,12,5,275,9,5,1,6,1,6,1,6,5,6,280,8,
        6,10,6,12,6,283,9,6,1,7,5,7,286,8,7,10,7,12,7,289,9,7,1,7,1,7,1,
        7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,3,7,302,8,7,1,8,1,8,1,9,3,9,307,
        8,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3,9,316,8,9,1,10,1,10,1,10,5,10,
        321,8,10,10,10,12,10,324,9,10,1,11,1,11,1,11,5,11,329,8,11,10,11,
        12,11,332,9,11,1,12,1,12,1,12,5,12,337,8,12,10,12,12,12,340,9,12,
        1,13,1,13,1,13,5,13,345,8,13,10,13,12,13,348,9,13,1,14,1,14,1,14,
        5,14,353,8,14,10,14,12,14,356,9,14,1,15,1,15,1,15,5,15,361,8,15,
        10,15,12,15,364,9,15,1,16,1,16,1,16,5,16,369,8,16,10,16,12,16,372,
        9,16,1,17,1,17,1,17,5,17,377,8,17,10,17,12,17,380,9,17,1,18,1,18,
        1,18,5,18,385,8,18,10,18,12,18,388,9,18,1,19,1,19,1,19,5,19,393,
        8,19,10,19,12,19,396,9,19,1,20,1,20,1,20,1,20,1,20,1,20,3,20,404,
        8,20,1,21,1,21,1,21,1,21,1,21,1,21,3,21,412,8,21,1,22,1,22,1,23,
        1,23,1,23,5,23,419,8,23,10,23,12,23,422,9,23,1,24,1,24,1,25,1,25,
        3,25,428,8,25,1,25,1,25,1,25,3,25,433,8,25,1,26,4,26,436,8,26,11,
        26,12,26,437,1,27,4,27,441,8,27,11,27,12,27,442,1,28,1,28,1,28,1,
        28,1,28,3,28,450,8,28,1,29,1,29,1,29,5,29,455,8,29,10,29,12,29,458,
        9,29,1,30,1,30,1,30,3,30,463,8,30,1,31,1,31,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,3,32,494,8,32,
        1,33,1,33,3,33,498,8,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,
        507,8,33,1,34,1,34,1,35,4,35,512,8,35,11,35,12,35,513,1,36,1,36,
        1,36,1,36,1,36,1,36,1,36,1,36,3,36,524,8,36,1,37,1,37,3,37,528,8,
        37,1,37,3,37,531,8,37,1,38,1,38,1,38,5,38,536,8,38,10,38,12,38,539,
        9,38,1,39,1,39,3,39,543,8,39,1,39,1,39,3,39,547,8,39,1,40,1,40,3,
        40,551,8,40,1,40,1,40,1,40,3,40,556,8,40,1,40,1,40,1,40,1,40,3,40,
        562,8,40,1,41,1,41,1,41,5,41,567,8,41,10,41,12,41,570,9,41,1,42,
        1,42,1,42,3,42,575,8,42,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,45,
        1,45,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,1,46,3,46,595,8,46,
        1,47,1,47,1,47,1,47,3,47,601,8,47,1,47,1,47,1,48,3,48,606,8,48,1,
        48,1,48,5,48,610,8,48,10,48,12,48,613,9,48,1,49,1,49,1,49,1,49,1,
        49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,
        49,632,8,49,1,49,1,49,1,49,3,49,637,8,49,1,49,3,49,640,8,49,1,49,
        1,49,1,49,1,49,1,49,3,49,647,8,49,1,49,1,49,1,49,1,49,1,49,1,49,
        1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,662,8,49,1,49,1,49,1,49,
        1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,674,8,49,1,49,5,49,677,8,
        49,10,49,12,49,680,9,49,1,50,1,50,1,51,1,51,1,51,4,51,687,8,51,11,
        51,12,51,688,1,51,1,51,3,51,693,8,51,1,52,1,52,1,52,1,52,1,52,1,
        52,1,52,1,53,3,53,703,8,53,1,53,1,53,3,53,707,8,53,5,53,709,8,53,
        10,53,12,53,712,9,53,1,54,1,54,1,54,3,54,717,8,54,1,54,3,54,720,
        8,54,1,55,1,55,1,55,1,55,1,55,5,55,727,8,55,10,55,12,55,730,9,55,
        1,56,1,56,3,56,734,8,56,4,56,736,8,56,11,56,12,56,737,1,57,4,57,
        741,8,57,11,57,12,57,742,1,58,1,58,1,58,3,58,748,8,58,1,59,1,59,
        1,59,5,59,753,8,59,10,59,12,59,756,9,59,1,60,1,60,1,60,1,60,1,60,
        3,60,763,8,60,3,60,765,8,60,1,61,1,61,1,61,5,61,770,8,61,10,61,12,
        61,773,9,61,1,62,1,62,3,62,777,8,62,1,63,1,63,3,63,781,8,63,1,63,
        1,63,5,63,785,8,63,10,63,12,63,788,9,63,3,63,790,8,63,1,64,1,64,
        1,64,1,64,1,64,5,64,797,8,64,10,64,12,64,800,9,64,1,64,1,64,3,64,
        804,8,64,1,64,3,64,807,8,64,1,64,1,64,1,64,1,64,3,64,813,8,64,1,
        64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,
        64,3,64,829,8,64,1,64,1,64,5,64,833,8,64,10,64,12,64,836,9,64,3,
        64,838,8,64,1,64,1,64,1,64,3,64,843,8,64,1,64,3,64,846,8,64,1,64,
        1,64,1,64,1,64,1,64,3,64,853,8,64,1,64,1,64,1,64,1,64,1,64,1,64,
        1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,3,64,872,
        8,64,1,64,1,64,5,64,876,8,64,10,64,12,64,879,9,64,5,64,881,8,64,
        10,64,12,64,884,9,64,1,65,1,65,1,66,1,66,1,66,1,66,3,66,892,8,66,
        1,66,1,66,3,66,896,8,66,1,67,3,67,899,8,67,1,67,1,67,1,67,3,67,904,
        8,67,1,67,5,67,907,8,67,10,67,12,67,910,9,67,1,68,1,68,1,68,1,69,
        4,69,916,8,69,11,69,12,69,917,1,70,1,70,1,70,1,70,1,70,1,70,3,70,
        926,8,70,1,71,1,71,1,71,1,71,1,71,4,71,933,8,71,11,71,12,71,934,
        1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,
        1,72,1,72,5,72,952,8,72,10,72,12,72,955,9,72,3,72,957,8,72,1,72,
        1,72,1,72,1,72,5,72,963,8,72,10,72,12,72,966,9,72,3,72,968,8,72,
        5,72,970,8,72,10,72,12,72,973,9,72,1,72,1,72,1,72,3,72,978,8,72,
        1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,991,
        8,73,1,74,1,74,3,74,995,8,74,1,74,1,74,1,75,4,75,1000,8,75,11,75,
        12,75,1001,1,76,1,76,3,76,1006,8,76,1,77,3,77,1009,8,77,1,77,1,77,
        1,78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1020,8,78,1,78,1,78,1,78,
        1,78,1,78,1,78,3,78,1028,8,78,1,79,1,79,1,79,1,79,1,79,1,79,1,79,
        1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,
        3,79,1050,8,79,1,80,1,80,1,80,5,80,1055,8,80,10,80,12,80,1058,9,
        80,1,80,1,80,3,80,1062,8,80,1,81,1,81,3,81,1066,8,81,3,81,1068,8,
        81,1,81,1,81,3,81,1072,8,81,1,81,1,81,3,81,1076,8,81,1,82,1,82,3,
        82,1080,8,82,1,83,1,83,1,83,5,83,1085,8,83,10,83,12,83,1088,9,83,
        1,84,1,84,1,84,1,84,1,84,1,84,3,84,1096,8,84,1,84,1,84,3,84,1100,
        8,84,1,84,1,84,1,85,3,85,1105,8,85,1,85,1,85,1,86,4,86,1110,8,86,
        11,86,12,86,1111,1,87,1,87,1,87,1,87,3,87,1118,8,87,1,88,3,88,1121,
        8,88,1,88,1,88,3,88,1125,8,88,1,88,1,88,1,89,4,89,1130,8,89,11,89,
        12,89,1131,1,89,0,2,98,128,90,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,0,20,1,0,107,108,3,0,44,44,77,77,79,79,2,0,44,44,55,
        55,5,0,76,76,78,78,80,80,83,83,88,89,1,0,80,82,2,0,76,76,78,78,1,
        0,74,75,1,0,70,73,1,0,105,106,1,0,94,104,6,0,20,20,31,31,39,39,45,
        45,48,48,63,63,1,0,4,6,2,0,46,46,49,49,4,0,24,24,40,40,52,52,56,
        56,2,0,9,9,11,15,2,0,64,65,93,93,1,0,64,65,2,0,80,80,87,87,2,0,16,
        16,18,18,2,0,19,19,52,52,1245,0,180,1,0,0,0,2,218,1,0,0,0,4,220,
        1,0,0,0,6,227,1,0,0,0,8,237,1,0,0,0,10,256,1,0,0,0,12,276,1,0,0,
        0,14,287,1,0,0,0,16,303,1,0,0,0,18,315,1,0,0,0,20,317,1,0,0,0,22,
        325,1,0,0,0,24,333,1,0,0,0,26,341,1,0,0,0,28,349,1,0,0,0,30,357,
        1,0,0,0,32,365,1,0,0,0,34,373,1,0,0,0,36,381,1,0,0,0,38,389,1,0,
        0,0,40,397,1,0,0,0,42,411,1,0,0,0,44,413,1,0,0,0,46,415,1,0,0,0,
        48,423,1,0,0,0,50,432,1,0,0,0,52,435,1,0,0,0,54,440,1,0,0,0,56,449,
        1,0,0,0,58,451,1,0,0,0,60,459,1,0,0,0,62,464,1,0,0,0,64,493,1,0,
        0,0,66,506,1,0,0,0,68,508,1,0,0,0,70,511,1,0,0,0,72,523,1,0,0,0,
        74,527,1,0,0,0,76,532,1,0,0,0,78,546,1,0,0,0,80,561,1,0,0,0,82,563,
        1,0,0,0,84,571,1,0,0,0,86,576,1,0,0,0,88,578,1,0,0,0,90,583,1,0,
        0,0,92,594,1,0,0,0,94,596,1,0,0,0,96,605,1,0,0,0,98,631,1,0,0,0,
        100,681,1,0,0,0,102,692,1,0,0,0,104,694,1,0,0,0,106,702,1,0,0,0,
        108,713,1,0,0,0,110,728,1,0,0,0,112,735,1,0,0,0,114,740,1,0,0,0,
        116,744,1,0,0,0,118,749,1,0,0,0,120,764,1,0,0,0,122,766,1,0,0,0,
        124,774,1,0,0,0,126,789,1,0,0,0,128,837,1,0,0,0,130,885,1,0,0,0,
        132,895,1,0,0,0,134,898,1,0,0,0,136,911,1,0,0,0,138,915,1,0,0,0,
        140,925,1,0,0,0,142,927,1,0,0,0,144,977,1,0,0,0,146,990,1,0,0,0,
        148,992,1,0,0,0,150,999,1,0,0,0,152,1005,1,0,0,0,154,1008,1,0,0,
        0,156,1027,1,0,0,0,158,1049,1,0,0,0,160,1051,1,0,0,0,162,1067,1,
        0,0,0,164,1077,1,0,0,0,166,1081,1,0,0,0,168,1099,1,0,0,0,170,1104,
        1,0,0,0,172,1109,1,0,0,0,174,1117,1,0,0,0,176,1120,1,0,0,0,178,1129,
        1,0,0,0,180,181,5,110,0,0,181,182,5,64,0,0,182,183,3,46,23,0,183,
        184,5,65,0,0,184,1,1,0,0,0,185,219,5,110,0,0,186,219,5,111,0,0,187,
        189,5,113,0,0,188,187,1,0,0,0,189,190,1,0,0,0,190,188,1,0,0,0,190,
        191,1,0,0,0,191,219,1,0,0,0,192,193,5,64,0,0,193,194,3,46,23,0,194,
        195,5,65,0,0,195,219,1,0,0,0,196,219,3,4,2,0,197,199,5,1,0,0,198,
        197,1,0,0,0,198,199,1,0,0,0,199,200,1,0,0,0,200,201,5,64,0,0,201,
        202,3,148,74,0,202,203,5,65,0,0,203,219,1,0,0,0,204,205,5,2,0,0,
        205,206,5,64,0,0,206,207,3,14,7,0,207,208,5,93,0,0,208,209,3,124,
        62,0,209,210,5,65,0,0,210,219,1,0,0,0,211,212,5,3,0,0,212,213,5,
        64,0,0,213,214,3,124,62,0,214,215,5,93,0,0,215,216,3,14,7,0,216,
        217,5,65,0,0,217,219,1,0,0,0,218,185,1,0,0,0,218,186,1,0,0,0,218,
        188,1,0,0,0,218,192,1,0,0,0,218,196,1,0,0,0,218,198,1,0,0,0,218,
        204,1,0,0,0,218,211,1,0,0,0,219,3,1,0,0,0,220,221,5,59,0,0,221,222,
        5,64,0,0,222,223,3,42,21,0,223,224,5,93,0,0,224,225,3,6,3,0,225,
        226,5,65,0,0,226,5,1,0,0,0,227,232,3,8,4,0,228,229,5,93,0,0,229,
        231,3,8,4,0,230,228,1,0,0,0,231,234,1,0,0,0,232,230,1,0,0,0,232,
        233,1,0,0,0,233,7,1,0,0,0,234,232,1,0,0,0,235,238,3,124,62,0,236,
        238,5,26,0,0,237,235,1,0,0,0,237,236,1,0,0,0,238,239,1,0,0,0,239,
        240,5,91,0,0,240,241,3,42,21,0,241,9,1,0,0,0,242,257,3,2,1,0,243,
        245,5,1,0,0,244,243,1,0,0,0,244,245,1,0,0,0,245,246,1,0,0,0,246,
        247,5,64,0,0,247,248,3,124,62,0,248,249,5,65,0,0,249,250,5,68,0,
        0,250,252,3,134,67,0,251,253,5,93,0,0,252,251,1,0,0,0,252,253,1,
        0,0,0,253,254,1,0,0,0,254,255,5,69,0,0,255,257,1,0,0,0,256,242,1,
        0,0,0,256,244,1,0,0,0,257,273,1,0,0,0,258,259,5,66,0,0,259,260,3,
        46,23,0,260,261,5,67,0,0,261,272,1,0,0,0,262,264,5,64,0,0,263,265,
        3,12,6,0,264,263,1,0,0,0,264,265,1,0,0,0,265,266,1,0,0,0,266,272,
        5,65,0,0,267,268,7,0,0,0,268,272,5,110,0,0,269,272,5,77,0,0,270,
        272,5,79,0,0,271,258,1,0,0,0,271,262,1,0,0,0,271,267,1,0,0,0,271,
        269,1,0,0,0,271,270,1,0,0,0,272,275,1,0,0,0,273,271,1,0,0,0,273,
        274,1,0,0,0,274,11,1,0,0,0,275,273,1,0,0,0,276,281,3,42,21,0,277,
        278,5,93,0,0,278,280,3,42,21,0,279,277,1,0,0,0,280,283,1,0,0,0,281,
        279,1,0,0,0,281,282,1,0,0,0,282,13,1,0,0,0,283,281,1,0,0,0,284,286,
        7,1,0,0,285,284,1,0,0,0,286,289,1,0,0,0,287,285,1,0,0,0,287,288,
        1,0,0,0,288,301,1,0,0,0,289,287,1,0,0,0,290,302,3,10,5,0,291,292,
        3,16,8,0,292,293,3,18,9,0,293,302,1,0,0,0,294,295,7,2,0,0,295,296,
        5,64,0,0,296,297,3,124,62,0,297,298,5,65,0,0,298,302,1,0,0,0,299,
        300,5,85,0,0,300,302,5,110,0,0,301,290,1,0,0,0,301,291,1,0,0,0,301,
        294,1,0,0,0,301,299,1,0,0,0,302,15,1,0,0,0,303,304,7,3,0,0,304,17,
        1,0,0,0,305,307,5,1,0,0,306,305,1,0,0,0,306,307,1,0,0,0,307,308,
        1,0,0,0,308,309,5,64,0,0,309,310,3,124,62,0,310,311,5,65,0,0,311,
        312,3,18,9,0,312,316,1,0,0,0,313,316,3,14,7,0,314,316,5,112,0,0,
        315,306,1,0,0,0,315,313,1,0,0,0,315,314,1,0,0,0,316,19,1,0,0,0,317,
        322,3,18,9,0,318,319,7,4,0,0,319,321,3,18,9,0,320,318,1,0,0,0,321,
        324,1,0,0,0,322,320,1,0,0,0,322,323,1,0,0,0,323,21,1,0,0,0,324,322,
        1,0,0,0,325,330,3,20,10,0,326,327,7,5,0,0,327,329,3,20,10,0,328,
        326,1,0,0,0,329,332,1,0,0,0,330,328,1,0,0,0,330,331,1,0,0,0,331,
        23,1,0,0,0,332,330,1,0,0,0,333,338,3,22,11,0,334,335,7,6,0,0,335,
        337,3,22,11,0,336,334,1,0,0,0,337,340,1,0,0,0,338,336,1,0,0,0,338,
        339,1,0,0,0,339,25,1,0,0,0,340,338,1,0,0,0,341,346,3,24,12,0,342,
        343,7,7,0,0,343,345,3,24,12,0,344,342,1,0,0,0,345,348,1,0,0,0,346,
        344,1,0,0,0,346,347,1,0,0,0,347,27,1,0,0,0,348,346,1,0,0,0,349,354,
        3,26,13,0,350,351,7,8,0,0,351,353,3,26,13,0,352,350,1,0,0,0,353,
        356,1,0,0,0,354,352,1,0,0,0,354,355,1,0,0,0,355,29,1,0,0,0,356,354,
        1,0,0,0,357,362,3,28,14,0,358,359,5,83,0,0,359,361,3,28,14,0,360,
        358,1,0,0,0,361,364,1,0,0,0,362,360,1,0,0,0,362,363,1,0,0,0,363,
        31,1,0,0,0,364,362,1,0,0,0,365,370,3,30,15,0,366,367,5,87,0,0,367,
        369,3,30,15,0,368,366,1,0,0,0,369,372,1,0,0,0,370,368,1,0,0,0,370,
        371,1,0,0,0,371,33,1,0,0,0,372,370,1,0,0,0,373,378,3,32,16,0,374,
        375,5,84,0,0,375,377,3,32,16,0,376,374,1,0,0,0,377,380,1,0,0,0,378,
        376,1,0,0,0,378,379,1,0,0,0,379,35,1,0,0,0,380,378,1,0,0,0,381,386,
        3,34,17,0,382,383,5,85,0,0,383,385,3,34,17,0,384,382,1,0,0,0,385,
        388,1,0,0,0,386,384,1,0,0,0,386,387,1,0,0,0,387,37,1,0,0,0,388,386,
        1,0,0,0,389,394,3,36,18,0,390,391,5,86,0,0,391,393,3,36,18,0,392,
        390,1,0,0,0,393,396,1,0,0,0,394,392,1,0,0,0,394,395,1,0,0,0,395,
        39,1,0,0,0,396,394,1,0,0,0,397,403,3,38,19,0,398,399,5,90,0,0,399,
        400,3,46,23,0,400,401,5,91,0,0,401,402,3,40,20,0,402,404,1,0,0,0,
        403,398,1,0,0,0,403,404,1,0,0,0,404,41,1,0,0,0,405,412,3,40,20,0,
        406,407,3,14,7,0,407,408,3,44,22,0,408,409,3,42,21,0,409,412,1,0,
        0,0,410,412,5,112,0,0,411,405,1,0,0,0,411,406,1,0,0,0,411,410,1,
        0,0,0,412,43,1,0,0,0,413,414,7,9,0,0,414,45,1,0,0,0,415,420,3,42,
        21,0,416,417,5,93,0,0,417,419,3,42,21,0,418,416,1,0,0,0,419,422,
        1,0,0,0,420,418,1,0,0,0,420,421,1,0,0,0,421,47,1,0,0,0,422,420,1,
        0,0,0,423,424,3,40,20,0,424,49,1,0,0,0,425,427,3,52,26,0,426,428,
        3,58,29,0,427,426,1,0,0,0,427,428,1,0,0,0,428,429,1,0,0,0,429,430,
        5,92,0,0,430,433,1,0,0,0,431,433,3,142,71,0,432,425,1,0,0,0,432,
        431,1,0,0,0,433,51,1,0,0,0,434,436,3,56,28,0,435,434,1,0,0,0,436,
        437,1,0,0,0,437,435,1,0,0,0,437,438,1,0,0,0,438,53,1,0,0,0,439,441,
        3,56,28,0,440,439,1,0,0,0,441,442,1,0,0,0,442,440,1,0,0,0,442,443,
        1,0,0,0,443,55,1,0,0,0,444,450,3,62,31,0,445,450,3,64,32,0,446,450,
        3,90,45,0,447,450,3,92,46,0,448,450,3,94,47,0,449,444,1,0,0,0,449,
        445,1,0,0,0,449,446,1,0,0,0,449,447,1,0,0,0,449,448,1,0,0,0,450,
        57,1,0,0,0,451,456,3,60,30,0,452,453,5,93,0,0,453,455,3,60,30,0,
        454,452,1,0,0,0,455,458,1,0,0,0,456,454,1,0,0,0,456,457,1,0,0,0,
        457,59,1,0,0,0,458,456,1,0,0,0,459,462,3,96,48,0,460,461,5,94,0,
        0,461,463,3,132,66,0,462,460,1,0,0,0,462,463,1,0,0,0,463,61,1,0,
        0,0,464,465,7,10,0,0,465,63,1,0,0,0,466,494,5,51,0,0,467,494,5,23,
        0,0,468,494,5,42,0,0,469,494,5,37,0,0,470,494,5,38,0,0,471,494,5,
        32,0,0,472,494,5,28,0,0,473,494,5,43,0,0,474,494,5,50,0,0,475,494,
        5,57,0,0,476,494,5,58,0,0,477,494,5,4,0,0,478,494,5,5,0,0,479,494,
        5,6,0,0,480,481,5,1,0,0,481,482,5,64,0,0,482,483,7,11,0,0,483,494,
        5,65,0,0,484,494,3,88,44,0,485,494,3,66,33,0,486,494,3,80,40,0,487,
        494,3,130,65,0,488,489,5,7,0,0,489,490,5,64,0,0,490,491,3,48,24,
        0,491,492,5,65,0,0,492,494,1,0,0,0,493,466,1,0,0,0,493,467,1,0,0,
        0,493,468,1,0,0,0,493,469,1,0,0,0,493,470,1,0,0,0,493,471,1,0,0,
        0,493,472,1,0,0,0,493,473,1,0,0,0,493,474,1,0,0,0,493,475,1,0,0,
        0,493,476,1,0,0,0,493,477,1,0,0,0,493,478,1,0,0,0,493,479,1,0,0,
        0,493,480,1,0,0,0,493,484,1,0,0,0,493,485,1,0,0,0,493,486,1,0,0,
        0,493,487,1,0,0,0,493,488,1,0,0,0,494,65,1,0,0,0,495,497,3,68,34,
        0,496,498,5,110,0,0,497,496,1,0,0,0,497,498,1,0,0,0,498,499,1,0,
        0,0,499,500,5,68,0,0,500,501,3,70,35,0,501,502,5,69,0,0,502,507,
        1,0,0,0,503,504,3,68,34,0,504,505,5,110,0,0,505,507,1,0,0,0,506,
        495,1,0,0,0,506,503,1,0,0,0,507,67,1,0,0,0,508,509,7,12,0,0,509,
        69,1,0,0,0,510,512,3,72,36,0,511,510,1,0,0,0,512,513,1,0,0,0,513,
        511,1,0,0,0,513,514,1,0,0,0,514,71,1,0,0,0,515,516,3,74,37,0,516,
        517,3,76,38,0,517,518,5,92,0,0,518,524,1,0,0,0,519,520,3,74,37,0,
        520,521,5,92,0,0,521,524,1,0,0,0,522,524,3,142,71,0,523,515,1,0,
        0,0,523,519,1,0,0,0,523,522,1,0,0,0,524,73,1,0,0,0,525,528,3,64,
        32,0,526,528,3,90,45,0,527,525,1,0,0,0,527,526,1,0,0,0,528,530,1,
        0,0,0,529,531,3,74,37,0,530,529,1,0,0,0,530,531,1,0,0,0,531,75,1,
        0,0,0,532,537,3,78,39,0,533,534,5,93,0,0,534,536,3,78,39,0,535,533,
        1,0,0,0,536,539,1,0,0,0,537,535,1,0,0,0,537,538,1,0,0,0,538,77,1,
        0,0,0,539,537,1,0,0,0,540,547,3,96,48,0,541,543,3,96,48,0,542,541,
        1,0,0,0,542,543,1,0,0,0,543,544,1,0,0,0,544,545,5,91,0,0,545,547,
        3,48,24,0,546,540,1,0,0,0,546,542,1,0,0,0,547,79,1,0,0,0,548,550,
        5,30,0,0,549,551,5,110,0,0,550,549,1,0,0,0,550,551,1,0,0,0,551,552,
        1,0,0,0,552,553,5,68,0,0,553,555,3,82,41,0,554,556,5,93,0,0,555,
        554,1,0,0,0,555,556,1,0,0,0,556,557,1,0,0,0,557,558,5,69,0,0,558,
        562,1,0,0,0,559,560,5,30,0,0,560,562,5,110,0,0,561,548,1,0,0,0,561,
        559,1,0,0,0,562,81,1,0,0,0,563,568,3,84,42,0,564,565,5,93,0,0,565,
        567,3,84,42,0,566,564,1,0,0,0,567,570,1,0,0,0,568,566,1,0,0,0,568,
        569,1,0,0,0,569,83,1,0,0,0,570,568,1,0,0,0,571,574,3,86,43,0,572,
        573,5,94,0,0,573,575,3,48,24,0,574,572,1,0,0,0,574,575,1,0,0,0,575,
        85,1,0,0,0,576,577,5,110,0,0,577,87,1,0,0,0,578,579,5,56,0,0,579,
        580,5,64,0,0,580,581,3,124,62,0,581,582,5,65,0,0,582,89,1,0,0,0,
        583,584,7,13,0,0,584,91,1,0,0,0,585,595,5,36,0,0,586,595,5,61,0,
        0,587,595,5,8,0,0,588,595,5,9,0,0,589,595,3,104,52,0,590,591,5,10,
        0,0,591,592,5,64,0,0,592,593,5,110,0,0,593,595,5,65,0,0,594,585,
        1,0,0,0,594,586,1,0,0,0,594,587,1,0,0,0,594,588,1,0,0,0,594,589,
        1,0,0,0,594,590,1,0,0,0,595,93,1,0,0,0,596,597,5,54,0,0,597,600,
        5,64,0,0,598,601,3,124,62,0,599,601,3,48,24,0,600,598,1,0,0,0,600,
        599,1,0,0,0,601,602,1,0,0,0,602,603,5,65,0,0,603,95,1,0,0,0,604,
        606,3,112,56,0,605,604,1,0,0,0,605,606,1,0,0,0,606,607,1,0,0,0,607,
        611,3,98,49,0,608,610,3,102,51,0,609,608,1,0,0,0,610,613,1,0,0,0,
        611,609,1,0,0,0,611,612,1,0,0,0,612,97,1,0,0,0,613,611,1,0,0,0,614,
        615,6,49,-1,0,615,632,5,110,0,0,616,617,5,64,0,0,617,618,3,96,48,
        0,618,619,5,65,0,0,619,632,1,0,0,0,620,621,5,110,0,0,621,622,5,91,
        0,0,622,632,5,112,0,0,623,624,3,100,50,0,624,625,5,110,0,0,625,632,
        1,0,0,0,626,627,5,64,0,0,627,628,3,100,50,0,628,629,3,96,48,0,629,
        630,5,65,0,0,630,632,1,0,0,0,631,614,1,0,0,0,631,616,1,0,0,0,631,
        620,1,0,0,0,631,623,1,0,0,0,631,626,1,0,0,0,632,678,1,0,0,0,633,
        634,10,9,0,0,634,636,5,66,0,0,635,637,3,114,57,0,636,635,1,0,0,0,
        636,637,1,0,0,0,637,639,1,0,0,0,638,640,3,42,21,0,639,638,1,0,0,
        0,639,640,1,0,0,0,640,641,1,0,0,0,641,677,5,67,0,0,642,643,10,8,
        0,0,643,644,5,66,0,0,644,646,5,45,0,0,645,647,3,114,57,0,646,645,
        1,0,0,0,646,647,1,0,0,0,647,648,1,0,0,0,648,649,3,42,21,0,649,650,
        5,67,0,0,650,677,1,0,0,0,651,652,10,7,0,0,652,653,5,66,0,0,653,654,
        3,114,57,0,654,655,5,45,0,0,655,656,3,42,21,0,656,657,5,67,0,0,657,
        677,1,0,0,0,658,659,10,6,0,0,659,661,5,66,0,0,660,662,3,114,57,0,
        661,660,1,0,0,0,661,662,1,0,0,0,662,663,1,0,0,0,663,664,5,80,0,0,
        664,677,5,67,0,0,665,666,10,5,0,0,666,667,5,64,0,0,667,668,3,116,
        58,0,668,669,5,65,0,0,669,677,1,0,0,0,670,671,10,4,0,0,671,673,5,
        64,0,0,672,674,3,122,61,0,673,672,1,0,0,0,673,674,1,0,0,0,674,675,
        1,0,0,0,675,677,5,65,0,0,676,633,1,0,0,0,676,642,1,0,0,0,676,651,
        1,0,0,0,676,658,1,0,0,0,676,665,1,0,0,0,676,670,1,0,0,0,677,680,
        1,0,0,0,678,676,1,0,0,0,678,679,1,0,0,0,679,99,1,0,0,0,680,678,1,
        0,0,0,681,682,7,14,0,0,682,101,1,0,0,0,683,684,5,16,0,0,684,686,
        5,64,0,0,685,687,5,113,0,0,686,685,1,0,0,0,687,688,1,0,0,0,688,686,
        1,0,0,0,688,689,1,0,0,0,689,690,1,0,0,0,690,693,5,65,0,0,691,693,
        3,104,52,0,692,683,1,0,0,0,692,691,1,0,0,0,693,103,1,0,0,0,694,695,
        5,17,0,0,695,696,5,64,0,0,696,697,5,64,0,0,697,698,3,106,53,0,698,
        699,5,65,0,0,699,700,5,65,0,0,700,105,1,0,0,0,701,703,3,108,54,0,
        702,701,1,0,0,0,702,703,1,0,0,0,703,710,1,0,0,0,704,706,5,93,0,0,
        705,707,3,108,54,0,706,705,1,0,0,0,706,707,1,0,0,0,707,709,1,0,0,
        0,708,704,1,0,0,0,709,712,1,0,0,0,710,708,1,0,0,0,710,711,1,0,0,
        0,711,107,1,0,0,0,712,710,1,0,0,0,713,719,8,15,0,0,714,716,5,64,
        0,0,715,717,3,12,6,0,716,715,1,0,0,0,716,717,1,0,0,0,717,718,1,0,
        0,0,718,720,5,65,0,0,719,714,1,0,0,0,719,720,1,0,0,0,720,109,1,0,
        0,0,721,727,8,16,0,0,722,723,5,64,0,0,723,724,3,110,55,0,724,725,
        5,65,0,0,725,727,1,0,0,0,726,721,1,0,0,0,726,722,1,0,0,0,727,730,
        1,0,0,0,728,726,1,0,0,0,728,729,1,0,0,0,729,111,1,0,0,0,730,728,
        1,0,0,0,731,733,7,17,0,0,732,734,3,114,57,0,733,732,1,0,0,0,733,
        734,1,0,0,0,734,736,1,0,0,0,735,731,1,0,0,0,736,737,1,0,0,0,737,
        735,1,0,0,0,737,738,1,0,0,0,738,113,1,0,0,0,739,741,3,90,45,0,740,
        739,1,0,0,0,741,742,1,0,0,0,742,740,1,0,0,0,742,743,1,0,0,0,743,
        115,1,0,0,0,744,747,3,118,59,0,745,746,5,93,0,0,746,748,5,109,0,
        0,747,745,1,0,0,0,747,748,1,0,0,0,748,117,1,0,0,0,749,754,3,120,
        60,0,750,751,5,93,0,0,751,753,3,120,60,0,752,750,1,0,0,0,753,756,
        1,0,0,0,754,752,1,0,0,0,754,755,1,0,0,0,755,119,1,0,0,0,756,754,
        1,0,0,0,757,758,3,52,26,0,758,759,3,96,48,0,759,765,1,0,0,0,760,
        762,3,54,27,0,761,763,3,126,63,0,762,761,1,0,0,0,762,763,1,0,0,0,
        763,765,1,0,0,0,764,757,1,0,0,0,764,760,1,0,0,0,765,121,1,0,0,0,
        766,771,5,110,0,0,767,768,5,93,0,0,768,770,5,110,0,0,769,767,1,0,
        0,0,770,773,1,0,0,0,771,769,1,0,0,0,771,772,1,0,0,0,772,123,1,0,
        0,0,773,771,1,0,0,0,774,776,3,74,37,0,775,777,3,126,63,0,776,775,
        1,0,0,0,776,777,1,0,0,0,777,125,1,0,0,0,778,790,3,112,56,0,779,781,
        3,112,56,0,780,779,1,0,0,0,780,781,1,0,0,0,781,782,1,0,0,0,782,786,
        3,128,64,0,783,785,3,102,51,0,784,783,1,0,0,0,785,788,1,0,0,0,786,
        784,1,0,0,0,786,787,1,0,0,0,787,790,1,0,0,0,788,786,1,0,0,0,789,
        778,1,0,0,0,789,780,1,0,0,0,790,127,1,0,0,0,791,792,6,64,-1,0,792,
        793,5,64,0,0,793,794,3,126,63,0,794,798,5,65,0,0,795,797,3,102,51,
        0,796,795,1,0,0,0,797,800,1,0,0,0,798,796,1,0,0,0,798,799,1,0,0,
        0,799,838,1,0,0,0,800,798,1,0,0,0,801,803,5,66,0,0,802,804,3,114,
        57,0,803,802,1,0,0,0,803,804,1,0,0,0,804,806,1,0,0,0,805,807,3,42,
        21,0,806,805,1,0,0,0,806,807,1,0,0,0,807,808,1,0,0,0,808,838,5,67,
        0,0,809,810,5,66,0,0,810,812,5,45,0,0,811,813,3,114,57,0,812,811,
        1,0,0,0,812,813,1,0,0,0,813,814,1,0,0,0,814,815,3,42,21,0,815,816,
        5,67,0,0,816,838,1,0,0,0,817,818,5,66,0,0,818,819,3,114,57,0,819,
        820,5,45,0,0,820,821,3,42,21,0,821,822,5,67,0,0,822,838,1,0,0,0,
        823,824,5,66,0,0,824,825,5,80,0,0,825,838,5,67,0,0,826,828,5,64,
        0,0,827,829,3,116,58,0,828,827,1,0,0,0,828,829,1,0,0,0,829,830,1,
        0,0,0,830,834,5,65,0,0,831,833,3,102,51,0,832,831,1,0,0,0,833,836,
        1,0,0,0,834,832,1,0,0,0,834,835,1,0,0,0,835,838,1,0,0,0,836,834,
        1,0,0,0,837,791,1,0,0,0,837,801,1,0,0,0,837,809,1,0,0,0,837,817,
        1,0,0,0,837,823,1,0,0,0,837,826,1,0,0,0,838,882,1,0,0,0,839,840,
        10,5,0,0,840,842,5,66,0,0,841,843,3,114,57,0,842,841,1,0,0,0,842,
        843,1,0,0,0,843,845,1,0,0,0,844,846,3,42,21,0,845,844,1,0,0,0,845,
        846,1,0,0,0,846,847,1,0,0,0,847,881,5,67,0,0,848,849,10,4,0,0,849,
        850,5,66,0,0,850,852,5,45,0,0,851,853,3,114,57,0,852,851,1,0,0,0,
        852,853,1,0,0,0,853,854,1,0,0,0,854,855,3,42,21,0,855,856,5,67,0,
        0,856,881,1,0,0,0,857,858,10,3,0,0,858,859,5,66,0,0,859,860,3,114,
        57,0,860,861,5,45,0,0,861,862,3,42,21,0,862,863,5,67,0,0,863,881,
        1,0,0,0,864,865,10,2,0,0,865,866,5,66,0,0,866,867,5,80,0,0,867,881,
        5,67,0,0,868,869,10,1,0,0,869,871,5,64,0,0,870,872,3,116,58,0,871,
        870,1,0,0,0,871,872,1,0,0,0,872,873,1,0,0,0,873,877,5,65,0,0,874,
        876,3,102,51,0,875,874,1,0,0,0,876,879,1,0,0,0,877,875,1,0,0,0,877,
        878,1,0,0,0,878,881,1,0,0,0,879,877,1,0,0,0,880,839,1,0,0,0,880,
        848,1,0,0,0,880,857,1,0,0,0,880,864,1,0,0,0,880,868,1,0,0,0,881,
        884,1,0,0,0,882,880,1,0,0,0,882,883,1,0,0,0,883,129,1,0,0,0,884,
        882,1,0,0,0,885,886,5,110,0,0,886,131,1,0,0,0,887,896,3,42,21,0,
        888,889,5,68,0,0,889,891,3,134,67,0,890,892,5,93,0,0,891,890,1,0,
        0,0,891,892,1,0,0,0,892,893,1,0,0,0,893,894,5,69,0,0,894,896,1,0,
        0,0,895,887,1,0,0,0,895,888,1,0,0,0,896,133,1,0,0,0,897,899,3,136,
        68,0,898,897,1,0,0,0,898,899,1,0,0,0,899,900,1,0,0,0,900,908,3,132,
        66,0,901,903,5,93,0,0,902,904,3,136,68,0,903,902,1,0,0,0,903,904,
        1,0,0,0,904,905,1,0,0,0,905,907,3,132,66,0,906,901,1,0,0,0,907,910,
        1,0,0,0,908,906,1,0,0,0,908,909,1,0,0,0,909,135,1,0,0,0,910,908,
        1,0,0,0,911,912,3,138,69,0,912,913,5,94,0,0,913,137,1,0,0,0,914,
        916,3,140,70,0,915,914,1,0,0,0,916,917,1,0,0,0,917,915,1,0,0,0,917,
        918,1,0,0,0,918,139,1,0,0,0,919,920,5,66,0,0,920,921,3,48,24,0,921,
        922,5,67,0,0,922,926,1,0,0,0,923,924,5,108,0,0,924,926,5,110,0,0,
        925,919,1,0,0,0,925,923,1,0,0,0,926,141,1,0,0,0,927,928,5,62,0,0,
        928,929,5,64,0,0,929,930,3,48,24,0,930,932,5,93,0,0,931,933,5,113,
        0,0,932,931,1,0,0,0,933,934,1,0,0,0,934,932,1,0,0,0,934,935,1,0,
        0,0,935,936,1,0,0,0,936,937,5,65,0,0,937,938,5,92,0,0,938,143,1,
        0,0,0,939,978,3,146,73,0,940,978,3,148,74,0,941,978,3,154,77,0,942,
        978,3,156,78,0,943,978,3,158,79,0,944,978,3,168,84,0,945,946,7,18,
        0,0,946,947,7,19,0,0,947,956,5,64,0,0,948,953,3,38,19,0,949,950,
        5,93,0,0,950,952,3,38,19,0,951,949,1,0,0,0,952,955,1,0,0,0,953,951,
        1,0,0,0,953,954,1,0,0,0,954,957,1,0,0,0,955,953,1,0,0,0,956,948,
        1,0,0,0,956,957,1,0,0,0,957,971,1,0,0,0,958,967,5,91,0,0,959,964,
        3,38,19,0,960,961,5,93,0,0,961,963,3,38,19,0,962,960,1,0,0,0,963,
        966,1,0,0,0,964,962,1,0,0,0,964,965,1,0,0,0,965,968,1,0,0,0,966,
        964,1,0,0,0,967,959,1,0,0,0,967,968,1,0,0,0,968,970,1,0,0,0,969,
        958,1,0,0,0,970,973,1,0,0,0,971,969,1,0,0,0,971,972,1,0,0,0,972,
        974,1,0,0,0,973,971,1,0,0,0,974,975,5,65,0,0,975,978,5,92,0,0,976,
        978,3,160,80,0,977,939,1,0,0,0,977,940,1,0,0,0,977,941,1,0,0,0,977,
        942,1,0,0,0,977,943,1,0,0,0,977,944,1,0,0,0,977,945,1,0,0,0,977,
        976,1,0,0,0,978,145,1,0,0,0,979,980,5,110,0,0,980,981,5,91,0,0,981,
        991,3,144,72,0,982,983,5,22,0,0,983,984,3,48,24,0,984,985,5,91,0,
        0,985,986,3,144,72,0,986,991,1,0,0,0,987,988,5,26,0,0,988,989,5,
        91,0,0,989,991,3,144,72,0,990,979,1,0,0,0,990,982,1,0,0,0,990,987,
        1,0,0,0,991,147,1,0,0,0,992,994,5,68,0,0,993,995,3,150,75,0,994,
        993,1,0,0,0,994,995,1,0,0,0,995,996,1,0,0,0,996,997,5,69,0,0,997,
        149,1,0,0,0,998,1000,3,152,76,0,999,998,1,0,0,0,1000,1001,1,0,0,
        0,1001,999,1,0,0,0,1001,1002,1,0,0,0,1002,151,1,0,0,0,1003,1006,
        3,144,72,0,1004,1006,3,50,25,0,1005,1003,1,0,0,0,1005,1004,1,0,0,
        0,1006,153,1,0,0,0,1007,1009,3,46,23,0,1008,1007,1,0,0,0,1008,1009,
        1,0,0,0,1009,1010,1,0,0,0,1010,1011,5,92,0,0,1011,155,1,0,0,0,1012,
        1013,5,35,0,0,1013,1014,5,64,0,0,1014,1015,3,46,23,0,1015,1016,5,
        65,0,0,1016,1019,3,144,72,0,1017,1018,5,29,0,0,1018,1020,3,144,72,
        0,1019,1017,1,0,0,0,1019,1020,1,0,0,0,1020,1028,1,0,0,0,1021,1022,
        5,47,0,0,1022,1023,5,64,0,0,1023,1024,3,46,23,0,1024,1025,5,65,0,
        0,1025,1026,3,144,72,0,1026,1028,1,0,0,0,1027,1012,1,0,0,0,1027,
        1021,1,0,0,0,1028,157,1,0,0,0,1029,1030,5,53,0,0,1030,1031,5,64,
        0,0,1031,1032,3,46,23,0,1032,1033,5,65,0,0,1033,1034,3,144,72,0,
        1034,1050,1,0,0,0,1035,1036,5,27,0,0,1036,1037,3,144,72,0,1037,1038,
        5,53,0,0,1038,1039,5,64,0,0,1039,1040,3,46,23,0,1040,1041,5,65,0,
        0,1041,1042,5,92,0,0,1042,1050,1,0,0,0,1043,1044,5,33,0,0,1044,1045,
        5,64,0,0,1045,1046,3,162,81,0,1046,1047,5,65,0,0,1047,1048,3,144,
        72,0,1048,1050,1,0,0,0,1049,1029,1,0,0,0,1049,1035,1,0,0,0,1049,
        1043,1,0,0,0,1050,159,1,0,0,0,1051,1052,3,46,23,0,1052,1056,5,64,
        0,0,1053,1055,3,144,72,0,1054,1053,1,0,0,0,1055,1058,1,0,0,0,1056,
        1054,1,0,0,0,1056,1057,1,0,0,0,1057,1059,1,0,0,0,1058,1056,1,0,0,
        0,1059,1061,5,65,0,0,1060,1062,5,92,0,0,1061,1060,1,0,0,0,1061,1062,
        1,0,0,0,1062,161,1,0,0,0,1063,1068,3,164,82,0,1064,1066,3,46,23,
        0,1065,1064,1,0,0,0,1065,1066,1,0,0,0,1066,1068,1,0,0,0,1067,1063,
        1,0,0,0,1067,1065,1,0,0,0,1068,1069,1,0,0,0,1069,1071,5,92,0,0,1070,
        1072,3,166,83,0,1071,1070,1,0,0,0,1071,1072,1,0,0,0,1072,1073,1,
        0,0,0,1073,1075,5,92,0,0,1074,1076,3,166,83,0,1075,1074,1,0,0,0,
        1075,1076,1,0,0,0,1076,163,1,0,0,0,1077,1079,3,52,26,0,1078,1080,
        3,58,29,0,1079,1078,1,0,0,0,1079,1080,1,0,0,0,1080,165,1,0,0,0,1081,
        1086,3,42,21,0,1082,1083,5,93,0,0,1083,1085,3,42,21,0,1084,1082,
        1,0,0,0,1085,1088,1,0,0,0,1086,1084,1,0,0,0,1086,1087,1,0,0,0,1087,
        167,1,0,0,0,1088,1086,1,0,0,0,1089,1090,5,34,0,0,1090,1100,5,110,
        0,0,1091,1100,5,25,0,0,1092,1100,5,21,0,0,1093,1095,5,41,0,0,1094,
        1096,3,46,23,0,1095,1094,1,0,0,0,1095,1096,1,0,0,0,1096,1100,1,0,
        0,0,1097,1098,5,34,0,0,1098,1100,3,14,7,0,1099,1089,1,0,0,0,1099,
        1091,1,0,0,0,1099,1092,1,0,0,0,1099,1093,1,0,0,0,1099,1097,1,0,0,
        0,1100,1101,1,0,0,0,1101,1102,5,92,0,0,1102,169,1,0,0,0,1103,1105,
        3,172,86,0,1104,1103,1,0,0,0,1104,1105,1,0,0,0,1105,1106,1,0,0,0,
        1106,1107,5,0,0,1,1107,171,1,0,0,0,1108,1110,3,174,87,0,1109,1108,
        1,0,0,0,1110,1111,1,0,0,0,1111,1109,1,0,0,0,1111,1112,1,0,0,0,1112,
        173,1,0,0,0,1113,1118,3,176,88,0,1114,1118,3,50,25,0,1115,1118,3,
        0,0,0,1116,1118,5,92,0,0,1117,1113,1,0,0,0,1117,1114,1,0,0,0,1117,
        1115,1,0,0,0,1117,1116,1,0,0,0,1118,175,1,0,0,0,1119,1121,3,52,26,
        0,1120,1119,1,0,0,0,1120,1121,1,0,0,0,1121,1122,1,0,0,0,1122,1124,
        3,96,48,0,1123,1125,3,178,89,0,1124,1123,1,0,0,0,1124,1125,1,0,0,
        0,1125,1126,1,0,0,0,1126,1127,3,148,74,0,1127,177,1,0,0,0,1128,1130,
        3,50,25,0,1129,1128,1,0,0,0,1130,1131,1,0,0,0,1131,1129,1,0,0,0,
        1131,1132,1,0,0,0,1132,179,1,0,0,0,136,190,198,218,232,237,244,252,
        256,264,271,273,281,287,301,306,315,322,330,338,346,354,362,370,
        378,386,394,403,411,420,427,432,437,442,449,456,462,493,497,506,
        513,523,527,530,537,542,546,550,555,561,568,574,594,600,605,611,
        631,636,639,646,661,673,676,678,688,692,702,706,710,716,719,726,
        728,733,737,742,747,754,762,764,771,776,780,786,789,798,803,806,
        812,828,834,837,842,845,852,871,877,880,882,891,895,898,903,908,
        917,925,934,953,956,964,967,971,977,990,994,1001,1005,1008,1019,
        1027,1049,1056,1061,1065,1067,1071,1075,1079,1086,1095,1099,1104,
        1111,1117,1120,1124,1131
    ]

class CParser ( Parser ):

    grammarFileName = "C.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'__extension__'", "'__builtin_va_arg'", 
                     "'__builtin_offsetof'", "'__m128'", "'__m128d'", "'__m128i'", 
                     "'__typeof__'", "'__inline__'", "'__stdcall'", "'__declspec'", 
                     "'__cdecl'", "'__clrcall'", "'__fastcall'", "'__thiscall'", 
                     "'__vectorcall'", "'__asm'", "'__attribute__'", "'__asm__'", 
                     "'__volatile__'", "'auto'", "'break'", "'case'", "'char'", 
                     "'const'", "'continue'", "'default'", "'do'", "'double'", 
                     "'else'", "'enum'", "'extern'", "'float'", "'for'", 
                     "'goto'", "'if'", "'inline'", "'int'", "'long'", "'register'", 
                     "'restrict'", "'return'", "'short'", "'signed'", "'sizeof'", 
                     "'static'", "'struct'", "'switch'", "'typedef'", "'union'", 
                     "'unsigned'", "'void'", "'volatile'", "'while'", "'_Alignas'", 
                     "'_Alignof'", "'_Atomic'", "'_Bool'", "'_Complex'", 
                     "'_Generic'", "'_Imaginary'", "'_Noreturn'", "'_Static_assert'", 
                     "'_Thread_local'", "'('", "')'", "'['", "']'", "'{'", 
                     "'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", 
                     "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", 
                     "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", 
                     "'?'", "':'", "';'", "','", "'='", "'*='", "'/='", 
                     "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", 
                     "'|='", "'=='", "'!='", "'->'", "'.'", "'...'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "Auto", "Break", "Case", "Char", "Const", "Continue", 
                      "Default", "Do", "Double", "Else", "Enum", "Extern", 
                      "Float", "For", "Goto", "If", "Inline", "Int", "Long", 
                      "Register", "Restrict", "Return", "Short", "Signed", 
                      "Sizeof", "Static", "Struct", "Switch", "Typedef", 
                      "Union", "Unsigned", "Void", "Volatile", "While", 
                      "Alignas", "Alignof", "Atomic", "Bool", "Complex", 
                      "Generic", "Imaginary", "Noreturn", "StaticAssert", 
                      "ThreadLocal", "LeftParen", "RightParen", "LeftBracket", 
                      "RightBracket", "LeftBrace", "RightBrace", "Less", 
                      "LessEqual", "Greater", "GreaterEqual", "LeftShift", 
                      "RightShift", "Plus", "PlusPlus", "Minus", "MinusMinus", 
                      "Star", "Div", "Mod", "And", "Or", "AndAnd", "OrOr", 
                      "Caret", "Not", "Tilde", "Question", "Colon", "Semi", 
                      "Comma", "Assign", "StarAssign", "DivAssign", "ModAssign", 
                      "PlusAssign", "MinusAssign", "LeftShiftAssign", "RightShiftAssign", 
                      "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual", 
                      "Arrow", "Dot", "Ellipsis", "Identifier", "Constant", 
                      "DigitSequence", "StringLiteral", "MultiLineMacro", 
                      "Directive", "AsmBlock", "Whitespace", "Newline", 
                      "BlockComment", "LineComment" ]

    RULE_functionCall = 0
    RULE_primaryExpression = 1
    RULE_genericSelection = 2
    RULE_genericAssocList = 3
    RULE_genericAssociation = 4
    RULE_postfixExpression = 5
    RULE_argumentExpressionList = 6
    RULE_unaryExpression = 7
    RULE_unaryOperator = 8
    RULE_castExpression = 9
    RULE_multiplicativeExpression = 10
    RULE_additiveExpression = 11
    RULE_shiftExpression = 12
    RULE_relationalExpression = 13
    RULE_equalityExpression = 14
    RULE_andExpression = 15
    RULE_exclusiveOrExpression = 16
    RULE_inclusiveOrExpression = 17
    RULE_logicalAndExpression = 18
    RULE_logicalOrExpression = 19
    RULE_conditionalExpression = 20
    RULE_assignmentExpression = 21
    RULE_assignmentOperator = 22
    RULE_expression = 23
    RULE_constantExpression = 24
    RULE_declaration = 25
    RULE_declarationSpecifiers = 26
    RULE_declarationSpecifiers2 = 27
    RULE_declarationSpecifier = 28
    RULE_initDeclaratorList = 29
    RULE_initDeclarator = 30
    RULE_storageClassSpecifier = 31
    RULE_typeSpecifier = 32
    RULE_structOrUnionSpecifier = 33
    RULE_structOrUnion = 34
    RULE_structDeclarationList = 35
    RULE_structDeclaration = 36
    RULE_specifierQualifierList = 37
    RULE_structDeclaratorList = 38
    RULE_structDeclarator = 39
    RULE_enumSpecifier = 40
    RULE_enumeratorList = 41
    RULE_enumerator = 42
    RULE_enumerationConstant = 43
    RULE_atomicTypeSpecifier = 44
    RULE_typeQualifier = 45
    RULE_functionSpecifier = 46
    RULE_alignmentSpecifier = 47
    RULE_declarator = 48
    RULE_directDeclarator = 49
    RULE_vcSpecificModifer = 50
    RULE_gccDeclaratorExtension = 51
    RULE_gccAttributeSpecifier = 52
    RULE_gccAttributeList = 53
    RULE_gccAttribute = 54
    RULE_nestedParenthesesBlock = 55
    RULE_pointer = 56
    RULE_typeQualifierList = 57
    RULE_parameterTypeList = 58
    RULE_parameterList = 59
    RULE_parameterDeclaration = 60
    RULE_identifierList = 61
    RULE_typeName = 62
    RULE_abstractDeclarator = 63
    RULE_directAbstractDeclarator = 64
    RULE_typedefName = 65
    RULE_initializer = 66
    RULE_initializerList = 67
    RULE_designation = 68
    RULE_designatorList = 69
    RULE_designator = 70
    RULE_staticAssertDeclaration = 71
    RULE_statement = 72
    RULE_labeledStatement = 73
    RULE_compoundStatement = 74
    RULE_blockItemList = 75
    RULE_blockItem = 76
    RULE_expressionStatement = 77
    RULE_selectionStatement = 78
    RULE_iterationStatement = 79
    RULE_multiLineMacroStatement = 80
    RULE_forCondition = 81
    RULE_forDeclaration = 82
    RULE_forExpression = 83
    RULE_jumpStatement = 84
    RULE_compilationUnit = 85
    RULE_translationUnit = 86
    RULE_externalDeclaration = 87
    RULE_functionDefinition = 88
    RULE_declarationList = 89

    ruleNames =  [ "functionCall", "primaryExpression", "genericSelection", 
                   "genericAssocList", "genericAssociation", "postfixExpression", 
                   "argumentExpressionList", "unaryExpression", "unaryOperator", 
                   "castExpression", "multiplicativeExpression", "additiveExpression", 
                   "shiftExpression", "relationalExpression", "equalityExpression", 
                   "andExpression", "exclusiveOrExpression", "inclusiveOrExpression", 
                   "logicalAndExpression", "logicalOrExpression", "conditionalExpression", 
                   "assignmentExpression", "assignmentOperator", "expression", 
                   "constantExpression", "declaration", "declarationSpecifiers", 
                   "declarationSpecifiers2", "declarationSpecifier", "initDeclaratorList", 
                   "initDeclarator", "storageClassSpecifier", "typeSpecifier", 
                   "structOrUnionSpecifier", "structOrUnion", "structDeclarationList", 
                   "structDeclaration", "specifierQualifierList", "structDeclaratorList", 
                   "structDeclarator", "enumSpecifier", "enumeratorList", 
                   "enumerator", "enumerationConstant", "atomicTypeSpecifier", 
                   "typeQualifier", "functionSpecifier", "alignmentSpecifier", 
                   "declarator", "directDeclarator", "vcSpecificModifer", 
                   "gccDeclaratorExtension", "gccAttributeSpecifier", "gccAttributeList", 
                   "gccAttribute", "nestedParenthesesBlock", "pointer", 
                   "typeQualifierList", "parameterTypeList", "parameterList", 
                   "parameterDeclaration", "identifierList", "typeName", 
                   "abstractDeclarator", "directAbstractDeclarator", "typedefName", 
                   "initializer", "initializerList", "designation", "designatorList", 
                   "designator", "staticAssertDeclaration", "statement", 
                   "labeledStatement", "compoundStatement", "blockItemList", 
                   "blockItem", "expressionStatement", "selectionStatement", 
                   "iterationStatement", "multiLineMacroStatement", "forCondition", 
                   "forDeclaration", "forExpression", "jumpStatement", "compilationUnit", 
                   "translationUnit", "externalDeclaration", "functionDefinition", 
                   "declarationList" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    Auto=20
    Break=21
    Case=22
    Char=23
    Const=24
    Continue=25
    Default=26
    Do=27
    Double=28
    Else=29
    Enum=30
    Extern=31
    Float=32
    For=33
    Goto=34
    If=35
    Inline=36
    Int=37
    Long=38
    Register=39
    Restrict=40
    Return=41
    Short=42
    Signed=43
    Sizeof=44
    Static=45
    Struct=46
    Switch=47
    Typedef=48
    Union=49
    Unsigned=50
    Void=51
    Volatile=52
    While=53
    Alignas=54
    Alignof=55
    Atomic=56
    Bool=57
    Complex=58
    Generic=59
    Imaginary=60
    Noreturn=61
    StaticAssert=62
    ThreadLocal=63
    LeftParen=64
    RightParen=65
    LeftBracket=66
    RightBracket=67
    LeftBrace=68
    RightBrace=69
    Less=70
    LessEqual=71
    Greater=72
    GreaterEqual=73
    LeftShift=74
    RightShift=75
    Plus=76
    PlusPlus=77
    Minus=78
    MinusMinus=79
    Star=80
    Div=81
    Mod=82
    And=83
    Or=84
    AndAnd=85
    OrOr=86
    Caret=87
    Not=88
    Tilde=89
    Question=90
    Colon=91
    Semi=92
    Comma=93
    Assign=94
    StarAssign=95
    DivAssign=96
    ModAssign=97
    PlusAssign=98
    MinusAssign=99
    LeftShiftAssign=100
    RightShiftAssign=101
    AndAssign=102
    XorAssign=103
    OrAssign=104
    Equal=105
    NotEqual=106
    Arrow=107
    Dot=108
    Ellipsis=109
    Identifier=110
    Constant=111
    DigitSequence=112
    StringLiteral=113
    MultiLineMacro=114
    Directive=115
    AsmBlock=116
    Whitespace=117
    Newline=118
    BlockComment=119
    LineComment=120

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




    class FunctionCallContext(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(CParser.Identifier, 0)

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

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


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

        def getRuleIndex(self):
            return CParser.RULE_functionCall

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

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

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




    def functionCall(self):

        localctx = CParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_functionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 180
            self.match(CParser.Identifier)
            self.state = 181
            self.match(CParser.LeftParen)
            self.state = 182
            self.expression()
            self.state = 183
            self.match(CParser.RightParen)
        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 Identifier(self):
            return self.getToken(CParser.Identifier, 0)

        def Constant(self):
            return self.getToken(CParser.Constant, 0)

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

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

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


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

        def genericSelection(self):
            return self.getTypedRuleContext(CParser.GenericSelectionContext,0)


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


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


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

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_primaryExpression)
        self._la = 0 # Token type
        try:
            self.state = 218
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 185
                self.match(CParser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 186
                self.match(CParser.Constant)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 188 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 187
                    self.match(CParser.StringLiteral)
                    self.state = 190 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==113):
                        break

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 192
                self.match(CParser.LeftParen)
                self.state = 193
                self.expression()
                self.state = 194
                self.match(CParser.RightParen)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 196
                self.genericSelection()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 198
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==1:
                    self.state = 197
                    self.match(CParser.T__0)


                self.state = 200
                self.match(CParser.LeftParen)
                self.state = 201
                self.compoundStatement()
                self.state = 202
                self.match(CParser.RightParen)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 204
                self.match(CParser.T__1)
                self.state = 205
                self.match(CParser.LeftParen)
                self.state = 206
                self.unaryExpression()
                self.state = 207
                self.match(CParser.Comma)
                self.state = 208
                self.typeName()
                self.state = 209
                self.match(CParser.RightParen)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 211
                self.match(CParser.T__2)
                self.state = 212
                self.match(CParser.LeftParen)
                self.state = 213
                self.typeName()
                self.state = 214
                self.match(CParser.Comma)
                self.state = 215
                self.unaryExpression()
                self.state = 216
                self.match(CParser.RightParen)
                pass


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


    class GenericSelectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Generic(self):
            return self.getToken(CParser.Generic, 0)

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

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


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

        def genericAssocList(self):
            return self.getTypedRuleContext(CParser.GenericAssocListContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_genericSelection

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

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

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




    def genericSelection(self):

        localctx = CParser.GenericSelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_genericSelection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 220
            self.match(CParser.Generic)
            self.state = 221
            self.match(CParser.LeftParen)
            self.state = 222
            self.assignmentExpression()
            self.state = 223
            self.match(CParser.Comma)
            self.state = 224
            self.genericAssocList()
            self.state = 225
            self.match(CParser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GenericAssocListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def genericAssociation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GenericAssociationContext)
            else:
                return self.getTypedRuleContext(CParser.GenericAssociationContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_genericAssocList

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

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

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




    def genericAssocList(self):

        localctx = CParser.GenericAssocListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_genericAssocList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 227
            self.genericAssociation()
            self.state = 232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 228
                self.match(CParser.Comma)
                self.state = 229
                self.genericAssociation()
                self.state = 234
                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 GenericAssociationContext(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(CParser.Colon, 0)

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


        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_genericAssociation

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

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

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




    def genericAssociation(self):

        localctx = CParser.GenericAssociationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_genericAssociation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 237
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 4, 5, 6, 7, 23, 24, 28, 30, 32, 37, 38, 40, 42, 43, 46, 49, 50, 51, 52, 56, 57, 58, 110]:
                self.state = 235
                self.typeName()
                pass
            elif token in [26]:
                self.state = 236
                self.match(CParser.Default)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 239
            self.match(CParser.Colon)
            self.state = 240
            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 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(CParser.PrimaryExpressionContext,0)


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

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


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

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

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


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

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.ExpressionContext,i)


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

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

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

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

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

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

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

        def argumentExpressionList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.ArgumentExpressionListContext)
            else:
                return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,i)


        def getRuleIndex(self):
            return CParser.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):

        localctx = CParser.PostfixExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_postfixExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 256
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 242
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.state = 244
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==1:
                    self.state = 243
                    self.match(CParser.T__0)


                self.state = 246
                self.match(CParser.LeftParen)
                self.state = 247
                self.typeName()
                self.state = 248
                self.match(CParser.RightParen)
                self.state = 249
                self.match(CParser.LeftBrace)
                self.state = 250
                self.initializerList()
                self.state = 252
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==93:
                    self.state = 251
                    self.match(CParser.Comma)


                self.state = 254
                self.match(CParser.RightBrace)
                pass


            self.state = 273
            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:
                    self.state = 271
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [66]:
                        self.state = 258
                        self.match(CParser.LeftBracket)
                        self.state = 259
                        self.expression()
                        self.state = 260
                        self.match(CParser.RightBracket)
                        pass
                    elif token in [64]:
                        self.state = 262
                        self.match(CParser.LeftParen)
                        self.state = 264
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                            self.state = 263
                            self.argumentExpressionList()


                        self.state = 266
                        self.match(CParser.RightParen)
                        pass
                    elif token in [107, 108]:
                        self.state = 267
                        _la = self._input.LA(1)
                        if not(_la==107 or _la==108):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 268
                        self.match(CParser.Identifier)
                        pass
                    elif token in [77]:
                        self.state = 269
                        self.match(CParser.PlusPlus)
                        pass
                    elif token in [79]:
                        self.state = 270
                        self.match(CParser.MinusMinus)
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 275
                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.exitRule()
        return localctx


    class ArgumentExpressionListContext(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(CParser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.AssignmentExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_argumentExpressionList

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

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

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




    def argumentExpressionList(self):

        localctx = CParser.ArgumentExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_argumentExpressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 276
            self.assignmentExpression()
            self.state = 281
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 277
                self.match(CParser.Comma)
                self.state = 278
                self.assignmentExpression()
                self.state = 283
                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 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(CParser.PostfixExpressionContext,0)


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


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


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

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


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

        def AndAnd(self):
            return self.getToken(CParser.AndAnd, 0)

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

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

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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_unaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 287
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 284
                    _la = self._input.LA(1)
                    if not(((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & 42949672961) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 289
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

            self.state = 301
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 59, 64, 110, 111, 113]:
                self.state = 290
                self.postfixExpression()
                pass
            elif token in [76, 78, 80, 83, 88, 89]:
                self.state = 291
                self.unaryOperator()
                self.state = 292
                self.castExpression()
                pass
            elif token in [44, 55]:
                self.state = 294
                _la = self._input.LA(1)
                if not(_la==44 or _la==55):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 295
                self.match(CParser.LeftParen)
                self.state = 296
                self.typeName()
                self.state = 297
                self.match(CParser.RightParen)
                pass
            elif token in [85]:
                self.state = 299
                self.match(CParser.AndAnd)
                self.state = 300
                self.match(CParser.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 UnaryOperatorContext(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(CParser.And, 0)

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

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

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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 303
            _la = self._input.LA(1)
            if not(((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & 12437) != 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 CastExpressionContext(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(CParser.LeftParen, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


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

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


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


        def DigitSequence(self):
            return self.getToken(CParser.DigitSequence, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_castExpression)
        self._la = 0 # Token type
        try:
            self.state = 315
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 306
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==1:
                    self.state = 305
                    self.match(CParser.T__0)


                self.state = 308
                self.match(CParser.LeftParen)
                self.state = 309
                self.typeName()
                self.state = 310
                self.match(CParser.RightParen)
                self.state = 311
                self.castExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 313
                self.unaryExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 314
                self.match(CParser.DigitSequence)
                pass


        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 castExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.CastExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.CastExpressionContext,i)


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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.castExpression()
            self.state = 322
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & 7) != 0):
                self.state = 318
                _la = self._input.LA(1)
                if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & 7) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 319
                self.castExpression()
                self.state = 324
                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(CParser.MultiplicativeExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.MultiplicativeExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 325
            self.multiplicativeExpression()
            self.state = 330
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==76 or _la==78:
                self.state = 326
                _la = self._input.LA(1)
                if not(_la==76 or _la==78):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 327
                self.multiplicativeExpression()
                self.state = 332
                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(CParser.AdditiveExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.AdditiveExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.ShiftExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_shiftExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            self.additiveExpression()
            self.state = 338
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==74 or _la==75:
                self.state = 334
                _la = self._input.LA(1)
                if not(_la==74 or _la==75):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 335
                self.additiveExpression()
                self.state = 340
                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 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(CParser.ShiftExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.ShiftExpressionContext,i)


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

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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.RelationalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 341
            self.shiftExpression()
            self.state = 346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 15) != 0):
                self.state = 342
                _la = self._input.LA(1)
                if not(((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 15) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 343
                self.shiftExpression()
                self.state = 348
                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 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(CParser.RelationalExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.RelationalExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.EqualityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 349
            self.relationalExpression()
            self.state = 354
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==105 or _la==106:
                self.state = 350
                _la = self._input.LA(1)
                if not(_la==105 or _la==106):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 351
                self.relationalExpression()
                self.state = 356
                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(CParser.EqualityExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.EqualityExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 357
            self.equalityExpression()
            self.state = 362
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==83:
                self.state = 358
                self.match(CParser.And)
                self.state = 359
                self.equalityExpression()
                self.state = 364
                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(CParser.AndExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.AndExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.ExclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_exclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 365
            self.andExpression()
            self.state = 370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==87:
                self.state = 366
                self.match(CParser.Caret)
                self.state = 367
                self.andExpression()
                self.state = 372
                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(CParser.ExclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.InclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_inclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            self.exclusiveOrExpression()
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==84:
                self.state = 374
                self.match(CParser.Or)
                self.state = 375
                self.exclusiveOrExpression()
                self.state = 380
                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(CParser.InclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.LogicalAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_logicalAndExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 381
            self.inclusiveOrExpression()
            self.state = 386
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==85:
                self.state = 382
                self.match(CParser.AndAnd)
                self.state = 383
                self.inclusiveOrExpression()
                self.state = 388
                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(CParser.LogicalAndExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.LogicalOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_logicalOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 389
            self.logicalAndExpression()
            self.state = 394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==86:
                self.state = 390
                self.match(CParser.OrOr)
                self.state = 391
                self.logicalAndExpression()
                self.state = 396
                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(CParser.LogicalOrExpressionContext,0)


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

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


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

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


        def getRuleIndex(self):
            return CParser.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 = CParser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 397
            self.logicalOrExpression()
            self.state = 403
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==90:
                self.state = 398
                self.match(CParser.Question)
                self.state = 399
                self.expression()
                self.state = 400
                self.match(CParser.Colon)
                self.state = 401
                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 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(CParser.ConditionalExpressionContext,0)


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


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


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


        def DigitSequence(self):
            return self.getToken(CParser.DigitSequence, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.AssignmentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_assignmentExpression)
        try:
            self.state = 411
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 405
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 406
                self.unaryExpression()
                self.state = 407
                self.assignmentOperator()
                self.state = 408
                self.assignmentExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 410
                self.match(CParser.DigitSequence)
                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(CParser.Assign, 0)

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 413
            _la = self._input.LA(1)
            if not(((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & 2047) != 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(CParser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.AssignmentExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            self.assignmentExpression()
            self.state = 420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 416
                self.match(CParser.Comma)
                self.state = 417
                self.assignmentExpression()
                self.state = 422
                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(CParser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 423
            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 DeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def declarationSpecifiers(self):
            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)


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

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


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


        def getRuleIndex(self):
            return CParser.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 = CParser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_declaration)
        self._la = 0 # Token type
        try:
            self.state = 432
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 4, 5, 6, 7, 8, 9, 10, 17, 20, 23, 24, 28, 30, 31, 32, 36, 37, 38, 39, 40, 42, 43, 45, 46, 48, 49, 50, 51, 52, 54, 56, 57, 58, 61, 63, 110]:
                self.enterOuterAlt(localctx, 1)
                self.state = 425
                self.declarationSpecifiers()
                self.state = 427
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 64000) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 70368752631809) != 0):
                    self.state = 426
                    self.initDeclaratorList()


                self.state = 429
                self.match(CParser.Semi)
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 2)
                self.state = 431
                self.staticAssertDeclaration()
                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 DeclarationSpecifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def declarationSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext)
            else:
                return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i)


        def getRuleIndex(self):
            return CParser.RULE_declarationSpecifiers

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

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

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




    def declarationSpecifiers(self):

        localctx = CParser.DeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_declarationSpecifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 435 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 434
                    self.declarationSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 437 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,31,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 DeclarationSpecifiers2Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def declarationSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext)
            else:
                return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i)


        def getRuleIndex(self):
            return CParser.RULE_declarationSpecifiers2

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

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

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




    def declarationSpecifiers2(self):

        localctx = CParser.DeclarationSpecifiers2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_declarationSpecifiers2)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 440 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 439
                self.declarationSpecifier()
                self.state = 442 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -6386264861217519630) != 0) or _la==110):
                    break

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


    class DeclarationSpecifierContext(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(CParser.StorageClassSpecifierContext,0)


        def typeSpecifier(self):
            return self.getTypedRuleContext(CParser.TypeSpecifierContext,0)


        def typeQualifier(self):
            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)


        def functionSpecifier(self):
            return self.getTypedRuleContext(CParser.FunctionSpecifierContext,0)


        def alignmentSpecifier(self):
            return self.getTypedRuleContext(CParser.AlignmentSpecifierContext,0)


        def getRuleIndex(self):
            return CParser.RULE_declarationSpecifier

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

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

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




    def declarationSpecifier(self):

        localctx = CParser.DeclarationSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_declarationSpecifier)
        try:
            self.state = 449
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 444
                self.storageClassSpecifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 445
                self.typeSpecifier()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 446
                self.typeQualifier()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 447
                self.functionSpecifier()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 448
                self.alignmentSpecifier()
                pass


        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(CParser.InitDeclaratorContext)
            else:
                return self.getTypedRuleContext(CParser.InitDeclaratorContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self.initDeclarator()
            self.state = 456
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 452
                self.match(CParser.Comma)
                self.state = 453
                self.initDeclarator()
                self.state = 458
                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(CParser.DeclaratorContext,0)


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

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


        def getRuleIndex(self):
            return CParser.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 = CParser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.declarator()
            self.state = 462
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==94:
                self.state = 460
                self.match(CParser.Assign)
                self.state = 461
                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 StorageClassSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Typedef(self):
            return self.getToken(CParser.Typedef, 0)

        def Extern(self):
            return self.getToken(CParser.Extern, 0)

        def Static(self):
            return self.getToken(CParser.Static, 0)

        def ThreadLocal(self):
            return self.getToken(CParser.ThreadLocal, 0)

        def Auto(self):
            return self.getToken(CParser.Auto, 0)

        def Register(self):
            return self.getToken(CParser.Register, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.StorageClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_storageClassSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 464
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & -9223054825601630208) != 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 TypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Void(self):
            return self.getToken(CParser.Void, 0)

        def Char(self):
            return self.getToken(CParser.Char, 0)

        def Short(self):
            return self.getToken(CParser.Short, 0)

        def Int(self):
            return self.getToken(CParser.Int, 0)

        def Long(self):
            return self.getToken(CParser.Long, 0)

        def Float(self):
            return self.getToken(CParser.Float, 0)

        def Double(self):
            return self.getToken(CParser.Double, 0)

        def Signed(self):
            return self.getToken(CParser.Signed, 0)

        def Unsigned(self):
            return self.getToken(CParser.Unsigned, 0)

        def Bool(self):
            return self.getToken(CParser.Bool, 0)

        def Complex(self):
            return self.getToken(CParser.Complex, 0)

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

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

        def atomicTypeSpecifier(self):
            return self.getTypedRuleContext(CParser.AtomicTypeSpecifierContext,0)


        def structOrUnionSpecifier(self):
            return self.getTypedRuleContext(CParser.StructOrUnionSpecifierContext,0)


        def enumSpecifier(self):
            return self.getTypedRuleContext(CParser.EnumSpecifierContext,0)


        def typedefName(self):
            return self.getTypedRuleContext(CParser.TypedefNameContext,0)


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


        def getRuleIndex(self):
            return CParser.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 = CParser.TypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_typeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 493
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [51]:
                self.enterOuterAlt(localctx, 1)
                self.state = 466
                self.match(CParser.Void)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 2)
                self.state = 467
                self.match(CParser.Char)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 3)
                self.state = 468
                self.match(CParser.Short)
                pass
            elif token in [37]:
                self.enterOuterAlt(localctx, 4)
                self.state = 469
                self.match(CParser.Int)
                pass
            elif token in [38]:
                self.enterOuterAlt(localctx, 5)
                self.state = 470
                self.match(CParser.Long)
                pass
            elif token in [32]:
                self.enterOuterAlt(localctx, 6)
                self.state = 471
                self.match(CParser.Float)
                pass
            elif token in [28]:
                self.enterOuterAlt(localctx, 7)
                self.state = 472
                self.match(CParser.Double)
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 8)
                self.state = 473
                self.match(CParser.Signed)
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 9)
                self.state = 474
                self.match(CParser.Unsigned)
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 10)
                self.state = 475
                self.match(CParser.Bool)
                pass
            elif token in [58]:
                self.enterOuterAlt(localctx, 11)
                self.state = 476
                self.match(CParser.Complex)
                pass
            elif token in [4]:
                self.enterOuterAlt(localctx, 12)
                self.state = 477
                self.match(CParser.T__3)
                pass
            elif token in [5]:
                self.enterOuterAlt(localctx, 13)
                self.state = 478
                self.match(CParser.T__4)
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 14)
                self.state = 479
                self.match(CParser.T__5)
                pass
            elif token in [1]:
                self.enterOuterAlt(localctx, 15)
                self.state = 480
                self.match(CParser.T__0)
                self.state = 481
                self.match(CParser.LeftParen)
                self.state = 482
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 112) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 483
                self.match(CParser.RightParen)
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 16)
                self.state = 484
                self.atomicTypeSpecifier()
                pass
            elif token in [46, 49]:
                self.enterOuterAlt(localctx, 17)
                self.state = 485
                self.structOrUnionSpecifier()
                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 18)
                self.state = 486
                self.enumSpecifier()
                pass
            elif token in [110]:
                self.enterOuterAlt(localctx, 19)
                self.state = 487
                self.typedefName()
                pass
            elif token in [7]:
                self.enterOuterAlt(localctx, 20)
                self.state = 488
                self.match(CParser.T__6)
                self.state = 489
                self.match(CParser.LeftParen)
                self.state = 490
                self.constantExpression()
                self.state = 491
                self.match(CParser.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 StructOrUnionSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def structOrUnion(self):
            return self.getTypedRuleContext(CParser.StructOrUnionContext,0)


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

        def structDeclarationList(self):
            return self.getTypedRuleContext(CParser.StructDeclarationListContext,0)


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

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

        def getRuleIndex(self):
            return CParser.RULE_structOrUnionSpecifier

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

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

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




    def structOrUnionSpecifier(self):

        localctx = CParser.StructOrUnionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_structOrUnionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 495
                self.structOrUnion()
                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==110:
                    self.state = 496
                    self.match(CParser.Identifier)


                self.state = 499
                self.match(CParser.LeftBrace)
                self.state = 500
                self.structDeclarationList()
                self.state = 501
                self.match(CParser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 503
                self.structOrUnion()
                self.state = 504
                self.match(CParser.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 StructOrUnionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Struct(self):
            return self.getToken(CParser.Struct, 0)

        def Union(self):
            return self.getToken(CParser.Union, 0)

        def getRuleIndex(self):
            return CParser.RULE_structOrUnion

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

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

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




    def structOrUnion(self):

        localctx = CParser.StructOrUnionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_structOrUnion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 508
            _la = self._input.LA(1)
            if not(_la==46 or _la==49):
                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 StructDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def structDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.StructDeclarationContext)
            else:
                return self.getTypedRuleContext(CParser.StructDeclarationContext,i)


        def getRuleIndex(self):
            return CParser.RULE_structDeclarationList

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

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

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




    def structDeclarationList(self):

        localctx = CParser.StructDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_structDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 510
                self.structDeclaration()
                self.state = 513 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 5124618506368712946) != 0) or _la==110):
                    break

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


    class StructDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def specifierQualifierList(self):
            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)


        def structDeclaratorList(self):
            return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0)


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

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


        def getRuleIndex(self):
            return CParser.RULE_structDeclaration

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

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

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




    def structDeclaration(self):

        localctx = CParser.StructDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_structDeclaration)
        try:
            self.state = 523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 515
                self.specifierQualifierList()
                self.state = 516
                self.structDeclaratorList()
                self.state = 517
                self.match(CParser.Semi)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 519
                self.specifierQualifierList()
                self.state = 520
                self.match(CParser.Semi)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 522
                self.staticAssertDeclaration()
                pass


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


    class SpecifierQualifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeSpecifier(self):
            return self.getTypedRuleContext(CParser.TypeSpecifierContext,0)


        def typeQualifier(self):
            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)


        def specifierQualifierList(self):
            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_specifierQualifierList

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

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

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




    def specifierQualifierList(self):

        localctx = CParser.SpecifierQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_specifierQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
            if la_ == 1:
                self.state = 525
                self.typeSpecifier()
                pass

            elif la_ == 2:
                self.state = 526
                self.typeQualifier()
                pass


            self.state = 530
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 529
                self.specifierQualifierList()


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


    class StructDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def structDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.StructDeclaratorContext)
            else:
                return self.getTypedRuleContext(CParser.StructDeclaratorContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_structDeclaratorList

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

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

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




    def structDeclaratorList(self):

        localctx = CParser.StructDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_structDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 532
            self.structDeclarator()
            self.state = 537
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 533
                self.match(CParser.Comma)
                self.state = 534
                self.structDeclarator()
                self.state = 539
                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 StructDeclaratorContext(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(CParser.DeclaratorContext,0)


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

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


        def getRuleIndex(self):
            return CParser.RULE_structDeclarator

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

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

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




    def structDeclarator(self):

        localctx = CParser.StructDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_structDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 546
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 540
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 542
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 64000) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 70368752631809) != 0):
                    self.state = 541
                    self.declarator()


                self.state = 544
                self.match(CParser.Colon)
                self.state = 545
                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 EnumSpecifierContext(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(CParser.Enum, 0)

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

        def enumeratorList(self):
            return self.getTypedRuleContext(CParser.EnumeratorListContext,0)


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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 561
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 548
                self.match(CParser.Enum)
                self.state = 550
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==110:
                    self.state = 549
                    self.match(CParser.Identifier)


                self.state = 552
                self.match(CParser.LeftBrace)
                self.state = 553
                self.enumeratorList()
                self.state = 555
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==93:
                    self.state = 554
                    self.match(CParser.Comma)


                self.state = 557
                self.match(CParser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 559
                self.match(CParser.Enum)
                self.state = 560
                self.match(CParser.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 EnumeratorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enumerator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.EnumeratorContext)
            else:
                return self.getTypedRuleContext(CParser.EnumeratorContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.EnumeratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_enumeratorList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 563
            self.enumerator()
            self.state = 568
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,49,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 564
                    self.match(CParser.Comma)
                    self.state = 565
                    self.enumerator() 
                self.state = 570
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,49,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 EnumeratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enumerationConstant(self):
            return self.getTypedRuleContext(CParser.EnumerationConstantContext,0)


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

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


        def getRuleIndex(self):
            return CParser.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 = CParser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_enumerator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 571
            self.enumerationConstant()
            self.state = 574
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==94:
                self.state = 572
                self.match(CParser.Assign)
                self.state = 573
                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 EnumerationConstantContext(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(CParser.Identifier, 0)

        def getRuleIndex(self):
            return CParser.RULE_enumerationConstant

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

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

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




    def enumerationConstant(self):

        localctx = CParser.EnumerationConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_enumerationConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(CParser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtomicTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Atomic(self):
            return self.getToken(CParser.Atomic, 0)

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

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_atomicTypeSpecifier

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

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

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




    def atomicTypeSpecifier(self):

        localctx = CParser.AtomicTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_atomicTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            self.match(CParser.Atomic)
            self.state = 579
            self.match(CParser.LeftParen)
            self.state = 580
            self.typeName()
            self.state = 581
            self.match(CParser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeQualifierContext(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(CParser.Const, 0)

        def Restrict(self):
            return self.getToken(CParser.Restrict, 0)

        def Volatile(self):
            return self.getToken(CParser.Volatile, 0)

        def Atomic(self):
            return self.getToken(CParser.Atomic, 0)

        def getRuleIndex(self):
            return CParser.RULE_typeQualifier

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

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

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




    def typeQualifier(self):

        localctx = CParser.TypeQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_typeQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 583
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 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(CParser.Inline, 0)

        def Noreturn(self):
            return self.getToken(CParser.Noreturn, 0)

        def gccAttributeSpecifier(self):
            return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0)


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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.FunctionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_functionSpecifier)
        try:
            self.state = 594
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [36]:
                self.enterOuterAlt(localctx, 1)
                self.state = 585
                self.match(CParser.Inline)
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 2)
                self.state = 586
                self.match(CParser.Noreturn)
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 3)
                self.state = 587
                self.match(CParser.T__7)
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 4)
                self.state = 588
                self.match(CParser.T__8)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 5)
                self.state = 589
                self.gccAttributeSpecifier()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 6)
                self.state = 590
                self.match(CParser.T__9)
                self.state = 591
                self.match(CParser.LeftParen)
                self.state = 592
                self.match(CParser.Identifier)
                self.state = 593
                self.match(CParser.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 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(CParser.Alignas, 0)

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

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

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


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


        def getRuleIndex(self):
            return CParser.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 = CParser.AlignmentSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_alignmentSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 596
            self.match(CParser.Alignas)
            self.state = 597
            self.match(CParser.LeftParen)
            self.state = 600
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 598
                self.typeName()
                pass

            elif la_ == 2:
                self.state = 599
                self.constantExpression()
                pass


            self.state = 602
            self.match(CParser.RightParen)
        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 directDeclarator(self):
            return self.getTypedRuleContext(CParser.DirectDeclaratorContext,0)


        def pointer(self):
            return self.getTypedRuleContext(CParser.PointerContext,0)


        def gccDeclaratorExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
            else:
                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)


        def getRuleIndex(self):
            return CParser.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 = CParser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==80 or _la==87:
                self.state = 604
                self.pointer()


            self.state = 607
            self.directDeclarator(0)
            self.state = 611
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,54,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 608
                    self.gccDeclaratorExtension() 
                self.state = 613
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,54,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 DirectDeclaratorContext(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(CParser.Identifier, 0)

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

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


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

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

        def DigitSequence(self):
            return self.getToken(CParser.DigitSequence, 0)

        def vcSpecificModifer(self):
            return self.getTypedRuleContext(CParser.VcSpecificModiferContext,0)


        def directDeclarator(self):
            return self.getTypedRuleContext(CParser.DirectDeclaratorContext,0)


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

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

        def typeQualifierList(self):
            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)


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


        def Static(self):
            return self.getToken(CParser.Static, 0)

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

        def parameterTypeList(self):
            return self.getTypedRuleContext(CParser.ParameterTypeListContext,0)


        def identifierList(self):
            return self.getTypedRuleContext(CParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_directDeclarator

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

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

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



    def directDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.DirectDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 98
        self.enterRecursionRule(localctx, 98, self.RULE_directDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 615
                self.match(CParser.Identifier)
                pass

            elif la_ == 2:
                self.state = 616
                self.match(CParser.LeftParen)
                self.state = 617
                self.declarator()
                self.state = 618
                self.match(CParser.RightParen)
                pass

            elif la_ == 3:
                self.state = 620
                self.match(CParser.Identifier)
                self.state = 621
                self.match(CParser.Colon)
                self.state = 622
                self.match(CParser.DigitSequence)
                pass

            elif la_ == 4:
                self.state = 623
                self.vcSpecificModifer()
                self.state = 624
                self.match(CParser.Identifier)
                pass

            elif la_ == 5:
                self.state = 626
                self.match(CParser.LeftParen)
                self.state = 627
                self.vcSpecificModifer()
                self.state = 628
                self.declarator()
                self.state = 629
                self.match(CParser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 678
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,62,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 = 676
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                    if la_ == 1:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 633
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 634
                        self.match(CParser.LeftBracket)
                        self.state = 636
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                            self.state = 635
                            self.typeQualifierList()


                        self.state = 639
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                            self.state = 638
                            self.assignmentExpression()


                        self.state = 641
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 642
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 643
                        self.match(CParser.LeftBracket)
                        self.state = 644
                        self.match(CParser.Static)
                        self.state = 646
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                            self.state = 645
                            self.typeQualifierList()


                        self.state = 648
                        self.assignmentExpression()
                        self.state = 649
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 3:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 651
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 652
                        self.match(CParser.LeftBracket)
                        self.state = 653
                        self.typeQualifierList()
                        self.state = 654
                        self.match(CParser.Static)
                        self.state = 655
                        self.assignmentExpression()
                        self.state = 656
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 4:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 658
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 659
                        self.match(CParser.LeftBracket)
                        self.state = 661
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                            self.state = 660
                            self.typeQualifierList()


                        self.state = 663
                        self.match(CParser.Star)
                        self.state = 664
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 5:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 665
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 666
                        self.match(CParser.LeftParen)
                        self.state = 667
                        self.parameterTypeList()
                        self.state = 668
                        self.match(CParser.RightParen)
                        pass

                    elif la_ == 6:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 670
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 671
                        self.match(CParser.LeftParen)
                        self.state = 673
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==110:
                            self.state = 672
                            self.identifierList()


                        self.state = 675
                        self.match(CParser.RightParen)
                        pass

             
                self.state = 680
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,62,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 VcSpecificModiferContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CParser.RULE_vcSpecificModifer

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

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

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




    def vcSpecificModifer(self):

        localctx = CParser.VcSpecificModiferContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_vcSpecificModifer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 681
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 64000) != 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 GccDeclaratorExtensionContext(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(CParser.LeftParen, 0)

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

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

        def gccAttributeSpecifier(self):
            return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0)


        def getRuleIndex(self):
            return CParser.RULE_gccDeclaratorExtension

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

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

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




    def gccDeclaratorExtension(self):

        localctx = CParser.GccDeclaratorExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_gccDeclaratorExtension)
        self._la = 0 # Token type
        try:
            self.state = 692
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [16]:
                self.enterOuterAlt(localctx, 1)
                self.state = 683
                self.match(CParser.T__15)
                self.state = 684
                self.match(CParser.LeftParen)
                self.state = 686 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 685
                    self.match(CParser.StringLiteral)
                    self.state = 688 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==113):
                        break

                self.state = 690
                self.match(CParser.RightParen)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 2)
                self.state = 691
                self.gccAttributeSpecifier()
                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 GccAttributeSpecifierContext(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(CParser.LeftParen)
            else:
                return self.getToken(CParser.LeftParen, i)

        def gccAttributeList(self):
            return self.getTypedRuleContext(CParser.GccAttributeListContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_gccAttributeSpecifier

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

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

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




    def gccAttributeSpecifier(self):

        localctx = CParser.GccAttributeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_gccAttributeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 694
            self.match(CParser.T__16)
            self.state = 695
            self.match(CParser.LeftParen)
            self.state = 696
            self.match(CParser.LeftParen)
            self.state = 697
            self.gccAttributeList()
            self.state = 698
            self.match(CParser.RightParen)
            self.state = 699
            self.match(CParser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GccAttributeListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def gccAttribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccAttributeContext)
            else:
                return self.getTypedRuleContext(CParser.GccAttributeContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_gccAttributeList

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

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

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




    def gccAttributeList(self):

        localctx = CParser.GccAttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_gccAttributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 702
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 36028796884746239) != 0):
                self.state = 701
                self.gccAttribute()


            self.state = 710
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 704
                self.match(CParser.Comma)
                self.state = 706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 36028796884746239) != 0):
                    self.state = 705
                    self.gccAttribute()


                self.state = 712
                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 GccAttributeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def argumentExpressionList(self):
            return self.getTypedRuleContext(CParser.ArgumentExpressionListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_gccAttribute

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

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

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




    def gccAttribute(self):

        localctx = CParser.GccAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_gccAttribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 713
            _la = self._input.LA(1)
            if _la <= 0 or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 536870915) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 719
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==64:
                self.state = 714
                self.match(CParser.LeftParen)
                self.state = 716
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                    self.state = 715
                    self.argumentExpressionList()


                self.state = 718
                self.match(CParser.RightParen)


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


    class NestedParenthesesBlockContext(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(CParser.LeftParen)
            else:
                return self.getToken(CParser.LeftParen, i)

        def nestedParenthesesBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.NestedParenthesesBlockContext)
            else:
                return self.getTypedRuleContext(CParser.NestedParenthesesBlockContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_nestedParenthesesBlock

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

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

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




    def nestedParenthesesBlock(self):

        localctx = CParser.NestedParenthesesBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_nestedParenthesesBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 144115188075855869) != 0):
                self.state = 726
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if 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, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 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]:
                    self.state = 721
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==64 or _la==65:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                elif token in [64]:
                    self.state = 722
                    self.match(CParser.LeftParen)
                    self.state = 723
                    self.nestedParenthesesBlock()
                    self.state = 724
                    self.match(CParser.RightParen)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 730
                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 PointerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def typeQualifierList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.TypeQualifierListContext)
            else:
                return self.getTypedRuleContext(CParser.TypeQualifierListContext,i)


        def getRuleIndex(self):
            return CParser.RULE_pointer

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

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

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




    def pointer(self):

        localctx = CParser.PointerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_pointer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 735 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 731
                _la = self._input.LA(1)
                if not(_la==80 or _la==87):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 733
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                    self.state = 732
                    self.typeQualifierList()


                self.state = 737 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==80 or _la==87):
                    break

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


    class TypeQualifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeQualifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.TypeQualifierContext)
            else:
                return self.getTypedRuleContext(CParser.TypeQualifierContext,i)


        def getRuleIndex(self):
            return CParser.RULE_typeQualifierList

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

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

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




    def typeQualifierList(self):

        localctx = CParser.TypeQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_typeQualifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 740 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 739
                self.typeQualifier()
                self.state = 742 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 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 ParameterTypeListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameterList(self):
            return self.getTypedRuleContext(CParser.ParameterListContext,0)


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

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

        def getRuleIndex(self):
            return CParser.RULE_parameterTypeList

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

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

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




    def parameterTypeList(self):

        localctx = CParser.ParameterTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_parameterTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.parameterList()
            self.state = 747
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==93:
                self.state = 745
                self.match(CParser.Comma)
                self.state = 746
                self.match(CParser.Ellipsis)


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


    class ParameterListContext(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(CParser.ParameterDeclarationContext)
            else:
                return self.getTypedRuleContext(CParser.ParameterDeclarationContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_parameterList

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

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

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




    def parameterList(self):

        localctx = CParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_parameterList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 749
            self.parameterDeclaration()
            self.state = 754
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 750
                    self.match(CParser.Comma)
                    self.state = 751
                    self.parameterDeclaration() 
                self.state = 756
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,76,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 declarationSpecifiers(self):
            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)


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


        def declarationSpecifiers2(self):
            return self.getTypedRuleContext(CParser.DeclarationSpecifiers2Context,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_parameterDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 764
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 757
                self.declarationSpecifiers()
                self.state = 758
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 760
                self.declarationSpecifiers2()
                self.state = 762
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 8454149) != 0):
                    self.state = 761
                    self.abstractDeclarator()


                pass


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


    class IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return CParser.RULE_identifierList

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

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

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




    def identifierList(self):

        localctx = CParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 766
            self.match(CParser.Identifier)
            self.state = 771
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 767
                self.match(CParser.Comma)
                self.state = 768
                self.match(CParser.Identifier)
                self.state = 773
                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 TypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def specifierQualifierList(self):
            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CParser.RULE_typeName

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

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

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




    def typeName(self):

        localctx = CParser.TypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_typeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 774
            self.specifierQualifierList()
            self.state = 776
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 8454149) != 0):
                self.state = 775
                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 pointer(self):
            return self.getTypedRuleContext(CParser.PointerContext,0)


        def directAbstractDeclarator(self):
            return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0)


        def gccDeclaratorExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
            else:
                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)


        def getRuleIndex(self):
            return CParser.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 = CParser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_abstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 789
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 778
                self.pointer()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 780
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==80 or _la==87:
                    self.state = 779
                    self.pointer()


                self.state = 782
                self.directAbstractDeclarator(0)
                self.state = 786
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==16 or _la==17:
                    self.state = 783
                    self.gccDeclaratorExtension()
                    self.state = 788
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


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


    class DirectAbstractDeclaratorContext(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(CParser.LeftParen, 0)

        def abstractDeclarator(self):
            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)


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

        def gccDeclaratorExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
            else:
                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)


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

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

        def typeQualifierList(self):
            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)


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


        def Static(self):
            return self.getToken(CParser.Static, 0)

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

        def parameterTypeList(self):
            return self.getTypedRuleContext(CParser.ParameterTypeListContext,0)


        def directAbstractDeclarator(self):
            return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CParser.RULE_directAbstractDeclarator

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

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

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



    def directAbstractDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.DirectAbstractDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 128
        self.enterRecursionRule(localctx, 128, self.RULE_directAbstractDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 837
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.state = 792
                self.match(CParser.LeftParen)
                self.state = 793
                self.abstractDeclarator()
                self.state = 794
                self.match(CParser.RightParen)
                self.state = 798
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,84,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 795
                        self.gccDeclaratorExtension() 
                    self.state = 800
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,84,self._ctx)

                pass

            elif la_ == 2:
                self.state = 801
                self.match(CParser.LeftBracket)
                self.state = 803
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                    self.state = 802
                    self.typeQualifierList()


                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                    self.state = 805
                    self.assignmentExpression()


                self.state = 808
                self.match(CParser.RightBracket)
                pass

            elif la_ == 3:
                self.state = 809
                self.match(CParser.LeftBracket)
                self.state = 810
                self.match(CParser.Static)
                self.state = 812
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                    self.state = 811
                    self.typeQualifierList()


                self.state = 814
                self.assignmentExpression()
                self.state = 815
                self.match(CParser.RightBracket)
                pass

            elif la_ == 4:
                self.state = 817
                self.match(CParser.LeftBracket)
                self.state = 818
                self.typeQualifierList()
                self.state = 819
                self.match(CParser.Static)
                self.state = 820
                self.assignmentExpression()
                self.state = 821
                self.match(CParser.RightBracket)
                pass

            elif la_ == 5:
                self.state = 823
                self.match(CParser.LeftBracket)
                self.state = 824
                self.match(CParser.Star)
                self.state = 825
                self.match(CParser.RightBracket)
                pass

            elif la_ == 6:
                self.state = 826
                self.match(CParser.LeftParen)
                self.state = 828
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -6386264861217519630) != 0) or _la==110:
                    self.state = 827
                    self.parameterTypeList()


                self.state = 830
                self.match(CParser.RightParen)
                self.state = 834
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,89,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 831
                        self.gccDeclaratorExtension() 
                    self.state = 836
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,89,self._ctx)

                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 882
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,97,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 = 880
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
                    if la_ == 1:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 839
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 840
                        self.match(CParser.LeftBracket)
                        self.state = 842
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                            self.state = 841
                            self.typeQualifierList()


                        self.state = 845
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                            self.state = 844
                            self.assignmentExpression()


                        self.state = 847
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 848
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 849
                        self.match(CParser.LeftBracket)
                        self.state = 850
                        self.match(CParser.Static)
                        self.state = 852
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 76562293193703424) != 0):
                            self.state = 851
                            self.typeQualifierList()


                        self.state = 854
                        self.assignmentExpression()
                        self.state = 855
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 3:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 857
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 858
                        self.match(CParser.LeftBracket)
                        self.state = 859
                        self.typeQualifierList()
                        self.state = 860
                        self.match(CParser.Static)
                        self.state = 861
                        self.assignmentExpression()
                        self.state = 862
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 4:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 864
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 865
                        self.match(CParser.LeftBracket)
                        self.state = 866
                        self.match(CParser.Star)
                        self.state = 867
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 5:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 868
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 869
                        self.match(CParser.LeftParen)
                        self.state = 871
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & -6386264861217519630) != 0) or _la==110:
                            self.state = 870
                            self.parameterTypeList()


                        self.state = 873
                        self.match(CParser.RightParen)
                        self.state = 877
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,95,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 874
                                self.gccDeclaratorExtension() 
                            self.state = 879
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,95,self._ctx)

                        pass

             
                self.state = 884
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,97,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 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(CParser.Identifier, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.TypedefNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 885
            self.match(CParser.Identifier)
        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 assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


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

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


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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_initializer)
        self._la = 0 # Token type
        try:
            self.state = 895
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 44, 55, 59, 64, 76, 77, 78, 79, 80, 83, 85, 88, 89, 110, 111, 112, 113]:
                self.enterOuterAlt(localctx, 1)
                self.state = 887
                self.assignmentExpression()
                pass
            elif token in [68]:
                self.enterOuterAlt(localctx, 2)
                self.state = 888
                self.match(CParser.LeftBrace)
                self.state = 889
                self.initializerList()
                self.state = 891
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==93:
                    self.state = 890
                    self.match(CParser.Comma)


                self.state = 893
                self.match(CParser.RightBrace)
                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 initializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.InitializerContext)
            else:
                return self.getTypedRuleContext(CParser.InitializerContext,i)


        def designation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.DesignationContext)
            else:
                return self.getTypedRuleContext(CParser.DesignationContext,i)


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

        def getRuleIndex(self):
            return CParser.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 = CParser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 898
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==66 or _la==108:
                self.state = 897
                self.designation()


            self.state = 900
            self.initializer()
            self.state = 908
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,102,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 901
                    self.match(CParser.Comma)
                    self.state = 903
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==66 or _la==108:
                        self.state = 902
                        self.designation()


                    self.state = 905
                    self.initializer() 
                self.state = 910
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,102,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 DesignationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def designatorList(self):
            return self.getTypedRuleContext(CParser.DesignatorListContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_designation

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

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

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




    def designation(self):

        localctx = CParser.DesignationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_designation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 911
            self.designatorList()
            self.state = 912
            self.match(CParser.Assign)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DesignatorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def designator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.DesignatorContext)
            else:
                return self.getTypedRuleContext(CParser.DesignatorContext,i)


        def getRuleIndex(self):
            return CParser.RULE_designatorList

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

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

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




    def designatorList(self):

        localctx = CParser.DesignatorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_designatorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 915 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 914
                self.designator()
                self.state = 917 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==66 or _la==108):
                    break

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


    class DesignatorContext(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(CParser.LeftBracket, 0)

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


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

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

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

        def getRuleIndex(self):
            return CParser.RULE_designator

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

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

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




    def designator(self):

        localctx = CParser.DesignatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_designator)
        try:
            self.state = 925
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [66]:
                self.enterOuterAlt(localctx, 1)
                self.state = 919
                self.match(CParser.LeftBracket)
                self.state = 920
                self.constantExpression()
                self.state = 921
                self.match(CParser.RightBracket)
                pass
            elif token in [108]:
                self.enterOuterAlt(localctx, 2)
                self.state = 923
                self.match(CParser.Dot)
                self.state = 924
                self.match(CParser.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 StaticAssertDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def StaticAssert(self):
            return self.getToken(CParser.StaticAssert, 0)

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

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


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

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

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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.StaticAssertDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_staticAssertDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 927
            self.match(CParser.StaticAssert)
            self.state = 928
            self.match(CParser.LeftParen)
            self.state = 929
            self.constantExpression()
            self.state = 930
            self.match(CParser.Comma)
            self.state = 932 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 931
                self.match(CParser.StringLiteral)
                self.state = 934 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==113):
                    break

            self.state = 936
            self.match(CParser.RightParen)
            self.state = 937
            self.match(CParser.Semi)
        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(CParser.LabeledStatementContext,0)


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


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


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


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


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


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

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

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

        def Volatile(self):
            return self.getToken(CParser.Volatile, 0)

        def logicalOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.LogicalOrExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,i)


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

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

        def multiLineMacroStatement(self):
            return self.getTypedRuleContext(CParser.MultiLineMacroStatementContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 977
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 939
                self.labeledStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 940
                self.compoundStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 941
                self.expressionStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 942
                self.selectionStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 943
                self.iterationStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 944
                self.jumpStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 945
                _la = self._input.LA(1)
                if not(_la==16 or _la==18):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 946
                _la = self._input.LA(1)
                if not(_la==19 or _la==52):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 947
                self.match(CParser.LeftParen)
                self.state = 956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                    self.state = 948
                    self.logicalOrExpression()
                    self.state = 953
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==93:
                        self.state = 949
                        self.match(CParser.Comma)
                        self.state = 950
                        self.logicalOrExpression()
                        self.state = 955
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 971
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==91:
                    self.state = 958
                    self.match(CParser.Colon)
                    self.state = 967
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                        self.state = 959
                        self.logicalOrExpression()
                        self.state = 964
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==93:
                            self.state = 960
                            self.match(CParser.Comma)
                            self.state = 961
                            self.logicalOrExpression()
                            self.state = 966
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



                    self.state = 973
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 974
                self.match(CParser.RightParen)
                self.state = 975
                self.match(CParser.Semi)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 976
                self.multiLineMacroStatement()
                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 Identifier(self):
            return self.getToken(CParser.Identifier, 0)

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

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


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

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


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

        def getRuleIndex(self):
            return CParser.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 = CParser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_labeledStatement)
        try:
            self.state = 990
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [110]:
                self.enterOuterAlt(localctx, 1)
                self.state = 979
                self.match(CParser.Identifier)
                self.state = 980
                self.match(CParser.Colon)
                self.state = 981
                self.statement()
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 2)
                self.state = 982
                self.match(CParser.Case)
                self.state = 983
                self.constantExpression()
                self.state = 984
                self.match(CParser.Colon)
                self.state = 985
                self.statement()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 3)
                self.state = 987
                self.match(CParser.Default)
                self.state = 988
                self.match(CParser.Colon)
                self.state = 989
                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 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(CParser.LeftBrace, 0)

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

        def blockItemList(self):
            return self.getTypedRuleContext(CParser.BlockItemListContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 992
            self.match(CParser.LeftBrace)
            self.state = 994
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1152921505144305666) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531484180497) != 0):
                self.state = 993
                self.blockItemList()


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


    class BlockItemListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def blockItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.BlockItemContext)
            else:
                return self.getTypedRuleContext(CParser.BlockItemContext,i)


        def getRuleIndex(self):
            return CParser.RULE_blockItemList

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

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

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




    def blockItemList(self):

        localctx = CParser.BlockItemListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_blockItemList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 999 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 998
                self.blockItem()
                self.state = 1001 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -1152921505144305666) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531484180497) != 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 BlockItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def declaration(self):
            return self.getTypedRuleContext(CParser.DeclarationContext,0)


        def getRuleIndex(self):
            return CParser.RULE_blockItem

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

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

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




    def blockItem(self):

        localctx = CParser.BlockItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_blockItem)
        try:
            self.state = 1005
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1003
                self.statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1004
                self.declaration()
                pass


        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(CParser.Semi, 0)

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


        def getRuleIndex(self):
            return CParser.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 = CParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_expressionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1008
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                self.state = 1007
                self.expression()


            self.state = 1010
            self.match(CParser.Semi)
        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(CParser.If, 0)

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

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


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

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


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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_selectionStatement)
        try:
            self.state = 1027
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [35]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1012
                self.match(CParser.If)
                self.state = 1013
                self.match(CParser.LeftParen)
                self.state = 1014
                self.expression()
                self.state = 1015
                self.match(CParser.RightParen)
                self.state = 1016
                self.statement()
                self.state = 1019
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                if la_ == 1:
                    self.state = 1017
                    self.match(CParser.Else)
                    self.state = 1018
                    self.statement()


                pass
            elif token in [47]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1021
                self.match(CParser.Switch)
                self.state = 1022
                self.match(CParser.LeftParen)
                self.state = 1023
                self.expression()
                self.state = 1024
                self.match(CParser.RightParen)
                self.state = 1025
                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 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(CParser.While, 0)

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

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


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

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


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

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

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

        def forCondition(self):
            return self.getTypedRuleContext(CParser.ForConditionContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_iterationStatement)
        try:
            self.state = 1049
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [53]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1029
                self.match(CParser.While)
                self.state = 1030
                self.match(CParser.LeftParen)
                self.state = 1031
                self.expression()
                self.state = 1032
                self.match(CParser.RightParen)
                self.state = 1033
                self.statement()
                pass
            elif token in [27]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1035
                self.match(CParser.Do)
                self.state = 1036
                self.statement()
                self.state = 1037
                self.match(CParser.While)
                self.state = 1038
                self.match(CParser.LeftParen)
                self.state = 1039
                self.expression()
                self.state = 1040
                self.match(CParser.RightParen)
                self.state = 1041
                self.match(CParser.Semi)
                pass
            elif token in [33]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1043
                self.match(CParser.For)
                self.state = 1044
                self.match(CParser.LeftParen)
                self.state = 1045
                self.forCondition()
                self.state = 1046
                self.match(CParser.RightParen)
                self.state = 1047
                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 MultiLineMacroStatementContext(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(CParser.ExpressionContext,0)


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

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

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


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

        def getRuleIndex(self):
            return CParser.RULE_multiLineMacroStatement

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

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

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




    def multiLineMacroStatement(self):

        localctx = CParser.MultiLineMacroStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_multiLineMacroStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1051
            self.expression()
            self.state = 1052
            self.match(CParser.LeftParen)
            self.state = 1056
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 621657337645826062) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531484180497) != 0):
                self.state = 1053
                self.statement()
                self.state = 1058
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1059
            self.match(CParser.RightParen)
            self.state = 1061
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.state = 1060
                self.match(CParser.Semi)


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


    class ForConditionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def forDeclaration(self):
            return self.getTypedRuleContext(CParser.ForDeclarationContext,0)


        def forExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.ForExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.ForExpressionContext,i)


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


        def getRuleIndex(self):
            return CParser.RULE_forCondition

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

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

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




    def forCondition(self):

        localctx = CParser.ForConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_forCondition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1067
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.state = 1063
                self.forDeclaration()
                pass

            elif la_ == 2:
                self.state = 1065
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                    self.state = 1064
                    self.expression()


                pass


            self.state = 1069
            self.match(CParser.Semi)
            self.state = 1071
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                self.state = 1070
                self.forExpression()


            self.state = 1073
            self.match(CParser.Semi)
            self.state = 1075
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                self.state = 1074
                self.forExpression()


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


    class ForDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def declarationSpecifiers(self):
            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)


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


        def getRuleIndex(self):
            return CParser.RULE_forDeclaration

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

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

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




    def forDeclaration(self):

        localctx = CParser.ForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_forDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1077
            self.declarationSpecifiers()
            self.state = 1079
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 64000) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 70368752631809) != 0):
                self.state = 1078
                self.initDeclaratorList()


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


    class ForExpressionContext(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(CParser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.AssignmentExpressionContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_forExpression

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

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

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




    def forExpression(self):

        localctx = CParser.ForExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_forExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1081
            self.assignmentExpression()
            self.state = 1086
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==93:
                self.state = 1082
                self.match(CParser.Comma)
                self.state = 1083
                self.assignmentExpression()
                self.state = 1088
                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 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(CParser.Semi, 0)

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

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

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

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

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

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


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


        def getRuleIndex(self):
            return CParser.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 = CParser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_jumpStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1099
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
            if la_ == 1:
                self.state = 1089
                self.match(CParser.Goto)
                self.state = 1090
                self.match(CParser.Identifier)
                pass

            elif la_ == 2:
                self.state = 1091
                self.match(CParser.Continue)
                pass

            elif la_ == 3:
                self.state = 1092
                self.match(CParser.Break)
                pass

            elif la_ == 4:
                self.state = 1093
                self.match(CParser.Return)
                self.state = 1095
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 612507141508431886) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 1055531215745025) != 0):
                    self.state = 1094
                    self.expression()


                pass

            elif la_ == 5:
                self.state = 1097
                self.match(CParser.Goto)
                self.state = 1098
                self.unaryExpression()
                pass


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


    class CompilationUnitContext(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(CParser.EOF, 0)

        def translationUnit(self):
            return self.getTypedRuleContext(CParser.TranslationUnitContext,0)


        def getRuleIndex(self):
            return CParser.RULE_compilationUnit

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

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

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




    def compilationUnit(self):

        localctx = CParser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_compilationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1104
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1774578842790068238) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 70369021067265) != 0):
                self.state = 1103
                self.translationUnit()


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


    class TranslationUnitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def externalDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.ExternalDeclarationContext)
            else:
                return self.getTypedRuleContext(CParser.ExternalDeclarationContext,i)


        def getRuleIndex(self):
            return CParser.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 = CParser.TranslationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1109 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1108
                self.externalDeclaration()
                self.state = 1111 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -1774578842790068238) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 70369021067265) != 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 ExternalDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def declaration(self):
            return self.getTypedRuleContext(CParser.DeclarationContext,0)


        def functionCall(self):
            return self.getTypedRuleContext(CParser.FunctionCallContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_externalDeclaration

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

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

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




    def externalDeclaration(self):

        localctx = CParser.ExternalDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_externalDeclaration)
        try:
            self.state = 1117
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1113
                self.functionDefinition()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1114
                self.declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1115
                self.functionCall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1116
                self.match(CParser.Semi)
                pass


        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(CParser.DeclaratorContext,0)


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


        def declarationSpecifiers(self):
            return self.getTypedRuleContext(CParser.DeclarationSpecifiersContext,0)


        def declarationList(self):
            return self.getTypedRuleContext(CParser.DeclarationListContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1120
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
            if la_ == 1:
                self.state = 1119
                self.declarationSpecifiers()


            self.state = 1122
            self.declarator()
            self.state = 1124
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -1774578842790131726) != 0) or _la==110:
                self.state = 1123
                self.declarationList()


            self.state = 1126
            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 DeclarationListContext(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(CParser.DeclarationContext)
            else:
                return self.getTypedRuleContext(CParser.DeclarationContext,i)


        def getRuleIndex(self):
            return CParser.RULE_declarationList

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

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

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




    def declarationList(self):

        localctx = CParser.DeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_declarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1129 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1128
                self.declaration()
                self.state = 1131 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -1774578842790131726) != 0) or _la==110):
                    break

        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[49] = self.directDeclarator_sempred
        self._predicates[64] = self.directAbstractDeclarator_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 directDeclarator_sempred(self, localctx:DirectDeclaratorContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 4)
         

    def directAbstractDeclarator_sempred(self, localctx:DirectAbstractDeclaratorContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 1)
         




