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

class SolidityParser ( Parser ):

    grammarFileName = "Solidity.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'pragma'", "';'", "'*'", "'||'", "'^'", 
                     "'~'", "'>='", "'>'", "'<'", "'<='", "'='", "'as'", 
                     "'import'", "'from'", "'{'", "','", "'}'", "'abstract'", 
                     "'contract'", "'interface'", "'library'", "'is'", "'('", 
                     "')'", "'error'", "'using'", "'for'", "'struct'", "'modifier'", 
                     "'function'", "'returns'", "'event'", "'enum'", "'['", 
                     "']'", "'address'", "'.'", "'mapping'", "'=>'", "'memory'", 
                     "'storage'", "'calldata'", "'if'", "'else'", "'try'", 
                     "'catch'", "'while'", "'unchecked'", "'assembly'", 
                     "'do'", "'return'", "'throw'", "'emit'", "'revert'", 
                     "'var'", "'bool'", "'string'", "'byte'", "'++'", "'--'", 
                     "'new'", "':'", "'+'", "'-'", "'after'", "'delete'", 
                     "'!'", "'**'", "'/'", "'%'", "'<<'", "'>>'", "'&'", 
                     "'|'", "'=='", "'!='", "'&&'", "'?'", "'|='", "'^='", 
                     "'&='", "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", 
                     "'%='", "'let'", "':='", "'=:'", "'switch'", "'case'", 
                     "'default'", "'->'", "'callback'", "'override'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'anonymous'", "'break'", 
                     "'constant'", "'immutable'", "'continue'", "'leave'", 
                     "'external'", "'indexed'", "'internal'", "'payable'", 
                     "'private'", "'public'", "'virtual'", "'pure'", "'type'", 
                     "'view'", "'global'", "'constructor'", "'fallback'", 
                     "'receive'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "Int", "Uint", "Byte", "Fixed", 
                      "Ufixed", "BooleanLiteral", "DecimalNumber", "HexNumber", 
                      "NumberUnit", "HexLiteralFragment", "ReservedKeyword", 
                      "AnonymousKeyword", "BreakKeyword", "ConstantKeyword", 
                      "ImmutableKeyword", "ContinueKeyword", "LeaveKeyword", 
                      "ExternalKeyword", "IndexedKeyword", "InternalKeyword", 
                      "PayableKeyword", "PrivateKeyword", "PublicKeyword", 
                      "VirtualKeyword", "PureKeyword", "TypeKeyword", "ViewKeyword", 
                      "GlobalKeyword", "ConstructorKeyword", "FallbackKeyword", 
                      "ReceiveKeyword", "Identifier", "StringLiteralFragment", 
                      "VersionLiteral", "WS", "COMMENT", "LINE_COMMENT" ]

    RULE_sourceUnit = 0
    RULE_pragmaDirective = 1
    RULE_pragmaName = 2
    RULE_pragmaValue = 3
    RULE_version = 4
    RULE_versionOperator = 5
    RULE_versionConstraint = 6
    RULE_importDeclaration = 7
    RULE_importDirective = 8
    RULE_importPath = 9
    RULE_contractDefinition = 10
    RULE_inheritanceSpecifier = 11
    RULE_contractPart = 12
    RULE_stateVariableDeclaration = 13
    RULE_fileLevelConstant = 14
    RULE_customErrorDefinition = 15
    RULE_typeDefinition = 16
    RULE_usingForDeclaration = 17
    RULE_usingForObject = 18
    RULE_structDefinition = 19
    RULE_modifierDefinition = 20
    RULE_modifierInvocation = 21
    RULE_functionDefinition = 22
    RULE_functionDescriptor = 23
    RULE_returnParameters = 24
    RULE_modifierList = 25
    RULE_eventDefinition = 26
    RULE_enumValue = 27
    RULE_enumDefinition = 28
    RULE_parameterList = 29
    RULE_parameter = 30
    RULE_eventParameterList = 31
    RULE_eventParameter = 32
    RULE_functionTypeParameterList = 33
    RULE_functionTypeParameter = 34
    RULE_variableDeclaration = 35
    RULE_typeName = 36
    RULE_userDefinedTypeName = 37
    RULE_mappingKey = 38
    RULE_mapping = 39
    RULE_functionTypeName = 40
    RULE_storageLocation = 41
    RULE_stateMutability = 42
    RULE_block = 43
    RULE_statement = 44
    RULE_expressionStatement = 45
    RULE_ifStatement = 46
    RULE_tryStatement = 47
    RULE_catchClause = 48
    RULE_whileStatement = 49
    RULE_simpleStatement = 50
    RULE_uncheckedStatement = 51
    RULE_forStatement = 52
    RULE_inlineAssemblyStatement = 53
    RULE_inlineAssemblyStatementFlag = 54
    RULE_doWhileStatement = 55
    RULE_continueStatement = 56
    RULE_breakStatement = 57
    RULE_returnStatement = 58
    RULE_throwStatement = 59
    RULE_emitStatement = 60
    RULE_revertStatement = 61
    RULE_variableDeclarationStatement = 62
    RULE_variableDeclarationList = 63
    RULE_identifierList = 64
    RULE_elementaryTypeName = 65
    RULE_expression = 66
    RULE_primaryExpression = 67
    RULE_expressionList = 68
    RULE_nameValueList = 69
    RULE_nameValue = 70
    RULE_functionCallArguments = 71
    RULE_functionCall = 72
    RULE_assemblyBlock = 73
    RULE_assemblyItem = 74
    RULE_assemblyExpression = 75
    RULE_assemblyMember = 76
    RULE_assemblyCall = 77
    RULE_assemblyLocalDefinition = 78
    RULE_assemblyAssignment = 79
    RULE_assemblyIdentifierOrList = 80
    RULE_assemblyIdentifierList = 81
    RULE_assemblyStackAssignment = 82
    RULE_labelDefinition = 83
    RULE_assemblySwitch = 84
    RULE_assemblyCase = 85
    RULE_assemblyFunctionDefinition = 86
    RULE_assemblyFunctionReturns = 87
    RULE_assemblyFor = 88
    RULE_assemblyIf = 89
    RULE_assemblyLiteral = 90
    RULE_subAssembly = 91
    RULE_tupleExpression = 92
    RULE_numberLiteral = 93
    RULE_identifier = 94
    RULE_hexLiteral = 95
    RULE_overrideSpecifier = 96
    RULE_stringLiteral = 97

    ruleNames =  [ "sourceUnit", "pragmaDirective", "pragmaName", "pragmaValue", 
                   "version", "versionOperator", "versionConstraint", "importDeclaration", 
                   "importDirective", "importPath", "contractDefinition", 
                   "inheritanceSpecifier", "contractPart", "stateVariableDeclaration", 
                   "fileLevelConstant", "customErrorDefinition", "typeDefinition", 
                   "usingForDeclaration", "usingForObject", "structDefinition", 
                   "modifierDefinition", "modifierInvocation", "functionDefinition", 
                   "functionDescriptor", "returnParameters", "modifierList", 
                   "eventDefinition", "enumValue", "enumDefinition", "parameterList", 
                   "parameter", "eventParameterList", "eventParameter", 
                   "functionTypeParameterList", "functionTypeParameter", 
                   "variableDeclaration", "typeName", "userDefinedTypeName", 
                   "mappingKey", "mapping", "functionTypeName", "storageLocation", 
                   "stateMutability", "block", "statement", "expressionStatement", 
                   "ifStatement", "tryStatement", "catchClause", "whileStatement", 
                   "simpleStatement", "uncheckedStatement", "forStatement", 
                   "inlineAssemblyStatement", "inlineAssemblyStatementFlag", 
                   "doWhileStatement", "continueStatement", "breakStatement", 
                   "returnStatement", "throwStatement", "emitStatement", 
                   "revertStatement", "variableDeclarationStatement", "variableDeclarationList", 
                   "identifierList", "elementaryTypeName", "expression", 
                   "primaryExpression", "expressionList", "nameValueList", 
                   "nameValue", "functionCallArguments", "functionCall", 
                   "assemblyBlock", "assemblyItem", "assemblyExpression", 
                   "assemblyMember", "assemblyCall", "assemblyLocalDefinition", 
                   "assemblyAssignment", "assemblyIdentifierOrList", "assemblyIdentifierList", 
                   "assemblyStackAssignment", "labelDefinition", "assemblySwitch", 
                   "assemblyCase", "assemblyFunctionDefinition", "assemblyFunctionReturns", 
                   "assemblyFor", "assemblyIf", "assemblyLiteral", "subAssembly", 
                   "tupleExpression", "numberLiteral", "identifier", "hexLiteral", 
                   "overrideSpecifier", "stringLiteral" ]

    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
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    T__45=46
    T__46=47
    T__47=48
    T__48=49
    T__49=50
    T__50=51
    T__51=52
    T__52=53
    T__53=54
    T__54=55
    T__55=56
    T__56=57
    T__57=58
    T__58=59
    T__59=60
    T__60=61
    T__61=62
    T__62=63
    T__63=64
    T__64=65
    T__65=66
    T__66=67
    T__67=68
    T__68=69
    T__69=70
    T__70=71
    T__71=72
    T__72=73
    T__73=74
    T__74=75
    T__75=76
    T__76=77
    T__77=78
    T__78=79
    T__79=80
    T__80=81
    T__81=82
    T__82=83
    T__83=84
    T__84=85
    T__85=86
    T__86=87
    T__87=88
    T__88=89
    T__89=90
    T__90=91
    T__91=92
    T__92=93
    T__93=94
    T__94=95
    T__95=96
    T__96=97
    Int=98
    Uint=99
    Byte=100
    Fixed=101
    Ufixed=102
    BooleanLiteral=103
    DecimalNumber=104
    HexNumber=105
    NumberUnit=106
    HexLiteralFragment=107
    ReservedKeyword=108
    AnonymousKeyword=109
    BreakKeyword=110
    ConstantKeyword=111
    ImmutableKeyword=112
    ContinueKeyword=113
    LeaveKeyword=114
    ExternalKeyword=115
    IndexedKeyword=116
    InternalKeyword=117
    PayableKeyword=118
    PrivateKeyword=119
    PublicKeyword=120
    VirtualKeyword=121
    PureKeyword=122
    TypeKeyword=123
    ViewKeyword=124
    GlobalKeyword=125
    ConstructorKeyword=126
    FallbackKeyword=127
    ReceiveKeyword=128
    Identifier=129
    StringLiteralFragment=130
    VersionLiteral=131
    WS=132
    COMMENT=133
    LINE_COMMENT=134

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




    class SourceUnitContext(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(SolidityParser.EOF, 0)

        def pragmaDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.PragmaDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.PragmaDirectiveContext,i)


        def importDirective(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDirectiveContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDirectiveContext,i)


        def contractDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractDefinitionContext,i)


        def enumDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,i)


        def structDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StructDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,i)


        def functionDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionDefinitionContext,i)


        def fileLevelConstant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FileLevelConstantContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FileLevelConstantContext,i)


        def customErrorDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.CustomErrorDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.CustomErrorDefinitionContext,i)


        def typeDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.TypeDefinitionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext,i)


        def usingForDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UsingForDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_sourceUnit

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

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




    def sourceUnit(self):

        localctx = SolidityParser.SourceUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_sourceUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 208
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__0) | (1 << SolidityParser.T__12) | (1 << SolidityParser.T__13) | (1 << SolidityParser.T__17) | (1 << SolidityParser.T__18) | (1 << SolidityParser.T__19) | (1 << SolidityParser.T__20) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__25) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.FallbackKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 206
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 196
                    self.pragmaDirective()
                    pass

                elif la_ == 2:
                    self.state = 197
                    self.importDirective()
                    pass

                elif la_ == 3:
                    self.state = 198
                    self.contractDefinition()
                    pass

                elif la_ == 4:
                    self.state = 199
                    self.enumDefinition()
                    pass

                elif la_ == 5:
                    self.state = 200
                    self.structDefinition()
                    pass

                elif la_ == 6:
                    self.state = 201
                    self.functionDefinition()
                    pass

                elif la_ == 7:
                    self.state = 202
                    self.fileLevelConstant()
                    pass

                elif la_ == 8:
                    self.state = 203
                    self.customErrorDefinition()
                    pass

                elif la_ == 9:
                    self.state = 204
                    self.typeDefinition()
                    pass

                elif la_ == 10:
                    self.state = 205
                    self.usingForDeclaration()
                    pass


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

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


    class PragmaDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pragmaName(self):
            return self.getTypedRuleContext(SolidityParser.PragmaNameContext,0)


        def pragmaValue(self):
            return self.getTypedRuleContext(SolidityParser.PragmaValueContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaDirective

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

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




    def pragmaDirective(self):

        localctx = SolidityParser.PragmaDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_pragmaDirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 213
            self.match(SolidityParser.T__0)
            self.state = 214
            self.pragmaName()
            self.state = 215
            self.pragmaValue()
            self.state = 216
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaNameContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaName

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

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




    def pragmaName(self):

        localctx = SolidityParser.PragmaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_pragmaName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 218
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PragmaValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def version(self):
            return self.getTypedRuleContext(SolidityParser.VersionContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_pragmaValue

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

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




    def pragmaValue(self):

        localctx = SolidityParser.PragmaValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_pragmaValue)
        try:
            self.state = 223
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 220
                self.match(SolidityParser.T__2)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 221
                self.version()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 222
                self.expression(0)
                pass


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


    class VersionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def versionConstraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VersionConstraintContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VersionConstraintContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_version

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

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




    def version(self):

        localctx = SolidityParser.VersionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_version)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self.versionConstraint()
            self.state = 232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__3) | (1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0) or _la==SolidityParser.DecimalNumber or _la==SolidityParser.VersionLiteral:
                self.state = 227
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__3:
                    self.state = 226
                    self.match(SolidityParser.T__3)


                self.state = 229
                self.versionConstraint()
                self.state = 234
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class VersionOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SolidityParser.RULE_versionOperator

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

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




    def versionOperator(self):

        localctx = SolidityParser.VersionOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_versionOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 235
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 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 VersionConstraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VersionLiteral(self):
            return self.getToken(SolidityParser.VersionLiteral, 0)

        def versionOperator(self):
            return self.getTypedRuleContext(SolidityParser.VersionOperatorContext,0)


        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_versionConstraint

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

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




    def versionConstraint(self):

        localctx = SolidityParser.VersionConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_versionConstraint)
        self._la = 0 # Token type
        try:
            self.state = 245
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 238
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0):
                    self.state = 237
                    self.versionOperator()


                self.state = 240
                self.match(SolidityParser.VersionLiteral)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 242
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__4) | (1 << SolidityParser.T__5) | (1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9) | (1 << SolidityParser.T__10))) != 0):
                    self.state = 241
                    self.versionOperator()


                self.state = 244
                self.match(SolidityParser.DecimalNumber)
                pass


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


    class ImportDeclarationContext(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.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDeclaration

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

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




    def importDeclaration(self):

        localctx = SolidityParser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_importDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 247
            self.identifier()
            self.state = 250
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__11:
                self.state = 248
                self.match(SolidityParser.T__11)
                self.state = 249
                self.identifier()


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


    class ImportDirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def importPath(self):
            return self.getTypedRuleContext(SolidityParser.ImportPathContext,0)


        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def importDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ImportDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ImportDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_importDirective

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

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




    def importDirective(self):

        localctx = SolidityParser.ImportDirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_importDirective)
        self._la = 0 # Token type
        try:
            self.state = 288
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 252
                self.match(SolidityParser.T__12)
                self.state = 253
                self.importPath()
                self.state = 256
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__11:
                    self.state = 254
                    self.match(SolidityParser.T__11)
                    self.state = 255
                    self.identifier()


                self.state = 258
                self.match(SolidityParser.T__1)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 260
                self.match(SolidityParser.T__12)
                self.state = 263
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.T__2]:
                    self.state = 261
                    self.match(SolidityParser.T__2)
                    pass
                elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__95, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]:
                    self.state = 262
                    self.identifier()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 267
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SolidityParser.T__11:
                    self.state = 265
                    self.match(SolidityParser.T__11)
                    self.state = 266
                    self.identifier()


                self.state = 269
                self.match(SolidityParser.T__13)
                self.state = 270
                self.importPath()
                self.state = 271
                self.match(SolidityParser.T__1)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 273
                self.match(SolidityParser.T__12)
                self.state = 274
                self.match(SolidityParser.T__14)
                self.state = 275
                self.importDeclaration()
                self.state = 280
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 276
                    self.match(SolidityParser.T__15)
                    self.state = 277
                    self.importDeclaration()
                    self.state = 282
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 283
                self.match(SolidityParser.T__16)
                self.state = 284
                self.match(SolidityParser.T__13)
                self.state = 285
                self.importPath()
                self.state = 286
                self.match(SolidityParser.T__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 ImportPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def StringLiteralFragment(self):
            return self.getToken(SolidityParser.StringLiteralFragment, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_importPath

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

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




    def importPath(self):

        localctx = SolidityParser.ImportPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_importPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 290
            self.match(SolidityParser.StringLiteralFragment)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContractDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def inheritanceSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.InheritanceSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.InheritanceSpecifierContext,i)


        def contractPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ContractPartContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ContractPartContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractDefinition

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

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




    def contractDefinition(self):

        localctx = SolidityParser.ContractDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_contractDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__17:
                self.state = 292
                self.match(SolidityParser.T__17)


            self.state = 295
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__18) | (1 << SolidityParser.T__19) | (1 << SolidityParser.T__20))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 296
            self.identifier()
            self.state = 306
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__21:
                self.state = 297
                self.match(SolidityParser.T__21)
                self.state = 298
                self.inheritanceSpecifier()
                self.state = 303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 299
                    self.match(SolidityParser.T__15)
                    self.state = 300
                    self.inheritanceSpecifier()
                    self.state = 305
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 308
            self.match(SolidityParser.T__14)
            self.state = 312
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__25) | (1 << SolidityParser.T__27) | (1 << SolidityParser.T__28) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__31) | (1 << SolidityParser.T__32) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.FallbackKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 309
                self.contractPart()
                self.state = 314
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 315
            self.match(SolidityParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InheritanceSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_inheritanceSpecifier

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

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




    def inheritanceSpecifier(self):

        localctx = SolidityParser.InheritanceSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_inheritanceSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.userDefinedTypeName()
            self.state = 323
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__22:
                self.state = 318
                self.match(SolidityParser.T__22)
                self.state = 320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                    self.state = 319
                    self.expressionList()


                self.state = 322
                self.match(SolidityParser.T__23)


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


    class ContractPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def stateVariableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.StateVariableDeclarationContext,0)


        def usingForDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.UsingForDeclarationContext,0)


        def structDefinition(self):
            return self.getTypedRuleContext(SolidityParser.StructDefinitionContext,0)


        def modifierDefinition(self):
            return self.getTypedRuleContext(SolidityParser.ModifierDefinitionContext,0)


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


        def eventDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EventDefinitionContext,0)


        def enumDefinition(self):
            return self.getTypedRuleContext(SolidityParser.EnumDefinitionContext,0)


        def customErrorDefinition(self):
            return self.getTypedRuleContext(SolidityParser.CustomErrorDefinitionContext,0)


        def typeDefinition(self):
            return self.getTypedRuleContext(SolidityParser.TypeDefinitionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_contractPart

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

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




    def contractPart(self):

        localctx = SolidityParser.ContractPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_contractPart)
        try:
            self.state = 334
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 325
                self.stateVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 326
                self.usingForDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 327
                self.structDefinition()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 328
                self.modifierDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 329
                self.functionDefinition()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 330
                self.eventDefinition()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 331
                self.enumDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 332
                self.customErrorDefinition()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 333
                self.typeDefinition()
                pass


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


    class StateVariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


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

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

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

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

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

        def overrideSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_stateVariableDeclaration

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

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




    def stateVariableDeclaration(self):

        localctx = SolidityParser.StateVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_stateVariableDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self.typeName(0)
            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 97)) & ~0x3f) == 0 and ((1 << (_la - 97)) & ((1 << (SolidityParser.T__96 - 97)) | (1 << (SolidityParser.ConstantKeyword - 97)) | (1 << (SolidityParser.ImmutableKeyword - 97)) | (1 << (SolidityParser.InternalKeyword - 97)) | (1 << (SolidityParser.PrivateKeyword - 97)) | (1 << (SolidityParser.PublicKeyword - 97)))) != 0):
                self.state = 343
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.PublicKeyword]:
                    self.state = 337
                    self.match(SolidityParser.PublicKeyword)
                    pass
                elif token in [SolidityParser.InternalKeyword]:
                    self.state = 338
                    self.match(SolidityParser.InternalKeyword)
                    pass
                elif token in [SolidityParser.PrivateKeyword]:
                    self.state = 339
                    self.match(SolidityParser.PrivateKeyword)
                    pass
                elif token in [SolidityParser.ConstantKeyword]:
                    self.state = 340
                    self.match(SolidityParser.ConstantKeyword)
                    pass
                elif token in [SolidityParser.ImmutableKeyword]:
                    self.state = 341
                    self.match(SolidityParser.ImmutableKeyword)
                    pass
                elif token in [SolidityParser.T__96]:
                    self.state = 342
                    self.overrideSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 348
            self.identifier()
            self.state = 351
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__10:
                self.state = 349
                self.match(SolidityParser.T__10)
                self.state = 350
                self.expression(0)


            self.state = 353
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FileLevelConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_fileLevelConstant

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

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




    def fileLevelConstant(self):

        localctx = SolidityParser.FileLevelConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_fileLevelConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 355
            self.typeName(0)
            self.state = 356
            self.match(SolidityParser.ConstantKeyword)
            self.state = 357
            self.identifier()
            self.state = 358
            self.match(SolidityParser.T__10)
            self.state = 359
            self.expression(0)
            self.state = 360
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CustomErrorDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_customErrorDefinition

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

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




    def customErrorDefinition(self):

        localctx = SolidityParser.CustomErrorDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_customErrorDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 362
            self.match(SolidityParser.T__24)
            self.state = 363
            self.identifier()
            self.state = 364
            self.parameterList()
            self.state = 365
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TypeKeyword(self):
            return self.getToken(SolidityParser.TypeKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_typeDefinition

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

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




    def typeDefinition(self):

        localctx = SolidityParser.TypeDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_typeDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 367
            self.match(SolidityParser.TypeKeyword)
            self.state = 368
            self.identifier()
            self.state = 369
            self.match(SolidityParser.T__21)
            self.state = 370
            self.elementaryTypeName()
            self.state = 371
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def usingForObject(self):
            return self.getTypedRuleContext(SolidityParser.UsingForObjectContext,0)


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


        def GlobalKeyword(self):
            return self.getToken(SolidityParser.GlobalKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_usingForDeclaration

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

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




    def usingForDeclaration(self):

        localctx = SolidityParser.UsingForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_usingForDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            self.match(SolidityParser.T__25)
            self.state = 374
            self.usingForObject()
            self.state = 375
            self.match(SolidityParser.T__26)
            self.state = 378
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__2]:
                self.state = 376
                self.match(SolidityParser.T__2)
                pass
            elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__35, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__95, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]:
                self.state = 377
                self.typeName(0)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 381
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.GlobalKeyword:
                self.state = 380
                self.match(SolidityParser.GlobalKeyword)


            self.state = 383
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UsingForObjectContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def userDefinedTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UserDefinedTypeNameContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_usingForObject

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

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




    def usingForObject(self):

        localctx = SolidityParser.UsingForObjectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_usingForObject)
        self._la = 0 # Token type
        try:
            self.state = 397
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__95, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 385
                self.userDefinedTypeName()
                pass
            elif token in [SolidityParser.T__14]:
                self.enterOuterAlt(localctx, 2)
                self.state = 386
                self.match(SolidityParser.T__14)
                self.state = 387
                self.userDefinedTypeName()
                self.state = 392
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 388
                    self.match(SolidityParser.T__15)
                    self.state = 389
                    self.userDefinedTypeName()
                    self.state = 394
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 395
                self.match(SolidityParser.T__16)
                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 StructDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_structDefinition

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

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




    def structDefinition(self):

        localctx = SolidityParser.StructDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_structDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.match(SolidityParser.T__27)
            self.state = 400
            self.identifier()
            self.state = 401
            self.match(SolidityParser.T__14)
            self.state = 412
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 402
                self.variableDeclaration()
                self.state = 403
                self.match(SolidityParser.T__1)
                self.state = 409
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                    self.state = 404
                    self.variableDeclaration()
                    self.state = 405
                    self.match(SolidityParser.T__1)
                    self.state = 411
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 414
            self.match(SolidityParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


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


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

        def overrideSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierDefinition

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

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




    def modifierDefinition(self):

        localctx = SolidityParser.ModifierDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_modifierDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 416
            self.match(SolidityParser.T__28)
            self.state = 417
            self.identifier()
            self.state = 419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__22:
                self.state = 418
                self.parameterList()


            self.state = 425
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__96 or _la==SolidityParser.VirtualKeyword:
                self.state = 423
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SolidityParser.VirtualKeyword]:
                    self.state = 421
                    self.match(SolidityParser.VirtualKeyword)
                    pass
                elif token in [SolidityParser.T__96]:
                    self.state = 422
                    self.overrideSpecifier()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 430
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__1]:
                self.state = 428
                self.match(SolidityParser.T__1)
                pass
            elif token in [SolidityParser.T__14]:
                self.state = 429
                self.block()
                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 ModifierInvocationContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierInvocation

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

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




    def modifierInvocation(self):

        localctx = SolidityParser.ModifierInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_modifierInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 432
            self.identifier()
            self.state = 438
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__22:
                self.state = 433
                self.match(SolidityParser.T__22)
                self.state = 435
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                    self.state = 434
                    self.expressionList()


                self.state = 437
                self.match(SolidityParser.T__23)


        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 functionDescriptor(self):
            return self.getTypedRuleContext(SolidityParser.FunctionDescriptorContext,0)


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


        def modifierList(self):
            return self.getTypedRuleContext(SolidityParser.ModifierListContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def returnParameters(self):
            return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionDefinition

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

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




    def functionDefinition(self):

        localctx = SolidityParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 440
            self.functionDescriptor()
            self.state = 441
            self.parameterList()
            self.state = 442
            self.modifierList()
            self.state = 444
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__30:
                self.state = 443
                self.returnParameters()


            self.state = 448
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__1]:
                self.state = 446
                self.match(SolidityParser.T__1)
                pass
            elif token in [SolidityParser.T__14]:
                self.state = 447
                self.block()
                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 FunctionDescriptorContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def ConstructorKeyword(self):
            return self.getToken(SolidityParser.ConstructorKeyword, 0)

        def FallbackKeyword(self):
            return self.getToken(SolidityParser.FallbackKeyword, 0)

        def ReceiveKeyword(self):
            return self.getToken(SolidityParser.ReceiveKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_functionDescriptor

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

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




    def functionDescriptor(self):

        localctx = SolidityParser.FunctionDescriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_functionDescriptor)
        self._la = 0 # Token type
        try:
            self.state = 457
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__29]:
                self.enterOuterAlt(localctx, 1)
                self.state = 450
                self.match(SolidityParser.T__29)
                self.state = 452
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                    self.state = 451
                    self.identifier()


                pass
            elif token in [SolidityParser.ConstructorKeyword]:
                self.enterOuterAlt(localctx, 2)
                self.state = 454
                self.match(SolidityParser.ConstructorKeyword)
                pass
            elif token in [SolidityParser.FallbackKeyword]:
                self.enterOuterAlt(localctx, 3)
                self.state = 455
                self.match(SolidityParser.FallbackKeyword)
                pass
            elif token in [SolidityParser.ReceiveKeyword]:
                self.enterOuterAlt(localctx, 4)
                self.state = 456
                self.match(SolidityParser.ReceiveKeyword)
                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 ReturnParametersContext(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(SolidityParser.ParameterListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_returnParameters

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

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




    def returnParameters(self):

        localctx = SolidityParser.ReturnParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_returnParameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.match(SolidityParser.T__30)
            self.state = 460
            self.parameterList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def modifierInvocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ModifierInvocationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ModifierInvocationContext,i)


        def overrideSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.OverrideSpecifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.OverrideSpecifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_modifierList

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

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




    def modifierList(self):

        localctx = SolidityParser.ModifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_modifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 472
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.T__96 - 96)) | (1 << (SolidityParser.ConstantKeyword - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.ExternalKeyword - 96)) | (1 << (SolidityParser.InternalKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.PrivateKeyword - 96)) | (1 << (SolidityParser.PublicKeyword - 96)) | (1 << (SolidityParser.VirtualKeyword - 96)) | (1 << (SolidityParser.PureKeyword - 96)) | (1 << (SolidityParser.ViewKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 470
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
                if la_ == 1:
                    self.state = 462
                    self.match(SolidityParser.ExternalKeyword)
                    pass

                elif la_ == 2:
                    self.state = 463
                    self.match(SolidityParser.PublicKeyword)
                    pass

                elif la_ == 3:
                    self.state = 464
                    self.match(SolidityParser.InternalKeyword)
                    pass

                elif la_ == 4:
                    self.state = 465
                    self.match(SolidityParser.PrivateKeyword)
                    pass

                elif la_ == 5:
                    self.state = 466
                    self.match(SolidityParser.VirtualKeyword)
                    pass

                elif la_ == 6:
                    self.state = 467
                    self.stateMutability()
                    pass

                elif la_ == 7:
                    self.state = 468
                    self.modifierInvocation()
                    pass

                elif la_ == 8:
                    self.state = 469
                    self.overrideSpecifier()
                    pass


                self.state = 474
                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 EventDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def eventParameterList(self):
            return self.getTypedRuleContext(SolidityParser.EventParameterListContext,0)


        def AnonymousKeyword(self):
            return self.getToken(SolidityParser.AnonymousKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_eventDefinition

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

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




    def eventDefinition(self):

        localctx = SolidityParser.EventDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_eventDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 475
            self.match(SolidityParser.T__31)
            self.state = 476
            self.identifier()
            self.state = 477
            self.eventParameterList()
            self.state = 479
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.AnonymousKeyword:
                self.state = 478
                self.match(SolidityParser.AnonymousKeyword)


            self.state = 481
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumValueContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumValue

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

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




    def enumValue(self):

        localctx = SolidityParser.EnumValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_enumValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 483
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def enumValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EnumValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EnumValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_enumDefinition

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

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




    def enumDefinition(self):

        localctx = SolidityParser.EnumDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_enumDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 485
            self.match(SolidityParser.T__32)
            self.state = 486
            self.identifier()
            self.state = 487
            self.match(SolidityParser.T__14)
            self.state = 489
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 488
                self.enumValue()


            self.state = 495
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__15:
                self.state = 491
                self.match(SolidityParser.T__15)
                self.state = 492
                self.enumValue()
                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 498
            self.match(SolidityParser.T__16)
        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 parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.ParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.ParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameterList

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

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




    def parameterList(self):

        localctx = SolidityParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_parameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 500
            self.match(SolidityParser.T__22)
            self.state = 509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 501
                self.parameter()
                self.state = 506
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 502
                    self.match(SolidityParser.T__15)
                    self.state = 503
                    self.parameter()
                    self.state = 508
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 511
            self.match(SolidityParser.T__23)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_parameter

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

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




    def parameter(self):

        localctx = SolidityParser.ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 513
            self.typeName(0)
            self.state = 515
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 514
                self.storageLocation()


            self.state = 518
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 517
                self.identifier()


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


    class EventParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def eventParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.EventParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.EventParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameterList

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

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




    def eventParameterList(self):

        localctx = SolidityParser.EventParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_eventParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 520
            self.match(SolidityParser.T__22)
            self.state = 529
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 521
                self.eventParameter()
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 522
                    self.match(SolidityParser.T__15)
                    self.state = 523
                    self.eventParameter()
                    self.state = 528
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 531
            self.match(SolidityParser.T__23)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EventParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def IndexedKeyword(self):
            return self.getToken(SolidityParser.IndexedKeyword, 0)

        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_eventParameter

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

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




    def eventParameter(self):

        localctx = SolidityParser.EventParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_eventParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 533
            self.typeName(0)
            self.state = 535
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.IndexedKeyword:
                self.state = 534
                self.match(SolidityParser.IndexedKeyword)


            self.state = 538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 537
                self.identifier()


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


    class FunctionTypeParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionTypeParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameterList

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

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




    def functionTypeParameterList(self):

        localctx = SolidityParser.FunctionTypeParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_functionTypeParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 540
            self.match(SolidityParser.T__22)
            self.state = 549
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 541
                self.functionTypeParameter()
                self.state = 546
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 542
                    self.match(SolidityParser.T__15)
                    self.state = 543
                    self.functionTypeParameter()
                    self.state = 548
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 551
            self.match(SolidityParser.T__23)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeParameter

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

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




    def functionTypeParameter(self):

        localctx = SolidityParser.FunctionTypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_functionTypeParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 553
            self.typeName(0)
            self.state = 555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__39) | (1 << SolidityParser.T__40) | (1 << SolidityParser.T__41))) != 0):
                self.state = 554
                self.storageLocation()


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


    class VariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def storageLocation(self):
            return self.getTypedRuleContext(SolidityParser.StorageLocationContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclaration

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

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




    def variableDeclaration(self):

        localctx = SolidityParser.VariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_variableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 557
            self.typeName(0)
            self.state = 559
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
            if la_ == 1:
                self.state = 558
                self.storageLocation()


            self.state = 561
            self.identifier()
        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 elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def mapping(self):
            return self.getTypedRuleContext(SolidityParser.MappingContext,0)


        def functionTypeName(self):
            return self.getTypedRuleContext(SolidityParser.FunctionTypeNameContext,0)


        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

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


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


        def getRuleIndex(self):
            return SolidityParser.RULE_typeName

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

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



    def typeName(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.TypeNameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 72
        self.enterRecursionRule(localctx, 72, self.RULE_typeName, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 570
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 564
                self.elementaryTypeName()
                pass

            elif la_ == 2:
                self.state = 565
                self.userDefinedTypeName()
                pass

            elif la_ == 3:
                self.state = 566
                self.mapping()
                pass

            elif la_ == 4:
                self.state = 567
                self.functionTypeName()
                pass

            elif la_ == 5:
                self.state = 568
                self.match(SolidityParser.T__35)
                self.state = 569
                self.match(SolidityParser.PayableKeyword)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 580
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,59,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SolidityParser.TypeNameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeName)
                    self.state = 572
                    if not self.precpred(self._ctx, 3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                    self.state = 573
                    self.match(SolidityParser.T__33)
                    self.state = 575
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                        self.state = 574
                        self.expression(0)


                    self.state = 577
                    self.match(SolidityParser.T__34) 
                self.state = 582
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,59,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 UserDefinedTypeNameContext(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.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_userDefinedTypeName

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

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




    def userDefinedTypeName(self):

        localctx = SolidityParser.UserDefinedTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_userDefinedTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 583
            self.identifier()
            self.state = 588
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 584
                    self.match(SolidityParser.T__36)
                    self.state = 585
                    self.identifier() 
                self.state = 590
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,60,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 MappingKeyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def elementaryTypeName(self):
            return self.getTypedRuleContext(SolidityParser.ElementaryTypeNameContext,0)


        def userDefinedTypeName(self):
            return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_mappingKey

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

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




    def mappingKey(self):

        localctx = SolidityParser.MappingKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_mappingKey)
        try:
            self.state = 593
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__35, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed]:
                self.enterOuterAlt(localctx, 1)
                self.state = 591
                self.elementaryTypeName()
                pass
            elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__95, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 592
                self.userDefinedTypeName()
                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 MappingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def mappingKey(self):
            return self.getTypedRuleContext(SolidityParser.MappingKeyContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_mapping

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

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




    def mapping(self):

        localctx = SolidityParser.MappingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_mapping)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 595
            self.match(SolidityParser.T__37)
            self.state = 596
            self.match(SolidityParser.T__22)
            self.state = 597
            self.mappingKey()
            self.state = 598
            self.match(SolidityParser.T__38)
            self.state = 599
            self.typeName(0)
            self.state = 600
            self.match(SolidityParser.T__23)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionTypeParameterList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.FunctionTypeParameterListContext)
            else:
                return self.getTypedRuleContext(SolidityParser.FunctionTypeParameterListContext,i)


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

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

        def stateMutability(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.StateMutabilityContext)
            else:
                return self.getTypedRuleContext(SolidityParser.StateMutabilityContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionTypeName

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

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




    def functionTypeName(self):

        localctx = SolidityParser.FunctionTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_functionTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 602
            self.match(SolidityParser.T__29)
            self.state = 603
            self.functionTypeParameterList()
            self.state = 609
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,63,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 607
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SolidityParser.InternalKeyword]:
                        self.state = 604
                        self.match(SolidityParser.InternalKeyword)
                        pass
                    elif token in [SolidityParser.ExternalKeyword]:
                        self.state = 605
                        self.match(SolidityParser.ExternalKeyword)
                        pass
                    elif token in [SolidityParser.ConstantKeyword, SolidityParser.PayableKeyword, SolidityParser.PureKeyword, SolidityParser.ViewKeyword]:
                        self.state = 606
                        self.stateMutability()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 611
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,63,self._ctx)

            self.state = 614
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                self.state = 612
                self.match(SolidityParser.T__30)
                self.state = 613
                self.functionTypeParameterList()


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


    class StorageLocationContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SolidityParser.RULE_storageLocation

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

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




    def storageLocation(self):

        localctx = SolidityParser.StorageLocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_storageLocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 616
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__39) | (1 << SolidityParser.T__40) | (1 << SolidityParser.T__41))) != 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 StateMutabilityContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PureKeyword(self):
            return self.getToken(SolidityParser.PureKeyword, 0)

        def ConstantKeyword(self):
            return self.getToken(SolidityParser.ConstantKeyword, 0)

        def ViewKeyword(self):
            return self.getToken(SolidityParser.ViewKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_stateMutability

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

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




    def stateMutability(self):

        localctx = SolidityParser.StateMutabilityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_stateMutability)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 618
            _la = self._input.LA(1)
            if not(((((_la - 111)) & ~0x3f) == 0 and ((1 << (_la - 111)) & ((1 << (SolidityParser.ConstantKeyword - 111)) | (1 << (SolidityParser.PayableKeyword - 111)) | (1 << (SolidityParser.PureKeyword - 111)) | (1 << (SolidityParser.ViewKeyword - 111)))) != 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 BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return SolidityParser.RULE_block

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

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




    def block(self):

        localctx = SolidityParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 620
            self.match(SolidityParser.T__14)
            self.state = 624
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__14 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__26 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__42 - 6)) | (1 << (SolidityParser.T__44 - 6)) | (1 << (SolidityParser.T__46 - 6)) | (1 << (SolidityParser.T__47 - 6)) | (1 << (SolidityParser.T__48 - 6)) | (1 << (SolidityParser.T__49 - 6)) | (1 << (SolidityParser.T__50 - 6)) | (1 << (SolidityParser.T__51 - 6)) | (1 << (SolidityParser.T__52 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.BreakKeyword - 96)) | (1 << (SolidityParser.ContinueKeyword - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                self.state = 621
                self.statement()
                self.state = 626
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 627
            self.match(SolidityParser.T__16)
        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 ifStatement(self):
            return self.getTypedRuleContext(SolidityParser.IfStatementContext,0)


        def tryStatement(self):
            return self.getTypedRuleContext(SolidityParser.TryStatementContext,0)


        def whileStatement(self):
            return self.getTypedRuleContext(SolidityParser.WhileStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(SolidityParser.ForStatementContext,0)


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def inlineAssemblyStatement(self):
            return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementContext,0)


        def doWhileStatement(self):
            return self.getTypedRuleContext(SolidityParser.DoWhileStatementContext,0)


        def continueStatement(self):
            return self.getTypedRuleContext(SolidityParser.ContinueStatementContext,0)


        def breakStatement(self):
            return self.getTypedRuleContext(SolidityParser.BreakStatementContext,0)


        def returnStatement(self):
            return self.getTypedRuleContext(SolidityParser.ReturnStatementContext,0)


        def throwStatement(self):
            return self.getTypedRuleContext(SolidityParser.ThrowStatementContext,0)


        def emitStatement(self):
            return self.getTypedRuleContext(SolidityParser.EmitStatementContext,0)


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


        def uncheckedStatement(self):
            return self.getTypedRuleContext(SolidityParser.UncheckedStatementContext,0)


        def revertStatement(self):
            return self.getTypedRuleContext(SolidityParser.RevertStatementContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_statement

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

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




    def statement(self):

        localctx = SolidityParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_statement)
        try:
            self.state = 644
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 629
                self.ifStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 630
                self.tryStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 631
                self.whileStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 632
                self.forStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 633
                self.block()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 634
                self.inlineAssemblyStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 635
                self.doWhileStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 636
                self.continueStatement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 637
                self.breakStatement()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 638
                self.returnStatement()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 639
                self.throwStatement()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 640
                self.emitStatement()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 641
                self.simpleStatement()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 642
                self.uncheckedStatement()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 643
                self.revertStatement()
                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 expression(self):
            return self.getTypedRuleContext(SolidityParser.ExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionStatement

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

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




    def expressionStatement(self):

        localctx = SolidityParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_expressionStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 646
            self.expression(0)
            self.state = 647
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return SolidityParser.RULE_ifStatement

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

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




    def ifStatement(self):

        localctx = SolidityParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_ifStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 649
            self.match(SolidityParser.T__42)
            self.state = 650
            self.match(SolidityParser.T__22)
            self.state = 651
            self.expression(0)
            self.state = 652
            self.match(SolidityParser.T__23)
            self.state = 653
            self.statement()
            self.state = 656
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                self.state = 654
                self.match(SolidityParser.T__43)
                self.state = 655
                self.statement()


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


    class TryStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def returnParameters(self):
            return self.getTypedRuleContext(SolidityParser.ReturnParametersContext,0)


        def catchClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.CatchClauseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.CatchClauseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_tryStatement

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

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




    def tryStatement(self):

        localctx = SolidityParser.TryStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_tryStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 658
            self.match(SolidityParser.T__44)
            self.state = 659
            self.expression(0)
            self.state = 661
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__30:
                self.state = 660
                self.returnParameters()


            self.state = 663
            self.block()
            self.state = 665 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 664
                self.catchClause()
                self.state = 667 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SolidityParser.T__45):
                    break

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


    class CatchClauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


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


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_catchClause

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

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




    def catchClause(self):

        localctx = SolidityParser.CatchClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_catchClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 669
            self.match(SolidityParser.T__45)
            self.state = 674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__22) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 671
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                    self.state = 670
                    self.identifier()


                self.state = 673
                self.parameterList()


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


    class WhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return SolidityParser.RULE_whileStatement

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

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




    def whileStatement(self):

        localctx = SolidityParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 678
            self.match(SolidityParser.T__46)
            self.state = 679
            self.match(SolidityParser.T__22)
            self.state = 680
            self.expression(0)
            self.state = 681
            self.match(SolidityParser.T__23)
            self.state = 682
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SimpleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclarationStatement(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationStatementContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_simpleStatement

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

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




    def simpleStatement(self):

        localctx = SolidityParser.SimpleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_simpleStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 686
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 684
                self.variableDeclarationStatement()
                pass

            elif la_ == 2:
                self.state = 685
                self.expressionStatement()
                pass


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


    class UncheckedStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def block(self):
            return self.getTypedRuleContext(SolidityParser.BlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_uncheckedStatement

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

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




    def uncheckedStatement(self):

        localctx = SolidityParser.UncheckedStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_uncheckedStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 688
            self.match(SolidityParser.T__47)
            self.state = 689
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def simpleStatement(self):
            return self.getTypedRuleContext(SolidityParser.SimpleStatementContext,0)


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


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


        def getRuleIndex(self):
            return SolidityParser.RULE_forStatement

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

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




    def forStatement(self):

        localctx = SolidityParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 691
            self.match(SolidityParser.T__26)
            self.state = 692
            self.match(SolidityParser.T__22)
            self.state = 695
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__5, SolidityParser.T__13, SolidityParser.T__22, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__33, SolidityParser.T__35, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__95, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]:
                self.state = 693
                self.simpleStatement()
                pass
            elif token in [SolidityParser.T__1]:
                self.state = 694
                self.match(SolidityParser.T__1)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 699
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__5, SolidityParser.T__13, SolidityParser.T__22, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__33, SolidityParser.T__35, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__95, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]:
                self.state = 697
                self.expressionStatement()
                pass
            elif token in [SolidityParser.T__1]:
                self.state = 698
                self.match(SolidityParser.T__1)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 702
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                self.state = 701
                self.expression(0)


            self.state = 704
            self.match(SolidityParser.T__23)
            self.state = 705
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InlineAssemblyStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def StringLiteralFragment(self):
            return self.getToken(SolidityParser.StringLiteralFragment, 0)

        def inlineAssemblyStatementFlag(self):
            return self.getTypedRuleContext(SolidityParser.InlineAssemblyStatementFlagContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_inlineAssemblyStatement

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

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




    def inlineAssemblyStatement(self):

        localctx = SolidityParser.InlineAssemblyStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_inlineAssemblyStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 707
            self.match(SolidityParser.T__48)
            self.state = 709
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.StringLiteralFragment:
                self.state = 708
                self.match(SolidityParser.StringLiteralFragment)


            self.state = 715
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__22:
                self.state = 711
                self.match(SolidityParser.T__22)
                self.state = 712
                self.inlineAssemblyStatementFlag()
                self.state = 713
                self.match(SolidityParser.T__23)


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


    class InlineAssemblyStatementFlagContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_inlineAssemblyStatementFlag

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

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




    def inlineAssemblyStatementFlag(self):

        localctx = SolidityParser.InlineAssemblyStatementFlagContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_inlineAssemblyStatementFlag)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 719
            self.stringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DoWhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return SolidityParser.RULE_doWhileStatement

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

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




    def doWhileStatement(self):

        localctx = SolidityParser.DoWhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_doWhileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 721
            self.match(SolidityParser.T__49)
            self.state = 722
            self.statement()
            self.state = 723
            self.match(SolidityParser.T__46)
            self.state = 724
            self.match(SolidityParser.T__22)
            self.state = 725
            self.expression(0)
            self.state = 726
            self.match(SolidityParser.T__23)
            self.state = 727
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContinueStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_continueStatement

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

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




    def continueStatement(self):

        localctx = SolidityParser.ContinueStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_continueStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 729
            self.match(SolidityParser.ContinueKeyword)
            self.state = 730
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BreakStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_breakStatement

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

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




    def breakStatement(self):

        localctx = SolidityParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_breakStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 732
            self.match(SolidityParser.BreakKeyword)
            self.state = 733
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return SolidityParser.RULE_returnStatement

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

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




    def returnStatement(self):

        localctx = SolidityParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_returnStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 735
            self.match(SolidityParser.T__50)
            self.state = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                self.state = 736
                self.expression(0)


            self.state = 739
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ThrowStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return SolidityParser.RULE_throwStatement

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

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




    def throwStatement(self):

        localctx = SolidityParser.ThrowStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_throwStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 741
            self.match(SolidityParser.T__51)
            self.state = 742
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EmitStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return SolidityParser.RULE_emitStatement

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

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




    def emitStatement(self):

        localctx = SolidityParser.EmitStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_emitStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.match(SolidityParser.T__52)
            self.state = 745
            self.functionCall()
            self.state = 746
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RevertStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return SolidityParser.RULE_revertStatement

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

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




    def revertStatement(self):

        localctx = SolidityParser.RevertStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_revertStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 748
            self.match(SolidityParser.T__53)
            self.state = 749
            self.functionCall()
            self.state = 750
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def variableDeclaration(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,0)


        def variableDeclarationList(self):
            return self.getTypedRuleContext(SolidityParser.VariableDeclarationListContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationStatement

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

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




    def variableDeclarationStatement(self):

        localctx = SolidityParser.VariableDeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_variableDeclarationStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 752
                self.match(SolidityParser.T__54)
                self.state = 753
                self.identifierList()
                pass

            elif la_ == 2:
                self.state = 754
                self.variableDeclaration()
                pass

            elif la_ == 3:
                self.state = 755
                self.match(SolidityParser.T__22)
                self.state = 756
                self.variableDeclarationList()
                self.state = 757
                self.match(SolidityParser.T__23)
                pass


            self.state = 763
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__10:
                self.state = 761
                self.match(SolidityParser.T__10)
                self.state = 762
                self.expression(0)


            self.state = 765
            self.match(SolidityParser.T__1)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.VariableDeclarationContext)
            else:
                return self.getTypedRuleContext(SolidityParser.VariableDeclarationContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_variableDeclarationList

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

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




    def variableDeclarationList(self):

        localctx = SolidityParser.VariableDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_variableDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 768
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 767
                self.variableDeclaration()


            self.state = 776
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__15:
                self.state = 770
                self.match(SolidityParser.T__15)
                self.state = 772
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__37) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                    self.state = 771
                    self.variableDeclaration()


                self.state = 778
                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 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.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_identifierList

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

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




    def identifierList(self):

        localctx = SolidityParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            self.match(SolidityParser.T__22)
            self.state = 786
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 781
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                        self.state = 780
                        self.identifier()


                    self.state = 783
                    self.match(SolidityParser.T__15) 
                self.state = 788
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,85,self._ctx)

            self.state = 790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 789
                self.identifier()


            self.state = 792
            self.match(SolidityParser.T__23)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElementaryTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def Uint(self):
            return self.getToken(SolidityParser.Uint, 0)

        def Byte(self):
            return self.getToken(SolidityParser.Byte, 0)

        def Fixed(self):
            return self.getToken(SolidityParser.Fixed, 0)

        def Ufixed(self):
            return self.getToken(SolidityParser.Ufixed, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_elementaryTypeName

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

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




    def elementaryTypeName(self):

        localctx = SolidityParser.ElementaryTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_elementaryTypeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 794
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__35) | (1 << SolidityParser.T__54) | (1 << SolidityParser.T__55) | (1 << SolidityParser.T__56) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 98)) & ~0x3f) == 0 and ((1 << (_la - 98)) & ((1 << (SolidityParser.Int - 98)) | (1 << (SolidityParser.Uint - 98)) | (1 << (SolidityParser.Byte - 98)) | (1 << (SolidityParser.Fixed - 98)) | (1 << (SolidityParser.Ufixed - 98)))) != 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 typeName(self):
            return self.getTypedRuleContext(SolidityParser.TypeNameContext,0)


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


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


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def nameValueList(self):
            return self.getTypedRuleContext(SolidityParser.NameValueListContext,0)


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_expression

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

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



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SolidityParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 132
        self.enterRecursionRule(localctx, 132, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 814
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 797
                self.match(SolidityParser.T__60)
                self.state = 798
                self.typeName(0)
                pass

            elif la_ == 2:
                self.state = 799
                self.match(SolidityParser.T__22)
                self.state = 800
                self.expression(0)
                self.state = 801
                self.match(SolidityParser.T__23)
                pass

            elif la_ == 3:
                self.state = 803
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__58 or _la==SolidityParser.T__59):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 804
                self.expression(19)
                pass

            elif la_ == 4:
                self.state = 805
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__62 or _la==SolidityParser.T__63):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 806
                self.expression(18)
                pass

            elif la_ == 5:
                self.state = 807
                _la = self._input.LA(1)
                if not(_la==SolidityParser.T__64 or _la==SolidityParser.T__65):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 808
                self.expression(17)
                pass

            elif la_ == 6:
                self.state = 809
                self.match(SolidityParser.T__66)
                self.state = 810
                self.expression(16)
                pass

            elif la_ == 7:
                self.state = 811
                self.match(SolidityParser.T__5)
                self.state = 812
                self.expression(15)
                pass

            elif la_ == 8:
                self.state = 813
                self.primaryExpression()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 890
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,91,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 = 888
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
                    if la_ == 1:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 816
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 817
                        self.match(SolidityParser.T__67)
                        self.state = 818
                        self.expression(15)
                        pass

                    elif la_ == 2:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 819
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 820
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__2 or _la==SolidityParser.T__68 or _la==SolidityParser.T__69):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 821
                        self.expression(14)
                        pass

                    elif la_ == 3:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 822
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 823
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__62 or _la==SolidityParser.T__63):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 824
                        self.expression(13)
                        pass

                    elif la_ == 4:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 825
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 826
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__70 or _la==SolidityParser.T__71):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 827
                        self.expression(12)
                        pass

                    elif la_ == 5:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 828
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 829
                        self.match(SolidityParser.T__72)
                        self.state = 830
                        self.expression(11)
                        pass

                    elif la_ == 6:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 831
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 832
                        self.match(SolidityParser.T__4)
                        self.state = 833
                        self.expression(10)
                        pass

                    elif la_ == 7:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 834
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 835
                        self.match(SolidityParser.T__73)
                        self.state = 836
                        self.expression(9)
                        pass

                    elif la_ == 8:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 837
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 838
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__6) | (1 << SolidityParser.T__7) | (1 << SolidityParser.T__8) | (1 << SolidityParser.T__9))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 839
                        self.expression(8)
                        pass

                    elif la_ == 9:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 840
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 841
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__74 or _la==SolidityParser.T__75):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 842
                        self.expression(7)
                        pass

                    elif la_ == 10:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 843
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 844
                        self.match(SolidityParser.T__76)
                        self.state = 845
                        self.expression(6)
                        pass

                    elif la_ == 11:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 846
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 847
                        self.match(SolidityParser.T__3)
                        self.state = 848
                        self.expression(5)
                        pass

                    elif la_ == 12:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 849
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 850
                        self.match(SolidityParser.T__77)
                        self.state = 851
                        self.expression(0)
                        self.state = 852
                        self.match(SolidityParser.T__61)
                        self.state = 853
                        self.expression(4)
                        pass

                    elif la_ == 13:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 855
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 856
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__10 or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (SolidityParser.T__78 - 79)) | (1 << (SolidityParser.T__79 - 79)) | (1 << (SolidityParser.T__80 - 79)) | (1 << (SolidityParser.T__81 - 79)) | (1 << (SolidityParser.T__82 - 79)) | (1 << (SolidityParser.T__83 - 79)) | (1 << (SolidityParser.T__84 - 79)) | (1 << (SolidityParser.T__85 - 79)) | (1 << (SolidityParser.T__86 - 79)) | (1 << (SolidityParser.T__87 - 79)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 857
                        self.expression(3)
                        pass

                    elif la_ == 14:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 858
                        if not self.precpred(self._ctx, 27):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 27)")
                        self.state = 859
                        _la = self._input.LA(1)
                        if not(_la==SolidityParser.T__58 or _la==SolidityParser.T__59):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

                    elif la_ == 15:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 860
                        if not self.precpred(self._ctx, 25):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 25)")
                        self.state = 861
                        self.match(SolidityParser.T__33)
                        self.state = 862
                        self.expression(0)
                        self.state = 863
                        self.match(SolidityParser.T__34)
                        pass

                    elif la_ == 16:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 865
                        if not self.precpred(self._ctx, 24):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 24)")
                        self.state = 866
                        self.match(SolidityParser.T__33)
                        self.state = 868
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                            self.state = 867
                            self.expression(0)


                        self.state = 870
                        self.match(SolidityParser.T__61)
                        self.state = 872
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                            self.state = 871
                            self.expression(0)


                        self.state = 874
                        self.match(SolidityParser.T__34)
                        pass

                    elif la_ == 17:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 875
                        if not self.precpred(self._ctx, 23):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 23)")
                        self.state = 876
                        self.match(SolidityParser.T__36)
                        self.state = 877
                        self.identifier()
                        pass

                    elif la_ == 18:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 878
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 879
                        self.match(SolidityParser.T__14)
                        self.state = 880
                        self.nameValueList()
                        self.state = 881
                        self.match(SolidityParser.T__16)
                        pass

                    elif la_ == 19:
                        localctx = SolidityParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 883
                        if not self.precpred(self._ctx, 21):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                        self.state = 884
                        self.match(SolidityParser.T__22)
                        self.state = 885
                        self.functionCallArguments()
                        self.state = 886
                        self.match(SolidityParser.T__23)
                        pass

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

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

        def BooleanLiteral(self):
            return self.getToken(SolidityParser.BooleanLiteral, 0)

        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def hexLiteral(self):
            return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0)


        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def TypeKeyword(self):
            return self.getToken(SolidityParser.TypeKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def tupleExpression(self):
            return self.getTypedRuleContext(SolidityParser.TupleExpressionContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_primaryExpression

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

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




    def primaryExpression(self):

        localctx = SolidityParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_primaryExpression)
        try:
            self.state = 902
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 893
                self.match(SolidityParser.BooleanLiteral)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 894
                self.numberLiteral()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 895
                self.hexLiteral()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 896
                self.stringLiteral()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 897
                self.identifier()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 898
                self.match(SolidityParser.TypeKeyword)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 899
                self.match(SolidityParser.PayableKeyword)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 900
                self.tupleExpression()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 901
                self.typeName(0)
                pass


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


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return SolidityParser.RULE_expressionList

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

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




    def expressionList(self):

        localctx = SolidityParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 904
            self.expression(0)
            self.state = 909
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__15:
                self.state = 905
                self.match(SolidityParser.T__15)
                self.state = 906
                self.expression(0)
                self.state = 911
                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 NameValueListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nameValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.NameValueContext)
            else:
                return self.getTypedRuleContext(SolidityParser.NameValueContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_nameValueList

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

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




    def nameValueList(self):

        localctx = SolidityParser.NameValueListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_nameValueList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 912
            self.nameValue()
            self.state = 917
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 913
                    self.match(SolidityParser.T__15)
                    self.state = 914
                    self.nameValue() 
                self.state = 919
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,94,self._ctx)

            self.state = 921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__15:
                self.state = 920
                self.match(SolidityParser.T__15)


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


    class NameValueContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_nameValue

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

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




    def nameValue(self):

        localctx = SolidityParser.NameValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_nameValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 923
            self.identifier()
            self.state = 924
            self.match(SolidityParser.T__61)
            self.state = 925
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nameValueList(self):
            return self.getTypedRuleContext(SolidityParser.NameValueListContext,0)


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


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCallArguments

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

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




    def functionCallArguments(self):

        localctx = SolidityParser.FunctionCallArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_functionCallArguments)
        self._la = 0 # Token type
        try:
            self.state = 935
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__14]:
                self.enterOuterAlt(localctx, 1)
                self.state = 927
                self.match(SolidityParser.T__14)
                self.state = 929
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                    self.state = 928
                    self.nameValueList()


                self.state = 931
                self.match(SolidityParser.T__16)
                pass
            elif token in [SolidityParser.T__5, SolidityParser.T__13, SolidityParser.T__22, SolidityParser.T__23, SolidityParser.T__24, SolidityParser.T__29, SolidityParser.T__33, SolidityParser.T__35, SolidityParser.T__37, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__54, SolidityParser.T__55, SolidityParser.T__56, SolidityParser.T__57, SolidityParser.T__58, SolidityParser.T__59, SolidityParser.T__60, SolidityParser.T__62, SolidityParser.T__63, SolidityParser.T__64, SolidityParser.T__65, SolidityParser.T__66, SolidityParser.T__95, SolidityParser.Int, SolidityParser.Uint, SolidityParser.Byte, SolidityParser.Fixed, SolidityParser.Ufixed, SolidityParser.BooleanLiteral, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.TypeKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]:
                self.enterOuterAlt(localctx, 2)
                self.state = 933
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                    self.state = 932
                    self.expressionList()


                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 FunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def functionCallArguments(self):
            return self.getTypedRuleContext(SolidityParser.FunctionCallArgumentsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_functionCall

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

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




    def functionCall(self):

        localctx = SolidityParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_functionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 937
            self.expression(0)
            self.state = 938
            self.match(SolidityParser.T__22)
            self.state = 939
            self.functionCallArguments()
            self.state = 940
            self.match(SolidityParser.T__23)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyItemContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyItemContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyBlock

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

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




    def assemblyBlock(self):

        localctx = SolidityParser.AssemblyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_assemblyBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 942
            self.match(SolidityParser.T__14)
            self.state = 946
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__14) | (1 << SolidityParser.T__22) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__26) | (1 << SolidityParser.T__29) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__42) | (1 << SolidityParser.T__48) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & ((1 << (SolidityParser.T__88 - 89)) | (1 << (SolidityParser.T__91 - 89)) | (1 << (SolidityParser.T__95 - 89)) | (1 << (SolidityParser.DecimalNumber - 89)) | (1 << (SolidityParser.HexNumber - 89)) | (1 << (SolidityParser.HexLiteralFragment - 89)) | (1 << (SolidityParser.BreakKeyword - 89)) | (1 << (SolidityParser.ContinueKeyword - 89)) | (1 << (SolidityParser.LeaveKeyword - 89)) | (1 << (SolidityParser.PayableKeyword - 89)) | (1 << (SolidityParser.ConstructorKeyword - 89)) | (1 << (SolidityParser.ReceiveKeyword - 89)) | (1 << (SolidityParser.Identifier - 89)) | (1 << (SolidityParser.StringLiteralFragment - 89)))) != 0):
                self.state = 943
                self.assemblyItem()
                self.state = 948
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 949
            self.match(SolidityParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyItemContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyLocalDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLocalDefinitionContext,0)


        def assemblyAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyAssignmentContext,0)


        def assemblyStackAssignment(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyStackAssignmentContext,0)


        def labelDefinition(self):
            return self.getTypedRuleContext(SolidityParser.LabelDefinitionContext,0)


        def assemblySwitch(self):
            return self.getTypedRuleContext(SolidityParser.AssemblySwitchContext,0)


        def assemblyFunctionDefinition(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionDefinitionContext,0)


        def assemblyFor(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyForContext,0)


        def assemblyIf(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIfContext,0)


        def BreakKeyword(self):
            return self.getToken(SolidityParser.BreakKeyword, 0)

        def ContinueKeyword(self):
            return self.getToken(SolidityParser.ContinueKeyword, 0)

        def LeaveKeyword(self):
            return self.getToken(SolidityParser.LeaveKeyword, 0)

        def subAssembly(self):
            return self.getTypedRuleContext(SolidityParser.SubAssemblyContext,0)


        def numberLiteral(self):
            return self.getTypedRuleContext(SolidityParser.NumberLiteralContext,0)


        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def hexLiteral(self):
            return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyItem

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

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




    def assemblyItem(self):

        localctx = SolidityParser.AssemblyItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_assemblyItem)
        try:
            self.state = 969
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 951
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 952
                self.assemblyBlock()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 953
                self.assemblyExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 954
                self.assemblyLocalDefinition()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 955
                self.assemblyAssignment()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 956
                self.assemblyStackAssignment()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 957
                self.labelDefinition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 958
                self.assemblySwitch()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 959
                self.assemblyFunctionDefinition()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 960
                self.assemblyFor()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 961
                self.assemblyIf()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 962
                self.match(SolidityParser.BreakKeyword)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 963
                self.match(SolidityParser.ContinueKeyword)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 964
                self.match(SolidityParser.LeaveKeyword)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 965
                self.subAssembly()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 966
                self.numberLiteral()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 967
                self.stringLiteral()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 968
                self.hexLiteral()
                pass


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


    class AssemblyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyCall(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyCallContext,0)


        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def assemblyMember(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyExpression

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

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




    def assemblyExpression(self):

        localctx = SolidityParser.AssemblyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_assemblyExpression)
        try:
            self.state = 974
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 971
                self.assemblyCall()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 972
                self.assemblyLiteral()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 973
                self.assemblyMember()
                pass


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


    class AssemblyMemberContext(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.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyMember

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

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




    def assemblyMember(self):

        localctx = SolidityParser.AssemblyMemberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_assemblyMember)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 976
            self.identifier()
            self.state = 977
            self.match(SolidityParser.T__36)
            self.state = 978
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyCallContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCall

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

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




    def assemblyCall(self):

        localctx = SolidityParser.AssemblyCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_assemblyCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 984
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__50]:
                self.state = 980
                self.match(SolidityParser.T__50)
                pass
            elif token in [SolidityParser.T__35]:
                self.state = 981
                self.match(SolidityParser.T__35)
                pass
            elif token in [SolidityParser.T__57]:
                self.state = 982
                self.match(SolidityParser.T__57)
                pass
            elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__41, SolidityParser.T__53, SolidityParser.T__95, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier]:
                self.state = 983
                self.identifier()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 998
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 986
                self.match(SolidityParser.T__22)
                self.state = 988
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__35) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__50) | (1 << SolidityParser.T__53) | (1 << SolidityParser.T__57))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                    self.state = 987
                    self.assemblyExpression()


                self.state = 994
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 990
                    self.match(SolidityParser.T__15)
                    self.state = 991
                    self.assemblyExpression()
                    self.state = 996
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 997
                self.match(SolidityParser.T__23)


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


    class AssemblyLocalDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLocalDefinition

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

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




    def assemblyLocalDefinition(self):

        localctx = SolidityParser.AssemblyLocalDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_assemblyLocalDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1000
            self.match(SolidityParser.T__88)
            self.state = 1001
            self.assemblyIdentifierOrList()
            self.state = 1004
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__89:
                self.state = 1002
                self.match(SolidityParser.T__89)
                self.state = 1003
                self.assemblyExpression()


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


    class AssemblyAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyIdentifierOrList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierOrListContext,0)


        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyAssignment

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

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




    def assemblyAssignment(self):

        localctx = SolidityParser.AssemblyAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_assemblyAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1006
            self.assemblyIdentifierOrList()
            self.state = 1007
            self.match(SolidityParser.T__89)
            self.state = 1008
            self.assemblyExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyIdentifierOrListContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyMember(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyMemberContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierOrList

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

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




    def assemblyIdentifierOrList(self):

        localctx = SolidityParser.AssemblyIdentifierOrListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_assemblyIdentifierOrList)
        try:
            self.state = 1016
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1010
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1011
                self.assemblyMember()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1012
                self.match(SolidityParser.T__22)
                self.state = 1013
                self.assemblyIdentifierList()
                self.state = 1014
                self.match(SolidityParser.T__23)
                pass


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


    class AssemblyIdentifierListContext(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.getTypedRuleContexts(SolidityParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(SolidityParser.IdentifierContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIdentifierList

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

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




    def assemblyIdentifierList(self):

        localctx = SolidityParser.AssemblyIdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_assemblyIdentifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1018
            self.identifier()
            self.state = 1023
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__15:
                self.state = 1019
                self.match(SolidityParser.T__15)
                self.state = 1020
                self.identifier()
                self.state = 1025
                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 AssemblyStackAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyStackAssignment

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

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




    def assemblyStackAssignment(self):

        localctx = SolidityParser.AssemblyStackAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_assemblyStackAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1026
            self.assemblyExpression()
            self.state = 1027
            self.match(SolidityParser.T__90)
            self.state = 1028
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LabelDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_labelDefinition

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

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




    def labelDefinition(self):

        localctx = SolidityParser.LabelDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_labelDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1030
            self.identifier()
            self.state = 1031
            self.match(SolidityParser.T__61)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblySwitchContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyCase(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyCaseContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyCaseContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblySwitch

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

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




    def assemblySwitch(self):

        localctx = SolidityParser.AssemblySwitchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_assemblySwitch)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1033
            self.match(SolidityParser.T__91)
            self.state = 1034
            self.assemblyExpression()
            self.state = 1038
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SolidityParser.T__92 or _la==SolidityParser.T__93:
                self.state = 1035
                self.assemblyCase()
                self.state = 1040
                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 AssemblyCaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyLiteral(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyLiteralContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyCase

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

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




    def assemblyCase(self):

        localctx = SolidityParser.AssemblyCaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_assemblyCase)
        try:
            self.state = 1047
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__92]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1041
                self.match(SolidityParser.T__92)
                self.state = 1042
                self.assemblyLiteral()
                self.state = 1043
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__93]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1045
                self.match(SolidityParser.T__93)
                self.state = 1046
                self.assemblyBlock()
                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 AssemblyFunctionDefinitionContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def assemblyFunctionReturns(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyFunctionReturnsContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionDefinition

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

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




    def assemblyFunctionDefinition(self):

        localctx = SolidityParser.AssemblyFunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_assemblyFunctionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1049
            self.match(SolidityParser.T__29)
            self.state = 1050
            self.identifier()
            self.state = 1051
            self.match(SolidityParser.T__22)
            self.state = 1053
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 0):
                self.state = 1052
                self.assemblyIdentifierList()


            self.state = 1055
            self.match(SolidityParser.T__23)
            self.state = 1057
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__94:
                self.state = 1056
                self.assemblyFunctionReturns()


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


    class AssemblyFunctionReturnsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyIdentifierList(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyIdentifierListContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFunctionReturns

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

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




    def assemblyFunctionReturns(self):

        localctx = SolidityParser.AssemblyFunctionReturnsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_assemblyFunctionReturns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1061
            self.match(SolidityParser.T__94)
            self.state = 1062
            self.assemblyIdentifierList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyForContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyExpressionContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,i)


        def assemblyBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.AssemblyBlockContext)
            else:
                return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyFor

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

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




    def assemblyFor(self):

        localctx = SolidityParser.AssemblyForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_assemblyFor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1064
            self.match(SolidityParser.T__26)
            self.state = 1067
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__14]:
                self.state = 1065
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__35, SolidityParser.T__41, SolidityParser.T__50, SolidityParser.T__53, SolidityParser.T__57, SolidityParser.T__95, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]:
                self.state = 1066
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1069
            self.assemblyExpression()
            self.state = 1072
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__14]:
                self.state = 1070
                self.assemblyBlock()
                pass
            elif token in [SolidityParser.T__13, SolidityParser.T__24, SolidityParser.T__35, SolidityParser.T__41, SolidityParser.T__50, SolidityParser.T__53, SolidityParser.T__57, SolidityParser.T__95, SolidityParser.DecimalNumber, SolidityParser.HexNumber, SolidityParser.HexLiteralFragment, SolidityParser.LeaveKeyword, SolidityParser.PayableKeyword, SolidityParser.ConstructorKeyword, SolidityParser.ReceiveKeyword, SolidityParser.Identifier, SolidityParser.StringLiteralFragment]:
                self.state = 1071
                self.assemblyExpression()
                pass
            else:
                raise NoViableAltException(self)

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


    class AssemblyIfContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assemblyExpression(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyExpressionContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyIf

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

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




    def assemblyIf(self):

        localctx = SolidityParser.AssemblyIfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_assemblyIf)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1076
            self.match(SolidityParser.T__42)
            self.state = 1077
            self.assemblyExpression()
            self.state = 1078
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssemblyLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def stringLiteral(self):
            return self.getTypedRuleContext(SolidityParser.StringLiteralContext,0)


        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def hexLiteral(self):
            return self.getTypedRuleContext(SolidityParser.HexLiteralContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_assemblyLiteral

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

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




    def assemblyLiteral(self):

        localctx = SolidityParser.AssemblyLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_assemblyLiteral)
        try:
            self.state = 1084
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.StringLiteralFragment]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1080
                self.stringLiteral()
                pass
            elif token in [SolidityParser.DecimalNumber]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1081
                self.match(SolidityParser.DecimalNumber)
                pass
            elif token in [SolidityParser.HexNumber]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1082
                self.match(SolidityParser.HexNumber)
                pass
            elif token in [SolidityParser.HexLiteralFragment]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1083
                self.hexLiteral()
                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 SubAssemblyContext(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.getTypedRuleContext(SolidityParser.IdentifierContext,0)


        def assemblyBlock(self):
            return self.getTypedRuleContext(SolidityParser.AssemblyBlockContext,0)


        def getRuleIndex(self):
            return SolidityParser.RULE_subAssembly

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

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




    def subAssembly(self):

        localctx = SolidityParser.SubAssemblyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_subAssembly)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1086
            self.match(SolidityParser.T__48)
            self.state = 1087
            self.identifier()
            self.state = 1088
            self.assemblyBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TupleExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return SolidityParser.RULE_tupleExpression

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

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




    def tupleExpression(self):

        localctx = SolidityParser.TupleExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_tupleExpression)
        self._la = 0 # Token type
        try:
            self.state = 1116
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SolidityParser.T__22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1090
                self.match(SolidityParser.T__22)

                self.state = 1092
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                    self.state = 1091
                    self.expression(0)


                self.state = 1100
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 1094
                    self.match(SolidityParser.T__15)
                    self.state = 1096
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                        self.state = 1095
                        self.expression(0)


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

                self.state = 1103
                self.match(SolidityParser.T__23)
                pass
            elif token in [SolidityParser.T__33]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1104
                self.match(SolidityParser.T__33)
                self.state = 1113
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 6)) & ~0x3f) == 0 and ((1 << (_la - 6)) & ((1 << (SolidityParser.T__5 - 6)) | (1 << (SolidityParser.T__13 - 6)) | (1 << (SolidityParser.T__22 - 6)) | (1 << (SolidityParser.T__24 - 6)) | (1 << (SolidityParser.T__29 - 6)) | (1 << (SolidityParser.T__33 - 6)) | (1 << (SolidityParser.T__35 - 6)) | (1 << (SolidityParser.T__37 - 6)) | (1 << (SolidityParser.T__41 - 6)) | (1 << (SolidityParser.T__53 - 6)) | (1 << (SolidityParser.T__54 - 6)) | (1 << (SolidityParser.T__55 - 6)) | (1 << (SolidityParser.T__56 - 6)) | (1 << (SolidityParser.T__57 - 6)) | (1 << (SolidityParser.T__58 - 6)) | (1 << (SolidityParser.T__59 - 6)) | (1 << (SolidityParser.T__60 - 6)) | (1 << (SolidityParser.T__62 - 6)) | (1 << (SolidityParser.T__63 - 6)) | (1 << (SolidityParser.T__64 - 6)) | (1 << (SolidityParser.T__65 - 6)) | (1 << (SolidityParser.T__66 - 6)))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.Int - 96)) | (1 << (SolidityParser.Uint - 96)) | (1 << (SolidityParser.Byte - 96)) | (1 << (SolidityParser.Fixed - 96)) | (1 << (SolidityParser.Ufixed - 96)) | (1 << (SolidityParser.BooleanLiteral - 96)) | (1 << (SolidityParser.DecimalNumber - 96)) | (1 << (SolidityParser.HexNumber - 96)) | (1 << (SolidityParser.HexLiteralFragment - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.TypeKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)) | (1 << (SolidityParser.StringLiteralFragment - 96)))) != 0):
                    self.state = 1105
                    self.expression(0)
                    self.state = 1110
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SolidityParser.T__15:
                        self.state = 1106
                        self.match(SolidityParser.T__15)
                        self.state = 1107
                        self.expression(0)
                        self.state = 1112
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1115
                self.match(SolidityParser.T__34)
                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 NumberLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DecimalNumber(self):
            return self.getToken(SolidityParser.DecimalNumber, 0)

        def HexNumber(self):
            return self.getToken(SolidityParser.HexNumber, 0)

        def NumberUnit(self):
            return self.getToken(SolidityParser.NumberUnit, 0)

        def getRuleIndex(self):
            return SolidityParser.RULE_numberLiteral

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

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




    def numberLiteral(self):

        localctx = SolidityParser.NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_numberLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1118
            _la = self._input.LA(1)
            if not(_la==SolidityParser.DecimalNumber or _la==SolidityParser.HexNumber):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1120
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.state = 1119
                self.match(SolidityParser.NumberUnit)


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


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ReceiveKeyword(self):
            return self.getToken(SolidityParser.ReceiveKeyword, 0)

        def ConstructorKeyword(self):
            return self.getToken(SolidityParser.ConstructorKeyword, 0)

        def PayableKeyword(self):
            return self.getToken(SolidityParser.PayableKeyword, 0)

        def LeaveKeyword(self):
            return self.getToken(SolidityParser.LeaveKeyword, 0)

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

        def getRuleIndex(self):
            return SolidityParser.RULE_identifier

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

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




    def identifier(self):

        localctx = SolidityParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1122
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SolidityParser.T__13) | (1 << SolidityParser.T__24) | (1 << SolidityParser.T__41) | (1 << SolidityParser.T__53))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (SolidityParser.T__95 - 96)) | (1 << (SolidityParser.LeaveKeyword - 96)) | (1 << (SolidityParser.PayableKeyword - 96)) | (1 << (SolidityParser.ConstructorKeyword - 96)) | (1 << (SolidityParser.ReceiveKeyword - 96)) | (1 << (SolidityParser.Identifier - 96)))) != 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 HexLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SolidityParser.RULE_hexLiteral

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

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




    def hexLiteral(self):

        localctx = SolidityParser.HexLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_hexLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1125 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1124
                    self.match(SolidityParser.HexLiteralFragment)

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

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

        def userDefinedTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SolidityParser.UserDefinedTypeNameContext)
            else:
                return self.getTypedRuleContext(SolidityParser.UserDefinedTypeNameContext,i)


        def getRuleIndex(self):
            return SolidityParser.RULE_overrideSpecifier

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

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




    def overrideSpecifier(self):

        localctx = SolidityParser.OverrideSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_overrideSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1129
            self.match(SolidityParser.T__96)
            self.state = 1141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SolidityParser.T__22:
                self.state = 1130
                self.match(SolidityParser.T__22)
                self.state = 1131
                self.userDefinedTypeName()
                self.state = 1136
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SolidityParser.T__15:
                    self.state = 1132
                    self.match(SolidityParser.T__15)
                    self.state = 1133
                    self.userDefinedTypeName()
                    self.state = 1138
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1139
                self.match(SolidityParser.T__23)


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


    class StringLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return SolidityParser.RULE_stringLiteral

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

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




    def stringLiteral(self):

        localctx = SolidityParser.StringLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_stringLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1144 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1143
                    self.match(SolidityParser.StringLiteralFragment)

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

        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[36] = self.typeName_sempred
        self._predicates[66] = self.expression_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 typeName_sempred(self, localctx:TypeNameContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 3)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 14)
         

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

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

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

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

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

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

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

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

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

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

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

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

            if predIndex == 14:
                return self.precpred(self._ctx, 27)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 25)
         

            if predIndex == 16:
                return self.precpred(self._ctx, 24)
         

            if predIndex == 17:
                return self.precpred(self._ctx, 23)
         

            if predIndex == 18:
                return self.precpred(self._ctx, 22)
         

            if predIndex == 19:
                return self.precpred(self._ctx, 21)
         




