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

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

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

    ruleNames =  [ "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", "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
    Sizet=37
    Int=38
    Long=39
    Register=40
    Restrict=41
    Return=42
    Short=43
    Signed=44
    Sizeof=45
    Static=46
    Struct=47
    Switch=48
    Typedef=49
    Union=50
    Unsigned=51
    Void=52
    Volatile=53
    While=54
    Alignas=55
    Alignof=56
    Atomic=57
    Bool=58
    Complex=59
    Generic=60
    Imaginary=61
    Noreturn=62
    StaticAssert=63
    ThreadLocal=64
    LeftParen=65
    RightParen=66
    LeftBracket=67
    RightBracket=68
    LeftBrace=69
    RightBrace=70
    Less=71
    LessEqual=72
    Greater=73
    GreaterEqual=74
    LeftShift=75
    RightShift=76
    Plus=77
    PlusPlus=78
    Minus=79
    MinusMinus=80
    Star=81
    Div=82
    Mod=83
    And=84
    Or=85
    AndAnd=86
    OrOr=87
    Caret=88
    Not=89
    Tilde=90
    Question=91
    Colon=92
    Semi=93
    Comma=94
    Assign=95
    StarAssign=96
    DivAssign=97
    ModAssign=98
    PlusAssign=99
    MinusAssign=100
    LeftShiftAssign=101
    RightShiftAssign=102
    AndAssign=103
    XorAssign=104
    OrAssign=105
    Equal=106
    NotEqual=107
    Arrow=108
    Dot=109
    Ellipsis=110
    Identifier=111
    Constant=112
    DigitSequence=113
    StringLiteral=114
    MultiLineMacro=115
    Directive=116
    AsmBlock=117
    Whitespace=118
    Newline=119
    BlockComment=120
    LineComment=121

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




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

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 179 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 178
                    self.match(CParser.StringLiteral)
                    self.state = 181 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==114):
                        break

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 183
                self.match(CParser.LeftParen)
                self.state = 184
                self.expression()
                self.state = 185
                self.match(CParser.RightParen)
                pass

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

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


                self.state = 191
                self.match(CParser.LeftParen)
                self.state = 192
                self.compoundStatement()
                self.state = 193
                self.match(CParser.RightParen)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 195
                self.match(CParser.T__1)
                self.state = 196
                self.match(CParser.LeftParen)
                self.state = 197
                self.unaryExpression()
                self.state = 198
                self.match(CParser.Comma)
                self.state = 199
                self.typeName()
                self.state = 200
                self.match(CParser.RightParen)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 202
                self.match(CParser.T__2)
                self.state = 203
                self.match(CParser.LeftParen)
                self.state = 204
                self.typeName()
                self.state = 205
                self.match(CParser.Comma)
                self.state = 206
                self.unaryExpression()
                self.state = 207
                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 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, 2, self.RULE_genericSelection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self.match(CParser.Generic)
            self.state = 212
            self.match(CParser.LeftParen)
            self.state = 213
            self.assignmentExpression()
            self.state = 214
            self.match(CParser.Comma)
            self.state = 215
            self.genericAssocList()
            self.state = 216
            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 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, 4, self.RULE_genericAssocList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 218
            self.genericAssociation()
            self.state = 223
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 219
                self.match(CParser.Comma)
                self.state = 220
                self.genericAssociation()
                self.state = 225
                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 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, 6, self.RULE_genericAssociation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 228
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 4, 5, 6, 7, 23, 24, 28, 30, 32, 37, 38, 39, 41, 43, 44, 47, 50, 51, 52, 53, 57, 58, 59, 111]:
                self.state = 226
                self.typeName()
                pass
            elif token in [26]:
                self.state = 227
                self.match(CParser.Default)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 230
            self.match(CParser.Colon)
            self.state = 231
            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 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, 8, self.RULE_postfixExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 247
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 233
                self.primaryExpression()
                pass

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


                self.state = 237
                self.match(CParser.LeftParen)
                self.state = 238
                self.typeName()
                self.state = 239
                self.match(CParser.RightParen)
                self.state = 240
                self.match(CParser.LeftBrace)
                self.state = 241
                self.initializerList()
                self.state = 243
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==94:
                    self.state = 242
                    self.match(CParser.Comma)


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


            self.state = 264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 26388279107589) != 0):
                self.state = 262
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [67]:
                    self.state = 249
                    self.match(CParser.LeftBracket)
                    self.state = 250
                    self.expression()
                    self.state = 251
                    self.match(CParser.RightBracket)
                    pass
                elif token in [65]:
                    self.state = 253
                    self.match(CParser.LeftParen)
                    self.state = 255
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                        self.state = 254
                        self.argumentExpressionList()


                    self.state = 257
                    self.match(CParser.RightParen)
                    pass
                elif token in [108, 109]:
                    self.state = 258
                    _la = self._input.LA(1)
                    if not(_la==108 or _la==109):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 259
                    self.match(CParser.Identifier)
                    pass
                elif token in [78]:
                    self.state = 260
                    self.match(CParser.PlusPlus)
                    pass
                elif token in [80]:
                    self.state = 261
                    self.match(CParser.MinusMinus)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 266
                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 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 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, 10, self.RULE_argumentExpressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 267
            self.assignmentExpression()
            self.state = 272
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 268
                self.match(CParser.Comma)
                self.state = 269
                self.assignmentExpression()
                self.state = 274
                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 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, 12, self.RULE_unaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 278
            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 = 275
                    _la = self._input.LA(1)
                    if not(((((_la - 45)) & ~0x3f) == 0 and ((1 << (_la - 45)) & 42949672961) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 280
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

            self.state = 292
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 60, 65, 111, 112, 114]:
                self.state = 281
                self.postfixExpression()
                pass
            elif token in [77, 79, 81, 84, 89, 90]:
                self.state = 282
                self.unaryOperator()
                self.state = 283
                self.castExpression()
                pass
            elif token in [45, 56]:
                self.state = 285
                _la = self._input.LA(1)
                if not(_la==45 or _la==56):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 286
                self.match(CParser.LeftParen)
                self.state = 287
                self.typeName()
                self.state = 288
                self.match(CParser.RightParen)
                pass
            elif token in [86]:
                self.state = 290
                self.match(CParser.AndAnd)
                self.state = 291
                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 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, 14, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            _la = self._input.LA(1)
            if not(((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 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 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, 16, self.RULE_castExpression)
        self._la = 0 # Token type
        try:
            self.state = 306
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 297
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==1:
                    self.state = 296
                    self.match(CParser.T__0)


                self.state = 299
                self.match(CParser.LeftParen)
                self.state = 300
                self.typeName()
                self.state = 301
                self.match(CParser.RightParen)
                self.state = 302
                self.castExpression()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 305
                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 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, 18, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.castExpression()
            self.state = 313
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 7) != 0):
                self.state = 309
                _la = self._input.LA(1)
                if not(((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 7) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 310
                self.castExpression()
                self.state = 315
                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 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, 20, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 316
            self.multiplicativeExpression()
            self.state = 321
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==77 or _la==79:
                self.state = 317
                _la = self._input.LA(1)
                if not(_la==77 or _la==79):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 318
                self.multiplicativeExpression()
                self.state = 323
                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 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, 22, self.RULE_shiftExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 324
            self.additiveExpression()
            self.state = 329
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==75 or _la==76:
                self.state = 325
                _la = self._input.LA(1)
                if not(_la==75 or _la==76):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 326
                self.additiveExpression()
                self.state = 331
                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 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, 24, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 332
            self.shiftExpression()
            self.state = 337
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 15) != 0):
                self.state = 333
                _la = self._input.LA(1)
                if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 15) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 334
                self.shiftExpression()
                self.state = 339
                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 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, 26, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 340
            self.relationalExpression()
            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==106 or _la==107:
                self.state = 341
                _la = self._input.LA(1)
                if not(_la==106 or _la==107):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 342
                self.relationalExpression()
                self.state = 347
                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 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, 28, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 348
            self.equalityExpression()
            self.state = 353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==84:
                self.state = 349
                self.match(CParser.And)
                self.state = 350
                self.equalityExpression()
                self.state = 355
                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 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, 30, self.RULE_exclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self.andExpression()
            self.state = 361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==88:
                self.state = 357
                self.match(CParser.Caret)
                self.state = 358
                self.andExpression()
                self.state = 363
                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 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, 32, self.RULE_inclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self.exclusiveOrExpression()
            self.state = 369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==85:
                self.state = 365
                self.match(CParser.Or)
                self.state = 366
                self.exclusiveOrExpression()
                self.state = 371
                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 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, 34, self.RULE_logicalAndExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 372
            self.inclusiveOrExpression()
            self.state = 377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==86:
                self.state = 373
                self.match(CParser.AndAnd)
                self.state = 374
                self.inclusiveOrExpression()
                self.state = 379
                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 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, 36, self.RULE_logicalOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 380
            self.logicalAndExpression()
            self.state = 385
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==87:
                self.state = 381
                self.match(CParser.OrOr)
                self.state = 382
                self.logicalAndExpression()
                self.state = 387
                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 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, 38, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 388
            self.logicalOrExpression()
            self.state = 394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==91:
                self.state = 389
                self.match(CParser.Question)
                self.state = 390
                self.expression()
                self.state = 391
                self.match(CParser.Colon)
                self.state = 392
                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 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, 40, self.RULE_assignmentExpression)
        try:
            self.state = 402
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 396
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 397
                self.unaryExpression()
                self.state = 398
                self.assignmentOperator()
                self.state = 399
                self.assignmentExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 401
                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 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, 42, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 404
            _la = self._input.LA(1)
            if not(((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 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 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, 44, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 406
            self.assignmentExpression()
            self.state = 411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 407
                self.match(CParser.Comma)
                self.state = 408
                self.assignmentExpression()
                self.state = 413
                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 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, 46, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 414
            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 Identifier(self):
            return self.getToken(CParser.Identifier, 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 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, 48, self.RULE_declaration)
        self._la = 0 # Token type
        try:
            self.state = 426
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 416
                self.declarationSpecifiers()
                self.state = 417
                self.match(CParser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 419
                self.declarationSpecifiers()
                self.state = 421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 64000) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 70368752631809) != 0):
                    self.state = 420
                    self.initDeclaratorList()


                self.state = 423
                self.match(CParser.Semi)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 425
                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 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 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, 50, self.RULE_declarationSpecifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 428
                    self.declarationSpecifier()

                else:
                    raise NoViableAltException(self)
                self.state = 431 
                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 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, 52, self.RULE_declarationSpecifiers2)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 434 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 433
                self.declarationSpecifier()
                self.state = 436 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 5674214412183013362) != 0) or _la==64 or _la==111):
                    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 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, 54, self.RULE_declarationSpecifier)
        try:
            self.state = 443
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 438
                self.storageClassSpecifier()
                pass

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

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

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

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 442
                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 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, 56, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 445
            self.initDeclarator()
            self.state = 450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 446
                self.match(CParser.Comma)
                self.state = 447
                self.initDeclarator()
                self.state = 452
                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 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, 58, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 453
            self.declarator()
            self.state = 456
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==95:
                self.state = 454
                self.match(CParser.Assign)
                self.state = 455
                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 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, 60, self.RULE_storageClassSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 458
            _la = self._input.LA(1)
            if not(((((_la - 20)) & ~0x3f) == 0 and ((1 << (_la - 20)) & 17592791074817) != 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 Sizet(self):
            return self.getToken(CParser.Sizet, 0)

        def getRuleIndex(self):
            return CParser.RULE_typeSpecifier

        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, 62, self.RULE_typeSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 488
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [52]:
                self.enterOuterAlt(localctx, 1)
                self.state = 460
                self.match(CParser.Void)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 2)
                self.state = 461
                self.match(CParser.Char)
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 3)
                self.state = 462
                self.match(CParser.Short)
                pass
            elif token in [38]:
                self.enterOuterAlt(localctx, 4)
                self.state = 463
                self.match(CParser.Int)
                pass
            elif token in [39]:
                self.enterOuterAlt(localctx, 5)
                self.state = 464
                self.match(CParser.Long)
                pass
            elif token in [32]:
                self.enterOuterAlt(localctx, 6)
                self.state = 465
                self.match(CParser.Float)
                pass
            elif token in [28]:
                self.enterOuterAlt(localctx, 7)
                self.state = 466
                self.match(CParser.Double)
                pass
            elif token in [44]:
                self.enterOuterAlt(localctx, 8)
                self.state = 467
                self.match(CParser.Signed)
                pass
            elif token in [51]:
                self.enterOuterAlt(localctx, 9)
                self.state = 468
                self.match(CParser.Unsigned)
                pass
            elif token in [58]:
                self.enterOuterAlt(localctx, 10)
                self.state = 469
                self.match(CParser.Bool)
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 11)
                self.state = 470
                self.match(CParser.Complex)
                pass
            elif token in [4]:
                self.enterOuterAlt(localctx, 12)
                self.state = 471
                self.match(CParser.T__3)
                pass
            elif token in [5]:
                self.enterOuterAlt(localctx, 13)
                self.state = 472
                self.match(CParser.T__4)
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 14)
                self.state = 473
                self.match(CParser.T__5)
                pass
            elif token in [1]:
                self.enterOuterAlt(localctx, 15)
                self.state = 474
                self.match(CParser.T__0)
                self.state = 475
                self.match(CParser.LeftParen)
                self.state = 476
                _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 = 477
                self.match(CParser.RightParen)
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 16)
                self.state = 478
                self.atomicTypeSpecifier()
                pass
            elif token in [47, 50]:
                self.enterOuterAlt(localctx, 17)
                self.state = 479
                self.structOrUnionSpecifier()
                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 18)
                self.state = 480
                self.enumSpecifier()
                pass
            elif token in [111]:
                self.enterOuterAlt(localctx, 19)
                self.state = 481
                self.typedefName()
                pass
            elif token in [7]:
                self.enterOuterAlt(localctx, 20)
                self.state = 482
                self.match(CParser.T__6)
                self.state = 483
                self.match(CParser.LeftParen)
                self.state = 484
                self.constantExpression()
                self.state = 485
                self.match(CParser.RightParen)
                pass
            elif token in [37]:
                self.enterOuterAlt(localctx, 21)
                self.state = 487
                self.match(CParser.Sizet)
                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 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, 64, self.RULE_structOrUnionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 501
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 490
                self.structOrUnion()
                self.state = 492
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==111:
                    self.state = 491
                    self.match(CParser.Identifier)


                self.state = 494
                self.match(CParser.LeftBrace)
                self.state = 495
                self.structDeclarationList()
                self.state = 496
                self.match(CParser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 498
                self.structOrUnion()
                self.state = 499
                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 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, 66, self.RULE_structOrUnion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 503
            _la = self._input.LA(1)
            if not(_la==47 or _la==50):
                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 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, 68, self.RULE_structDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 506 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 505
                self.structDeclaration()
                self.state = 508 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -8197506929195482894) != 0) or _la==111):
                    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 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, 70, self.RULE_structDeclaration)
        try:
            self.state = 518
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 510
                self.specifierQualifierList()
                self.state = 511
                self.structDeclaratorList()
                self.state = 512
                self.match(CParser.Semi)
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 517
                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 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, 72, self.RULE_specifierQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 522
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
            if la_ == 1:
                self.state = 520
                self.typeSpecifier()
                pass

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


            self.state = 525
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 524
                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 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, 74, self.RULE_structDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527
            self.structDeclarator()
            self.state = 532
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 528
                self.match(CParser.Comma)
                self.state = 529
                self.structDeclarator()
                self.state = 534
                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 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, 76, self.RULE_structDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 541
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 535
                self.declarator()
                pass

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


                self.state = 539
                self.match(CParser.Colon)
                self.state = 540
                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 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, 78, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 556
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 543
                self.match(CParser.Enum)
                self.state = 545
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==111:
                    self.state = 544
                    self.match(CParser.Identifier)


                self.state = 547
                self.match(CParser.LeftBrace)
                self.state = 548
                self.enumeratorList()
                self.state = 550
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==94:
                    self.state = 549
                    self.match(CParser.Comma)


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

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 554
                self.match(CParser.Enum)
                self.state = 555
                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 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, 80, self.RULE_enumeratorList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self.enumerator()
            self.state = 563
            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 = 559
                    self.match(CParser.Comma)
                    self.state = 560
                    self.enumerator() 
                self.state = 565
                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 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, 82, self.RULE_enumerator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 566
            self.enumerationConstant()
            self.state = 569
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==95:
                self.state = 567
                self.match(CParser.Assign)
                self.state = 568
                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 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, 84, self.RULE_enumerationConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 571
            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 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, 86, self.RULE_atomicTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 573
            self.match(CParser.Atomic)
            self.state = 574
            self.match(CParser.LeftParen)
            self.state = 575
            self.typeName()
            self.state = 576
            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 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, 88, self.RULE_typeQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 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 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, 90, self.RULE_functionSpecifier)
        try:
            self.state = 589
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [36]:
                self.enterOuterAlt(localctx, 1)
                self.state = 580
                self.match(CParser.Inline)
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 2)
                self.state = 581
                self.match(CParser.Noreturn)
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 3)
                self.state = 582
                self.match(CParser.T__7)
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 4)
                self.state = 583
                self.match(CParser.T__8)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 5)
                self.state = 584
                self.gccAttributeSpecifier()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 6)
                self.state = 585
                self.match(CParser.T__9)
                self.state = 586
                self.match(CParser.LeftParen)
                self.state = 587
                self.match(CParser.Identifier)
                self.state = 588
                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 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, 92, self.RULE_alignmentSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 591
            self.match(CParser.Alignas)
            self.state = 592
            self.match(CParser.LeftParen)
            self.state = 595
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 593
                self.typeName()
                pass

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


            self.state = 597
            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 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, 94, self.RULE_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 600
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==81 or _la==88:
                self.state = 599
                self.pointer()


            self.state = 602
            self.directDeclarator(0)
            self.state = 606
            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 = 603
                    self.gccDeclaratorExtension() 
                self.state = 608
                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 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 = 96
        self.enterRecursionRule(localctx, 96, self.RULE_directDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 626
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 610
                self.match(CParser.Identifier)
                pass

            elif la_ == 2:
                self.state = 611
                self.match(CParser.LeftParen)
                self.state = 612
                self.declarator()
                self.state = 613
                self.match(CParser.RightParen)
                pass

            elif la_ == 3:
                self.state = 615
                self.match(CParser.Identifier)
                self.state = 616
                self.match(CParser.Colon)
                self.state = 617
                self.match(CParser.DigitSequence)
                pass

            elif la_ == 4:
                self.state = 618
                self.vcSpecificModifer()
                self.state = 619
                self.match(CParser.Identifier)
                pass

            elif la_ == 5:
                self.state = 621
                self.match(CParser.LeftParen)
                self.state = 622
                self.vcSpecificModifer()
                self.state = 623
                self.declarator()
                self.state = 624
                self.match(CParser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 673
            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 = 671
                    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 = 628
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 629
                        self.match(CParser.LeftBracket)
                        self.state = 631
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 0):
                            self.state = 630
                            self.typeQualifierList()


                        self.state = 634
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                            self.state = 633
                            self.assignmentExpression()


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

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


                        self.state = 643
                        self.assignmentExpression()
                        self.state = 644
                        self.match(CParser.RightBracket)
                        pass

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

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


                        self.state = 658
                        self.match(CParser.Star)
                        self.state = 659
                        self.match(CParser.RightBracket)
                        pass

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

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


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

             
                self.state = 675
                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 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, 98, self.RULE_vcSpecificModifer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 676
            _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 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, 100, self.RULE_gccDeclaratorExtension)
        self._la = 0 # Token type
        try:
            self.state = 687
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [16]:
                self.enterOuterAlt(localctx, 1)
                self.state = 678
                self.match(CParser.T__15)
                self.state = 679
                self.match(CParser.LeftParen)
                self.state = 681 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 680
                    self.match(CParser.StringLiteral)
                    self.state = 683 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==114):
                        break

                self.state = 685
                self.match(CParser.RightParen)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 2)
                self.state = 686
                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 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, 102, self.RULE_gccAttributeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 689
            self.match(CParser.T__16)
            self.state = 690
            self.match(CParser.LeftParen)
            self.state = 691
            self.match(CParser.LeftParen)
            self.state = 692
            self.gccAttributeList()
            self.state = 693
            self.match(CParser.RightParen)
            self.state = 694
            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 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, 104, self.RULE_gccAttributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 288230375077969913) != 0):
                self.state = 696
                self.gccAttribute()


            self.state = 705
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 699
                self.match(CParser.Comma)
                self.state = 701
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & -2) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 288230375077969913) != 0):
                    self.state = 700
                    self.gccAttribute()


                self.state = 707
                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 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, 106, self.RULE_gccAttribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 708
            _la = self._input.LA(1)
            if _la <= 0 or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 536870915) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 714
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==65:
                self.state = 709
                self.match(CParser.LeftParen)
                self.state = 711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                    self.state = 710
                    self.argumentExpressionList()


                self.state = 713
                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 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, 108, self.RULE_nestedParenthesesBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 723
            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)) & 288230376151711739) != 0):
                self.state = 721
                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, 64, 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, 121]:
                    self.state = 716
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==65 or _la==66:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                elif token in [65]:
                    self.state = 717
                    self.match(CParser.LeftParen)
                    self.state = 718
                    self.nestedParenthesesBlock()
                    self.state = 719
                    self.match(CParser.RightParen)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 725
                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 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, 110, self.RULE_pointer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 726
                _la = self._input.LA(1)
                if not(_la==81 or _la==88):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 728
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 0):
                    self.state = 727
                    self.typeQualifierList()


                self.state = 732 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==81 or _la==88):
                    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 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, 112, self.RULE_typeQualifierList)
        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 = 734
                self.typeQualifier()
                self.state = 737 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 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 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, 114, self.RULE_parameterTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 739
            self.parameterList()
            self.state = 742
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==94:
                self.state = 740
                self.match(CParser.Comma)
                self.state = 741
                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 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, 116, self.RULE_parameterList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.parameterDeclaration()
            self.state = 749
            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 = 745
                    self.match(CParser.Comma)
                    self.state = 746
                    self.parameterDeclaration() 
                self.state = 751
                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 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, 118, self.RULE_parameterDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 752
                self.declarationSpecifiers()
                self.state = 753
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 755
                self.declarationSpecifiers2()
                self.state = 757
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 8454149) != 0):
                    self.state = 756
                    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 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, 120, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 761
            self.match(CParser.Identifier)
            self.state = 766
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 762
                self.match(CParser.Comma)
                self.state = 763
                self.match(CParser.Identifier)
                self.state = 768
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class 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 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, 122, self.RULE_typeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 769
            self.specifierQualifierList()
            self.state = 771
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 8454149) != 0):
                self.state = 770
                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 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, 124, self.RULE_abstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 784
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 773
                self.pointer()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81 or _la==88:
                    self.state = 774
                    self.pointer()


                self.state = 777
                self.directAbstractDeclarator(0)
                self.state = 781
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==16 or _la==17:
                    self.state = 778
                    self.gccDeclaratorExtension()
                    self.state = 783
                    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 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 = 126
        self.enterRecursionRule(localctx, 126, self.RULE_directAbstractDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 832
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.state = 787
                self.match(CParser.LeftParen)
                self.state = 788
                self.abstractDeclarator()
                self.state = 789
                self.match(CParser.RightParen)
                self.state = 793
                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 = 790
                        self.gccDeclaratorExtension() 
                    self.state = 795
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,84,self._ctx)

                pass

            elif la_ == 2:
                self.state = 796
                self.match(CParser.LeftBracket)
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 0):
                    self.state = 797
                    self.typeQualifierList()


                self.state = 801
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                    self.state = 800
                    self.assignmentExpression()


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

            elif la_ == 3:
                self.state = 804
                self.match(CParser.LeftBracket)
                self.state = 805
                self.match(CParser.Static)
                self.state = 807
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 0):
                    self.state = 806
                    self.typeQualifierList()


                self.state = 809
                self.assignmentExpression()
                self.state = 810
                self.match(CParser.RightBracket)
                pass

            elif la_ == 4:
                self.state = 812
                self.match(CParser.LeftBracket)
                self.state = 813
                self.typeQualifierList()
                self.state = 814
                self.match(CParser.Static)
                self.state = 815
                self.assignmentExpression()
                self.state = 816
                self.match(CParser.RightBracket)
                pass

            elif la_ == 5:
                self.state = 818
                self.match(CParser.LeftBracket)
                self.state = 819
                self.match(CParser.Star)
                self.state = 820
                self.match(CParser.RightBracket)
                pass

            elif la_ == 6:
                self.state = 821
                self.match(CParser.LeftParen)
                self.state = 823
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 5674214412183013362) != 0) or _la==64 or _la==111:
                    self.state = 822
                    self.parameterTypeList()


                self.state = 825
                self.match(CParser.RightParen)
                self.state = 829
                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 = 826
                        self.gccDeclaratorExtension() 
                    self.state = 831
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,89,self._ctx)

                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 877
            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 = 875
                    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 = 834
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 835
                        self.match(CParser.LeftBracket)
                        self.state = 837
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 153124586370629632) != 0):
                            self.state = 836
                            self.typeQualifierList()


                        self.state = 840
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                            self.state = 839
                            self.assignmentExpression()


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

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


                        self.state = 849
                        self.assignmentExpression()
                        self.state = 850
                        self.match(CParser.RightBracket)
                        pass

                    elif la_ == 3:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 852
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 853
                        self.match(CParser.LeftBracket)
                        self.state = 854
                        self.typeQualifierList()
                        self.state = 855
                        self.match(CParser.Static)
                        self.state = 856
                        self.assignmentExpression()
                        self.state = 857
                        self.match(CParser.RightBracket)
                        pass

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

                    elif la_ == 5:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 863
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 864
                        self.match(CParser.LeftParen)
                        self.state = 866
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 5674214412183013362) != 0) or _la==64 or _la==111:
                            self.state = 865
                            self.parameterTypeList()


                        self.state = 868
                        self.match(CParser.RightParen)
                        self.state = 872
                        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 = 869
                                self.gccDeclaratorExtension() 
                            self.state = 874
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,95,self._ctx)

                        pass

             
                self.state = 879
                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 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, 128, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 880
            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 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, 130, self.RULE_initializer)
        self._la = 0 # Token type
        try:
            self.state = 890
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 45, 56, 60, 65, 77, 78, 79, 80, 81, 84, 86, 89, 90, 111, 112, 113, 114]:
                self.enterOuterAlt(localctx, 1)
                self.state = 882
                self.assignmentExpression()
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 2)
                self.state = 883
                self.match(CParser.LeftBrace)
                self.state = 884
                self.initializerList()
                self.state = 886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==94:
                    self.state = 885
                    self.match(CParser.Comma)


                self.state = 888
                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 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, 132, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 893
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==67 or _la==109:
                self.state = 892
                self.designation()


            self.state = 895
            self.initializer()
            self.state = 903
            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 = 896
                    self.match(CParser.Comma)
                    self.state = 898
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==67 or _la==109:
                        self.state = 897
                        self.designation()


                    self.state = 900
                    self.initializer() 
                self.state = 905
                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 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, 134, self.RULE_designation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 906
            self.designatorList()
            self.state = 907
            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 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, 136, self.RULE_designatorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 910 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 909
                self.designator()
                self.state = 912 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==67 or _la==109):
                    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 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, 138, self.RULE_designator)
        try:
            self.state = 920
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [67]:
                self.enterOuterAlt(localctx, 1)
                self.state = 914
                self.match(CParser.LeftBracket)
                self.state = 915
                self.constantExpression()
                self.state = 916
                self.match(CParser.RightBracket)
                pass
            elif token in [109]:
                self.enterOuterAlt(localctx, 2)
                self.state = 918
                self.match(CParser.Dot)
                self.state = 919
                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 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, 140, self.RULE_staticAssertDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 922
            self.match(CParser.StaticAssert)
            self.state = 923
            self.match(CParser.LeftParen)
            self.state = 924
            self.constantExpression()
            self.state = 925
            self.match(CParser.Comma)
            self.state = 927 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 926
                self.match(CParser.StringLiteral)
                self.state = 929 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==114):
                    break

            self.state = 931
            self.match(CParser.RightParen)
            self.state = 932
            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 getRuleIndex(self):
            return CParser.RULE_statement

        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, 142, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 971
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 934
                self.labeledStatement()
                pass

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

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

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

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

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

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 940
                _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 = 941
                _la = self._input.LA(1)
                if not(_la==19 or _la==53):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 942
                self.match(CParser.LeftParen)
                self.state = 951
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                    self.state = 943
                    self.logicalOrExpression()
                    self.state = 948
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==94:
                        self.state = 944
                        self.match(CParser.Comma)
                        self.state = 945
                        self.logicalOrExpression()
                        self.state = 950
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 966
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==92:
                    self.state = 953
                    self.match(CParser.Colon)
                    self.state = 962
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                        self.state = 954
                        self.logicalOrExpression()
                        self.state = 959
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==94:
                            self.state = 955
                            self.match(CParser.Comma)
                            self.state = 956
                            self.logicalOrExpression()
                            self.state = 961
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



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

                self.state = 969
                self.match(CParser.RightParen)
                self.state = 970
                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 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 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, 144, self.RULE_labeledStatement)
        try:
            self.state = 984
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [111]:
                self.enterOuterAlt(localctx, 1)
                self.state = 973
                self.match(CParser.Identifier)
                self.state = 974
                self.match(CParser.Colon)
                self.state = 975
                self.statement()
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 2)
                self.state = 976
                self.match(CParser.Case)
                self.state = 977
                self.constantExpression()
                self.state = 978
                self.match(CParser.Colon)
                self.state = 979
                self.statement()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 3)
                self.state = 981
                self.match(CParser.Default)
                self.state = 982
                self.match(CParser.Colon)
                self.state = 983
                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 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, 146, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 986
            self.match(CParser.LeftBrace)
            self.state = 988
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -2305843009751152642) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 2111062968360995) != 0):
                self.state = 987
                self.blockItemList()


            self.state = 990
            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 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, 148, self.RULE_blockItemList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 993 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 992
                self.blockItem()
                self.state = 995 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -2305843009751152642) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 2111062968360995) != 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 declaration(self):
            return self.getTypedRuleContext(CParser.DeclarationContext,0)


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


        def getRuleIndex(self):
            return CParser.RULE_blockItem

        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, 150, self.RULE_blockItem)
        try:
            self.state = 999
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 997
                self.declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 998
                self.statement()
                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 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, 152, self.RULE_expressionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                self.state = 1001
                self.expression()


            self.state = 1004
            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 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, 154, self.RULE_selectionStatement)
        try:
            self.state = 1021
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [35]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1006
                self.match(CParser.If)
                self.state = 1007
                self.match(CParser.LeftParen)
                self.state = 1008
                self.expression()
                self.state = 1009
                self.match(CParser.RightParen)
                self.state = 1010
                self.statement()
                self.state = 1013
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                if la_ == 1:
                    self.state = 1011
                    self.match(CParser.Else)
                    self.state = 1012
                    self.statement()


                pass
            elif token in [48]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1015
                self.match(CParser.Switch)
                self.state = 1016
                self.match(CParser.LeftParen)
                self.state = 1017
                self.expression()
                self.state = 1018
                self.match(CParser.RightParen)
                self.state = 1019
                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 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, 156, self.RULE_iterationStatement)
        try:
            self.state = 1043
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [54]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1023
                self.match(CParser.While)
                self.state = 1024
                self.match(CParser.LeftParen)
                self.state = 1025
                self.expression()
                self.state = 1026
                self.match(CParser.RightParen)
                self.state = 1027
                self.statement()
                pass
            elif token in [27]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1029
                self.match(CParser.Do)
                self.state = 1030
                self.statement()
                self.state = 1031
                self.match(CParser.While)
                self.state = 1032
                self.match(CParser.LeftParen)
                self.state = 1033
                self.expression()
                self.state = 1034
                self.match(CParser.RightParen)
                self.state = 1035
                self.match(CParser.Semi)
                pass
            elif token in [33]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1037
                self.match(CParser.For)
                self.state = 1038
                self.match(CParser.LeftParen)
                self.state = 1039
                self.forCondition()
                self.state = 1040
                self.match(CParser.RightParen)
                self.state = 1041
                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 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 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, 158, self.RULE_forCondition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1049
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.state = 1045
                self.forDeclaration()
                pass

            elif la_ == 2:
                self.state = 1047
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                    self.state = 1046
                    self.expression()


                pass


            self.state = 1051
            self.match(CParser.Semi)
            self.state = 1053
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                self.state = 1052
                self.forExpression()


            self.state = 1055
            self.match(CParser.Semi)
            self.state = 1057
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                self.state = 1056
                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 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, 160, self.RULE_forDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1059
            self.declarationSpecifiers()
            self.state = 1061
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 64000) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 70368752631809) != 0):
                self.state = 1060
                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 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, 162, self.RULE_forExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1063
            self.assignmentExpression()
            self.state = 1068
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==94:
                self.state = 1064
                self.match(CParser.Comma)
                self.state = 1065
                self.assignmentExpression()
                self.state = 1070
                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 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, 164, self.RULE_jumpStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1081
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
            if la_ == 1:
                self.state = 1071
                self.match(CParser.Goto)
                self.state = 1072
                self.match(CParser.Identifier)
                pass

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

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

            elif la_ == 4:
                self.state = 1075
                self.match(CParser.Return)
                self.state = 1077
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1225014283016863758) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1055531215745025) != 0):
                    self.state = 1076
                    self.expression()


                pass

            elif la_ == 5:
                self.state = 1079
                self.match(CParser.Goto)
                self.state = 1080
                self.unaryExpression()
                pass


            self.state = 1083
            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 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, 166, self.RULE_compilationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1086
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -3549157624671698958) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 140738042134531) != 0):
                self.state = 1085
                self.translationUnit()


            self.state = 1088
            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 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, 168, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1091 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1090
                self.externalDeclaration()
                self.state = 1093 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -3549157624671698958) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 140738042134531) != 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 Semi(self):
            return self.getToken(CParser.Semi, 0)

        def getRuleIndex(self):
            return CParser.RULE_externalDeclaration

        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, 170, self.RULE_externalDeclaration)
        try:
            self.state = 1098
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1095
                self.functionDefinition()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1097
                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 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, 172, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1101
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
            if la_ == 1:
                self.state = 1100
                self.declarationSpecifiers()


            self.state = 1103
            self.declarator()
            self.state = 1105
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -3549157624671762446) != 0) or _la==64 or _la==111:
                self.state = 1104
                self.declarationList()


            self.state = 1107
            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 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, 174, self.RULE_declarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1110 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1109
                self.declaration()
                self.state = 1112 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -3549157624671762446) != 0) or _la==64 or _la==111):
                    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[48] = self.directDeclarator_sempred
        self._predicates[63] = 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)
         




