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

class PhpParser ( Parser ):

    grammarFileName = "PhpParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "'<?xml'", "<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>", "'#['", "'abstract'", "'array'", "'as'", 
                     "'binary'", "<INVALID>", "<INVALID>", "'break'", "'callable'", 
                     "'case'", "'catch'", "'class'", "'clone'", "'const'", 
                     "'continue'", "'declare'", "'default'", "'do'", "'real'", 
                     "'double'", "'echo'", "'else'", "'elseif'", "'empty'", 
                     "'enum'", "'enddeclare'", "'endfor'", "'endforeach'", 
                     "'endif'", "'endswitch'", "'endwhile'", "'eval'", "'die'", 
                     "'extends'", "'final'", "'finally'", "'float'", "'for'", 
                     "'foreach'", "'function'", "'global'", "'goto'", "'if'", 
                     "'implements'", "'import'", "'include'", "'include_once'", 
                     "'instanceof'", "'insteadof'", "'int8'", "'int16'", 
                     "'int64'", "<INVALID>", "'interface'", "'isset'", "'list'", 
                     "'and'", "'or'", "'xor'", "'match'", "'namespace'", 
                     "'new'", "'null'", "'object'", "'parent'", "'partial'", 
                     "'print'", "'private'", "'protected'", "'public'", 
                     "'readonly'", "'require'", "'require_once'", "'resource'", 
                     "'return'", "'static'", "'string'", "'switch'", "'throw'", 
                     "'trait'", "'try'", "'clrtypeof'", "<INVALID>", "'unicode'", 
                     "'unset'", "'use'", "'var'", "'while'", "'yield'", 
                     "'from'", "'fn'", "'ticks'", "'encoding'", "'strict_types'", 
                     "'__get'", "'__set'", "'__call'", "'__callstatic'", 
                     "'__construct'", "'__destruct'", "'__wakeup'", "'__sleep'", 
                     "'__autoload'", "'__isset'", "'__unset'", "'__tostring'", 
                     "'__invoke'", "'__set_state'", "'__clone'", "'__debuginfo'", 
                     "'__namespace__'", "'__class__'", "'__trait__'", "'__function__'", 
                     "'__method__'", "'__line__'", "'__file__'", "'__dir__'", 
                     "'<=>'", "'<:'", "':>'", "'=>'", "'++'", "'--'", "'==='", 
                     "'!=='", "'=='", "<INVALID>", "'<='", "'>='", "'+='", 
                     "'-='", "'*='", "'**'", "'**='", "'/='", "'.='", "'%='", 
                     "'<<='", "'>>='", "'&='", "'|='", "'^='", "'||'", "'&&'", 
                     "'??'", "'??='", "'<<'", "'>>'", "'::'", "'->'", "'\\'", 
                     "'...'", "<INVALID>", "<INVALID>", "'&'", "'|'", "'!'", 
                     "'^'", "'+'", "'-'", "'*'", "'%'", "<INVALID>", "'~'", 
                     "'@'", "<INVALID>", "'.'", "<INVALID>", "'('", "')'", 
                     "'['", "']'", "<INVALID>", "'}'", "','", "':'", "';'", 
                     "<INVALID>", "'''", "'`'" ]

    symbolicNames = [ "<INVALID>", "SeaWhitespace", "HtmlText", "XmlStart", 
                      "PHPStart", "HtmlScriptOpen", "HtmlStyleOpen", "HtmlComment", 
                      "HtmlDtd", "HtmlOpen", "Shebang", "Error", "XmlText", 
                      "XmlClose", "PHPStartInside", "HtmlClose", "HtmlSlashClose", 
                      "HtmlSlash", "HtmlEquals", "HtmlStartQuoteString", 
                      "HtmlStartDoubleQuoteString", "HtmlHex", "HtmlDecimal", 
                      "HtmlSpace", "HtmlName", "ErrorInside", "PHPStartInsideQuoteString", 
                      "HtmlEndQuoteString", "HtmlQuoteString", "ErrorHtmlQuote", 
                      "PHPStartDoubleQuoteString", "HtmlEndDoubleQuoteString", 
                      "HtmlDoubleQuoteString", "ErrorHtmlDoubleQuote", "ScriptText", 
                      "HtmlScriptClose", "PHPStartInsideScript", "StyleBody", 
                      "PHPEnd", "Whitespace", "MultiLineComment", "SingleLineComment", 
                      "ShellStyleComment", "AttributeStart", "Abstract", 
                      "Array", "As", "BinaryCast", "BoolType", "BooleanConstant", 
                      "Break", "Callable", "Case", "Catch", "Class", "Clone", 
                      "Const", "Continue", "Declare", "Default", "Do", "DoubleCast", 
                      "DoubleType", "Echo", "Else", "ElseIf", "Empty", "Enum_", 
                      "EndDeclare", "EndFor", "EndForeach", "EndIf", "EndSwitch", 
                      "EndWhile", "Eval", "Exit", "Extends", "Final", "Finally", 
                      "FloatCast", "For", "Foreach", "Function_", "Global", 
                      "Goto", "If", "Implements", "Import", "Include", "IncludeOnce", 
                      "InstanceOf", "InsteadOf", "Int8Cast", "Int16Cast", 
                      "Int64Type", "IntType", "Interface", "IsSet", "List", 
                      "LogicalAnd", "LogicalOr", "LogicalXor", "Match_", 
                      "Namespace", "New", "Null", "ObjectType", "Parent_", 
                      "Partial", "Print", "Private", "Protected", "Public", 
                      "Readonly", "Require", "RequireOnce", "Resource", 
                      "Return", "Static", "StringType", "Switch", "Throw", 
                      "Trait", "Try", "Typeof", "UintCast", "UnicodeCast", 
                      "Unset", "Use", "Var", "While", "Yield", "From", "LambdaFn", 
                      "Ticks", "Encoding", "StrictTypes", "Get", "Set", 
                      "Call", "CallStatic", "Constructor", "Destruct", "Wakeup", 
                      "Sleep", "Autoload", "IsSet__", "Unset__", "ToString__", 
                      "Invoke", "SetState", "Clone__", "DebugInfo", "Namespace__", 
                      "Class__", "Traic__", "Function__", "Method__", "Line__", 
                      "File__", "Dir__", "Spaceship", "Lgeneric", "Rgeneric", 
                      "DoubleArrow", "Inc", "Dec", "IsIdentical", "IsNoidentical", 
                      "IsEqual", "IsNotEq", "IsSmallerOrEqual", "IsGreaterOrEqual", 
                      "PlusEqual", "MinusEqual", "MulEqual", "Pow", "PowEqual", 
                      "DivEqual", "Concaequal", "ModEqual", "ShiftLeftEqual", 
                      "ShiftRightEqual", "AndEqual", "OrEqual", "XorEqual", 
                      "BooleanOr", "BooleanAnd", "NullCoalescing", "NullCoalescingEqual", 
                      "ShiftLeft", "ShiftRight", "DoubleColon", "ObjectOperator", 
                      "NamespaceSeparator", "Ellipsis", "Less", "Greater", 
                      "Ampersand", "Pipe", "Bang", "Caret", "Plus", "Minus", 
                      "Asterisk", "Percent", "Divide", "Tilde", "SuppressWarnings", 
                      "Dollar", "Dot", "QuestionMark", "OpenRoundBracket", 
                      "CloseRoundBracket", "OpenSquareBracket", "CloseSquareBracket", 
                      "OpenCurlyBracket", "CloseCurlyBracket", "Comma", 
                      "Colon", "SemiColon", "Eq", "Quote", "BackQuote", 
                      "VarName", "Label", "Octal", "Decimal", "Real", "Hex", 
                      "Binary", "BackQuoteString", "SingleQuoteString", 
                      "DoubleQuote", "StartNowDoc", "StartHereDoc", "ErrorPhp", 
                      "CurlyDollar", "UnicodeEscape", "StringPart", "Comment", 
                      "PHPEndSingleLineComment", "CommentEnd", "HereDocText", 
                      "XmlText2" ]

    RULE_htmlDocument = 0
    RULE_inlineHtml = 1
    RULE_htmlElement = 2
    RULE_scriptText = 3
    RULE_phpBlock = 4
    RULE_importStatement = 5
    RULE_topStatement = 6
    RULE_useDeclaration = 7
    RULE_useDeclarationContentList = 8
    RULE_useDeclarationContent = 9
    RULE_namespaceDeclaration = 10
    RULE_namespaceStatement = 11
    RULE_functionDeclaration = 12
    RULE_classDeclaration = 13
    RULE_classEntryType = 14
    RULE_interfaceList = 15
    RULE_typeParameterListInBrackets = 16
    RULE_typeParameterList = 17
    RULE_typeParameterWithDefaultsList = 18
    RULE_typeParameterDecl = 19
    RULE_typeParameterWithDefaultDecl = 20
    RULE_genericDynamicArgs = 21
    RULE_attributes = 22
    RULE_attributeGroup = 23
    RULE_attribute = 24
    RULE_innerStatementList = 25
    RULE_innerStatement = 26
    RULE_statement = 27
    RULE_emptyStatement_ = 28
    RULE_blockStatement = 29
    RULE_ifStatement = 30
    RULE_elseIfStatement = 31
    RULE_elseIfColonStatement = 32
    RULE_elseStatement = 33
    RULE_elseColonStatement = 34
    RULE_whileStatement = 35
    RULE_doWhileStatement = 36
    RULE_forStatement = 37
    RULE_forInit = 38
    RULE_forUpdate = 39
    RULE_switchStatement = 40
    RULE_switchBlock = 41
    RULE_breakStatement = 42
    RULE_continueStatement = 43
    RULE_returnStatement = 44
    RULE_expressionStatement = 45
    RULE_unsetStatement = 46
    RULE_foreachStatement = 47
    RULE_tryCatchFinally = 48
    RULE_catchClause = 49
    RULE_finallyStatement = 50
    RULE_throwStatement = 51
    RULE_gotoStatement = 52
    RULE_declareStatement = 53
    RULE_inlineHtmlStatement = 54
    RULE_declareList = 55
    RULE_directive = 56
    RULE_formalParameterList = 57
    RULE_formalParameter = 58
    RULE_typeHint = 59
    RULE_globalStatement = 60
    RULE_globalVar = 61
    RULE_echoStatement = 62
    RULE_staticVariableStatement = 63
    RULE_classStatement = 64
    RULE_traitAdaptations = 65
    RULE_traitAdaptationStatement = 66
    RULE_traitPrecedence = 67
    RULE_traitAlias = 68
    RULE_traitMethodReference = 69
    RULE_baseCtorCall = 70
    RULE_returnTypeDecl = 71
    RULE_methodBody = 72
    RULE_propertyModifiers = 73
    RULE_memberModifiers = 74
    RULE_variableInitializer = 75
    RULE_identifierInitializer = 76
    RULE_globalConstantDeclaration = 77
    RULE_enumDeclaration = 78
    RULE_enumItem = 79
    RULE_expressionList = 80
    RULE_parentheses = 81
    RULE_expression = 82
    RULE_assignable = 83
    RULE_arrayCreation = 84
    RULE_arrayDestructuring = 85
    RULE_indexedDestructItem = 86
    RULE_keyedDestructItem = 87
    RULE_lambdaFunctionExpr = 88
    RULE_matchExpr = 89
    RULE_matchItem = 90
    RULE_newExpr = 91
    RULE_assignmentOperator = 92
    RULE_yieldExpression = 93
    RULE_arrayItemList = 94
    RULE_arrayItem = 95
    RULE_lambdaFunctionUseVars = 96
    RULE_lambdaFunctionUseVar = 97
    RULE_qualifiedStaticTypeRef = 98
    RULE_typeRef = 99
    RULE_anonymousClass = 100
    RULE_indirectTypeRef = 101
    RULE_qualifiedNamespaceName = 102
    RULE_namespaceNameList = 103
    RULE_namespaceNameTail = 104
    RULE_qualifiedNamespaceNameList = 105
    RULE_arguments = 106
    RULE_actualArgument = 107
    RULE_argumentName = 108
    RULE_constantInitializer = 109
    RULE_constant = 110
    RULE_literalConstant = 111
    RULE_numericConstant = 112
    RULE_classConstant = 113
    RULE_stringConstant = 114
    RULE_string = 115
    RULE_interpolatedStringPart = 116
    RULE_chainList = 117
    RULE_chain = 118
    RULE_chainOrigin = 119
    RULE_memberAccess = 120
    RULE_functionCall = 121
    RULE_functionCallName = 122
    RULE_actualArguments = 123
    RULE_chainBase = 124
    RULE_keyedFieldName = 125
    RULE_keyedSimpleFieldName = 126
    RULE_keyedVariable = 127
    RULE_squareCurlyExpression = 128
    RULE_assignmentList = 129
    RULE_assignmentListElement = 130
    RULE_modifier = 131
    RULE_identifier = 132
    RULE_memberModifier = 133
    RULE_magicConstant = 134
    RULE_magicMethod = 135
    RULE_primitiveType = 136
    RULE_castOperation = 137

    ruleNames =  [ "htmlDocument", "inlineHtml", "htmlElement", "scriptText", 
                   "phpBlock", "importStatement", "topStatement", "useDeclaration", 
                   "useDeclarationContentList", "useDeclarationContent", 
                   "namespaceDeclaration", "namespaceStatement", "functionDeclaration", 
                   "classDeclaration", "classEntryType", "interfaceList", 
                   "typeParameterListInBrackets", "typeParameterList", "typeParameterWithDefaultsList", 
                   "typeParameterDecl", "typeParameterWithDefaultDecl", 
                   "genericDynamicArgs", "attributes", "attributeGroup", 
                   "attribute", "innerStatementList", "innerStatement", 
                   "statement", "emptyStatement_", "blockStatement", "ifStatement", 
                   "elseIfStatement", "elseIfColonStatement", "elseStatement", 
                   "elseColonStatement", "whileStatement", "doWhileStatement", 
                   "forStatement", "forInit", "forUpdate", "switchStatement", 
                   "switchBlock", "breakStatement", "continueStatement", 
                   "returnStatement", "expressionStatement", "unsetStatement", 
                   "foreachStatement", "tryCatchFinally", "catchClause", 
                   "finallyStatement", "throwStatement", "gotoStatement", 
                   "declareStatement", "inlineHtmlStatement", "declareList", 
                   "directive", "formalParameterList", "formalParameter", 
                   "typeHint", "globalStatement", "globalVar", "echoStatement", 
                   "staticVariableStatement", "classStatement", "traitAdaptations", 
                   "traitAdaptationStatement", "traitPrecedence", "traitAlias", 
                   "traitMethodReference", "baseCtorCall", "returnTypeDecl", 
                   "methodBody", "propertyModifiers", "memberModifiers", 
                   "variableInitializer", "identifierInitializer", "globalConstantDeclaration", 
                   "enumDeclaration", "enumItem", "expressionList", "parentheses", 
                   "expression", "assignable", "arrayCreation", "arrayDestructuring", 
                   "indexedDestructItem", "keyedDestructItem", "lambdaFunctionExpr", 
                   "matchExpr", "matchItem", "newExpr", "assignmentOperator", 
                   "yieldExpression", "arrayItemList", "arrayItem", "lambdaFunctionUseVars", 
                   "lambdaFunctionUseVar", "qualifiedStaticTypeRef", "typeRef", 
                   "anonymousClass", "indirectTypeRef", "qualifiedNamespaceName", 
                   "namespaceNameList", "namespaceNameTail", "qualifiedNamespaceNameList", 
                   "arguments", "actualArgument", "argumentName", "constantInitializer", 
                   "constant", "literalConstant", "numericConstant", "classConstant", 
                   "stringConstant", "string", "interpolatedStringPart", 
                   "chainList", "chain", "chainOrigin", "memberAccess", 
                   "functionCall", "functionCallName", "actualArguments", 
                   "chainBase", "keyedFieldName", "keyedSimpleFieldName", 
                   "keyedVariable", "squareCurlyExpression", "assignmentList", 
                   "assignmentListElement", "modifier", "identifier", "memberModifier", 
                   "magicConstant", "magicMethod", "primitiveType", "castOperation" ]

    EOF = Token.EOF
    SeaWhitespace=1
    HtmlText=2
    XmlStart=3
    PHPStart=4
    HtmlScriptOpen=5
    HtmlStyleOpen=6
    HtmlComment=7
    HtmlDtd=8
    HtmlOpen=9
    Shebang=10
    Error=11
    XmlText=12
    XmlClose=13
    PHPStartInside=14
    HtmlClose=15
    HtmlSlashClose=16
    HtmlSlash=17
    HtmlEquals=18
    HtmlStartQuoteString=19
    HtmlStartDoubleQuoteString=20
    HtmlHex=21
    HtmlDecimal=22
    HtmlSpace=23
    HtmlName=24
    ErrorInside=25
    PHPStartInsideQuoteString=26
    HtmlEndQuoteString=27
    HtmlQuoteString=28
    ErrorHtmlQuote=29
    PHPStartDoubleQuoteString=30
    HtmlEndDoubleQuoteString=31
    HtmlDoubleQuoteString=32
    ErrorHtmlDoubleQuote=33
    ScriptText=34
    HtmlScriptClose=35
    PHPStartInsideScript=36
    StyleBody=37
    PHPEnd=38
    Whitespace=39
    MultiLineComment=40
    SingleLineComment=41
    ShellStyleComment=42
    AttributeStart=43
    Abstract=44
    Array=45
    As=46
    BinaryCast=47
    BoolType=48
    BooleanConstant=49
    Break=50
    Callable=51
    Case=52
    Catch=53
    Class=54
    Clone=55
    Const=56
    Continue=57
    Declare=58
    Default=59
    Do=60
    DoubleCast=61
    DoubleType=62
    Echo=63
    Else=64
    ElseIf=65
    Empty=66
    Enum_=67
    EndDeclare=68
    EndFor=69
    EndForeach=70
    EndIf=71
    EndSwitch=72
    EndWhile=73
    Eval=74
    Exit=75
    Extends=76
    Final=77
    Finally=78
    FloatCast=79
    For=80
    Foreach=81
    Function_=82
    Global=83
    Goto=84
    If=85
    Implements=86
    Import=87
    Include=88
    IncludeOnce=89
    InstanceOf=90
    InsteadOf=91
    Int8Cast=92
    Int16Cast=93
    Int64Type=94
    IntType=95
    Interface=96
    IsSet=97
    List=98
    LogicalAnd=99
    LogicalOr=100
    LogicalXor=101
    Match_=102
    Namespace=103
    New=104
    Null=105
    ObjectType=106
    Parent_=107
    Partial=108
    Print=109
    Private=110
    Protected=111
    Public=112
    Readonly=113
    Require=114
    RequireOnce=115
    Resource=116
    Return=117
    Static=118
    StringType=119
    Switch=120
    Throw=121
    Trait=122
    Try=123
    Typeof=124
    UintCast=125
    UnicodeCast=126
    Unset=127
    Use=128
    Var=129
    While=130
    Yield=131
    From=132
    LambdaFn=133
    Ticks=134
    Encoding=135
    StrictTypes=136
    Get=137
    Set=138
    Call=139
    CallStatic=140
    Constructor=141
    Destruct=142
    Wakeup=143
    Sleep=144
    Autoload=145
    IsSet__=146
    Unset__=147
    ToString__=148
    Invoke=149
    SetState=150
    Clone__=151
    DebugInfo=152
    Namespace__=153
    Class__=154
    Traic__=155
    Function__=156
    Method__=157
    Line__=158
    File__=159
    Dir__=160
    Spaceship=161
    Lgeneric=162
    Rgeneric=163
    DoubleArrow=164
    Inc=165
    Dec=166
    IsIdentical=167
    IsNoidentical=168
    IsEqual=169
    IsNotEq=170
    IsSmallerOrEqual=171
    IsGreaterOrEqual=172
    PlusEqual=173
    MinusEqual=174
    MulEqual=175
    Pow=176
    PowEqual=177
    DivEqual=178
    Concaequal=179
    ModEqual=180
    ShiftLeftEqual=181
    ShiftRightEqual=182
    AndEqual=183
    OrEqual=184
    XorEqual=185
    BooleanOr=186
    BooleanAnd=187
    NullCoalescing=188
    NullCoalescingEqual=189
    ShiftLeft=190
    ShiftRight=191
    DoubleColon=192
    ObjectOperator=193
    NamespaceSeparator=194
    Ellipsis=195
    Less=196
    Greater=197
    Ampersand=198
    Pipe=199
    Bang=200
    Caret=201
    Plus=202
    Minus=203
    Asterisk=204
    Percent=205
    Divide=206
    Tilde=207
    SuppressWarnings=208
    Dollar=209
    Dot=210
    QuestionMark=211
    OpenRoundBracket=212
    CloseRoundBracket=213
    OpenSquareBracket=214
    CloseSquareBracket=215
    OpenCurlyBracket=216
    CloseCurlyBracket=217
    Comma=218
    Colon=219
    SemiColon=220
    Eq=221
    Quote=222
    BackQuote=223
    VarName=224
    Label=225
    Octal=226
    Decimal=227
    Real=228
    Hex=229
    Binary=230
    BackQuoteString=231
    SingleQuoteString=232
    DoubleQuote=233
    StartNowDoc=234
    StartHereDoc=235
    ErrorPhp=236
    CurlyDollar=237
    UnicodeEscape=238
    StringPart=239
    Comment=240
    PHPEndSingleLineComment=241
    CommentEnd=242
    HereDocText=243
    XmlText2=244

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




    class HtmlDocumentContext(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(PhpParser.EOF, 0)

        def Shebang(self):
            return self.getToken(PhpParser.Shebang, 0)

        def inlineHtml(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.InlineHtmlContext)
            else:
                return self.getTypedRuleContext(PhpParser.InlineHtmlContext,i)


        def phpBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.PhpBlockContext)
            else:
                return self.getTypedRuleContext(PhpParser.PhpBlockContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_htmlDocument

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

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




    def htmlDocument(self):

        localctx = PhpParser.HtmlDocumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_htmlDocument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 277
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 276
                self.match(PhpParser.Shebang)


            self.state = 283
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -8600244223124) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 420906795007) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4397045441345) != 0):
                self.state = 281
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
                if la_ == 1:
                    self.state = 279
                    self.inlineHtml()
                    pass

                elif la_ == 2:
                    self.state = 280
                    self.phpBlock()
                    pass


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

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


    class InlineHtmlContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def htmlElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.HtmlElementContext)
            else:
                return self.getTypedRuleContext(PhpParser.HtmlElementContext,i)


        def scriptText(self):
            return self.getTypedRuleContext(PhpParser.ScriptTextContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_inlineHtml

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

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




    def inlineHtml(self):

        localctx = PhpParser.InlineHtmlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_inlineHtml)
        try:
            self.state = 294
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2, 3, 5, 6, 8, 9, 15, 16, 17, 18, 19, 20, 21, 22, 24, 27, 28, 31, 32, 35, 37]:
                self.enterOuterAlt(localctx, 1)
                self.state = 289 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 288
                        self.htmlElement()

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

                pass
            elif token in [34]:
                self.enterOuterAlt(localctx, 2)
                self.state = 293
                self.scriptText()
                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 HtmlElementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def HtmlDtd(self):
            return self.getToken(PhpParser.HtmlDtd, 0)

        def HtmlClose(self):
            return self.getToken(PhpParser.HtmlClose, 0)

        def HtmlStyleOpen(self):
            return self.getToken(PhpParser.HtmlStyleOpen, 0)

        def HtmlOpen(self):
            return self.getToken(PhpParser.HtmlOpen, 0)

        def HtmlName(self):
            return self.getToken(PhpParser.HtmlName, 0)

        def HtmlSlashClose(self):
            return self.getToken(PhpParser.HtmlSlashClose, 0)

        def HtmlSlash(self):
            return self.getToken(PhpParser.HtmlSlash, 0)

        def HtmlText(self):
            return self.getToken(PhpParser.HtmlText, 0)

        def HtmlEquals(self):
            return self.getToken(PhpParser.HtmlEquals, 0)

        def HtmlStartQuoteString(self):
            return self.getToken(PhpParser.HtmlStartQuoteString, 0)

        def HtmlEndQuoteString(self):
            return self.getToken(PhpParser.HtmlEndQuoteString, 0)

        def HtmlStartDoubleQuoteString(self):
            return self.getToken(PhpParser.HtmlStartDoubleQuoteString, 0)

        def HtmlEndDoubleQuoteString(self):
            return self.getToken(PhpParser.HtmlEndDoubleQuoteString, 0)

        def HtmlHex(self):
            return self.getToken(PhpParser.HtmlHex, 0)

        def HtmlDecimal(self):
            return self.getToken(PhpParser.HtmlDecimal, 0)

        def HtmlQuoteString(self):
            return self.getToken(PhpParser.HtmlQuoteString, 0)

        def HtmlDoubleQuoteString(self):
            return self.getToken(PhpParser.HtmlDoubleQuoteString, 0)

        def StyleBody(self):
            return self.getToken(PhpParser.StyleBody, 0)

        def HtmlScriptOpen(self):
            return self.getToken(PhpParser.HtmlScriptOpen, 0)

        def HtmlScriptClose(self):
            return self.getToken(PhpParser.HtmlScriptClose, 0)

        def XmlStart(self):
            return self.getToken(PhpParser.XmlStart, 0)

        def XmlClose(self):
            return self.getToken(PhpParser.XmlClose, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_htmlElement

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

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




    def htmlElement(self):

        localctx = PhpParser.HtmlElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_htmlElement)
        self._la = 0 # Token type
        try:
            self.state = 324
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [8]:
                self.enterOuterAlt(localctx, 1)
                self.state = 296
                self.match(PhpParser.HtmlDtd)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 2)
                self.state = 297
                self.match(PhpParser.HtmlClose)
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 3)
                self.state = 298
                self.match(PhpParser.HtmlStyleOpen)
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 4)
                self.state = 299
                self.match(PhpParser.HtmlOpen)
                pass
            elif token in [24]:
                self.enterOuterAlt(localctx, 5)
                self.state = 300
                self.match(PhpParser.HtmlName)
                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 6)
                self.state = 301
                self.match(PhpParser.HtmlSlashClose)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 302
                self.match(PhpParser.HtmlSlash)
                pass
            elif token in [2]:
                self.enterOuterAlt(localctx, 8)
                self.state = 303
                self.match(PhpParser.HtmlText)
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 9)
                self.state = 304
                self.match(PhpParser.HtmlEquals)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 10)
                self.state = 305
                self.match(PhpParser.HtmlStartQuoteString)
                pass
            elif token in [27]:
                self.enterOuterAlt(localctx, 11)
                self.state = 306
                self.match(PhpParser.HtmlEndQuoteString)
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 12)
                self.state = 307
                self.match(PhpParser.HtmlStartDoubleQuoteString)
                pass
            elif token in [31]:
                self.enterOuterAlt(localctx, 13)
                self.state = 308
                self.match(PhpParser.HtmlEndDoubleQuoteString)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 14)
                self.state = 309
                self.match(PhpParser.HtmlHex)
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 15)
                self.state = 310
                self.match(PhpParser.HtmlDecimal)
                pass
            elif token in [28]:
                self.enterOuterAlt(localctx, 16)
                self.state = 311
                self.match(PhpParser.HtmlQuoteString)
                pass
            elif token in [32]:
                self.enterOuterAlt(localctx, 17)
                self.state = 312
                self.match(PhpParser.HtmlDoubleQuoteString)
                pass
            elif token in [37]:
                self.enterOuterAlt(localctx, 18)
                self.state = 313
                self.match(PhpParser.StyleBody)
                pass
            elif token in [5]:
                self.enterOuterAlt(localctx, 19)
                self.state = 314
                self.match(PhpParser.HtmlScriptOpen)
                pass
            elif token in [35]:
                self.enterOuterAlt(localctx, 20)
                self.state = 315
                self.match(PhpParser.HtmlScriptClose)
                pass
            elif token in [3]:
                self.enterOuterAlt(localctx, 21)
                self.state = 316
                self.match(PhpParser.XmlStart)
                self.state = 320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==12:
                    self.state = 317
                    self.match(PhpParser.XmlText)
                    self.state = 322
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 323
                self.match(PhpParser.XmlClose)
                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 ScriptTextContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return PhpParser.RULE_scriptText

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

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




    def scriptText(self):

        localctx = PhpParser.ScriptTextContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_scriptText)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 326
                    self.match(PhpParser.ScriptText)

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

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

        def importStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ImportStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.ImportStatementContext,i)


        def topStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.TopStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.TopStatementContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_phpBlock

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

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




    def phpBlock(self):

        localctx = PhpParser.PhpBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_phpBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 334
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 331
                    self.importStatement() 
                self.state = 336
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

            self.state = 338 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 337
                    self.topStatement()

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

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

        def Import(self):
            return self.getToken(PhpParser.Import, 0)

        def Namespace(self):
            return self.getToken(PhpParser.Namespace, 0)

        def namespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.NamespaceNameListContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_importStatement

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

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




    def importStatement(self):

        localctx = PhpParser.ImportStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_importStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 342
            self.match(PhpParser.Import)
            self.state = 343
            self.match(PhpParser.Namespace)
            self.state = 344
            self.namespaceNameList()
            self.state = 345
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TopStatementContext(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(PhpParser.StatementContext,0)


        def useDeclaration(self):
            return self.getTypedRuleContext(PhpParser.UseDeclarationContext,0)


        def namespaceDeclaration(self):
            return self.getTypedRuleContext(PhpParser.NamespaceDeclarationContext,0)


        def functionDeclaration(self):
            return self.getTypedRuleContext(PhpParser.FunctionDeclarationContext,0)


        def classDeclaration(self):
            return self.getTypedRuleContext(PhpParser.ClassDeclarationContext,0)


        def globalConstantDeclaration(self):
            return self.getTypedRuleContext(PhpParser.GlobalConstantDeclarationContext,0)


        def enumDeclaration(self):
            return self.getTypedRuleContext(PhpParser.EnumDeclarationContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_topStatement

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

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




    def topStatement(self):

        localctx = PhpParser.TopStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_topStatement)
        try:
            self.state = 354
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 347
                self.statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 348
                self.useDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 349
                self.namespaceDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 350
                self.functionDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 351
                self.classDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 352
                self.globalConstantDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 353
                self.enumDeclaration()
                pass


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


    class UseDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Use(self):
            return self.getToken(PhpParser.Use, 0)

        def useDeclarationContentList(self):
            return self.getTypedRuleContext(PhpParser.UseDeclarationContentListContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def Function_(self):
            return self.getToken(PhpParser.Function_, 0)

        def Const(self):
            return self.getToken(PhpParser.Const, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_useDeclaration

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

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




    def useDeclaration(self):

        localctx = PhpParser.UseDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_useDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self.match(PhpParser.Use)
            self.state = 358
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.state = 357
                _la = self._input.LA(1)
                if not(_la==56 or _la==82):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 360
            self.useDeclarationContentList()
            self.state = 361
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UseDeclarationContentListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def useDeclarationContent(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.UseDeclarationContentContext)
            else:
                return self.getTypedRuleContext(PhpParser.UseDeclarationContentContext,i)


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

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

        def getRuleIndex(self):
            return PhpParser.RULE_useDeclarationContentList

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

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




    def useDeclarationContentList(self):

        localctx = PhpParser.UseDeclarationContentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_useDeclarationContentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==194:
                self.state = 363
                self.match(PhpParser.NamespaceSeparator)


            self.state = 366
            self.useDeclarationContent()
            self.state = 374
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 367
                self.match(PhpParser.Comma)
                self.state = 369
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==194:
                    self.state = 368
                    self.match(PhpParser.NamespaceSeparator)


                self.state = 371
                self.useDeclarationContent()
                self.state = 376
                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 UseDeclarationContentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.NamespaceNameListContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_useDeclarationContent

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

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




    def useDeclarationContent(self):

        localctx = PhpParser.UseDeclarationContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_useDeclarationContent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 377
            self.namespaceNameList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NamespaceDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Namespace(self):
            return self.getToken(PhpParser.Namespace, 0)

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def namespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.NamespaceNameListContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def namespaceStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.NamespaceStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.NamespaceStatementContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_namespaceDeclaration

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

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




    def namespaceDeclaration(self):

        localctx = PhpParser.NamespaceDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_namespaceDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 379
            self.match(PhpParser.Namespace)
            self.state = 394
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.state = 381
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 9007199254740991) != 0) or _la==225:
                    self.state = 380
                    self.namespaceNameList()


                self.state = 383
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 387
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & -8600244223124) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -1) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & 420906795007) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4397045441345) != 0):
                    self.state = 384
                    self.namespaceStatement()
                    self.state = 389
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 390
                self.match(PhpParser.CloseCurlyBracket)
                pass

            elif la_ == 2:
                self.state = 391
                self.namespaceNameList()
                self.state = 392
                self.match(PhpParser.SemiColon)
                pass


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


    class NamespaceStatementContext(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(PhpParser.StatementContext,0)


        def useDeclaration(self):
            return self.getTypedRuleContext(PhpParser.UseDeclarationContext,0)


        def functionDeclaration(self):
            return self.getTypedRuleContext(PhpParser.FunctionDeclarationContext,0)


        def classDeclaration(self):
            return self.getTypedRuleContext(PhpParser.ClassDeclarationContext,0)


        def globalConstantDeclaration(self):
            return self.getTypedRuleContext(PhpParser.GlobalConstantDeclarationContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_namespaceStatement

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

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




    def namespaceStatement(self):

        localctx = PhpParser.NamespaceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_namespaceStatement)
        try:
            self.state = 401
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 396
                self.statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 397
                self.useDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 398
                self.functionDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 399
                self.classDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 400
                self.globalConstantDeclaration()
                pass


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


    class FunctionDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Function_(self):
            return self.getToken(PhpParser.Function_, 0)

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


        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(PhpParser.FormalParameterListContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def typeParameterListInBrackets(self):
            return self.getTypedRuleContext(PhpParser.TypeParameterListInBracketsContext,0)


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

        def typeHint(self):
            return self.getTypedRuleContext(PhpParser.TypeHintContext,0)


        def QuestionMark(self):
            return self.getToken(PhpParser.QuestionMark, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_functionDeclaration

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

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




    def functionDeclaration(self):

        localctx = PhpParser.FunctionDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_functionDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 403
                self.attributes()


            self.state = 406
            self.match(PhpParser.Function_)
            self.state = 408
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==198:
                self.state = 407
                self.match(PhpParser.Ampersand)


            self.state = 410
            self.identifier()
            self.state = 412
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==162:
                self.state = 411
                self.typeParameterListInBrackets()


            self.state = 414
            self.match(PhpParser.OpenRoundBracket)
            self.state = 415
            self.formalParameterList()
            self.state = 416
            self.match(PhpParser.CloseRoundBracket)
            self.state = 422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 417
                self.match(PhpParser.Colon)
                self.state = 419
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==211:
                    self.state = 418
                    self.match(PhpParser.QuestionMark)


                self.state = 421
                self.typeHint(0)


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


    class ClassDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def classEntryType(self):
            return self.getTypedRuleContext(PhpParser.ClassEntryTypeContext,0)


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


        def Interface(self):
            return self.getToken(PhpParser.Interface, 0)

        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def Private(self):
            return self.getToken(PhpParser.Private, 0)

        def modifier(self):
            return self.getTypedRuleContext(PhpParser.ModifierContext,0)


        def Partial(self):
            return self.getToken(PhpParser.Partial, 0)

        def classStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ClassStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.ClassStatementContext,i)


        def typeParameterListInBrackets(self):
            return self.getTypedRuleContext(PhpParser.TypeParameterListInBracketsContext,0)


        def Extends(self):
            return self.getToken(PhpParser.Extends, 0)

        def qualifiedStaticTypeRef(self):
            return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,0)


        def Implements(self):
            return self.getToken(PhpParser.Implements, 0)

        def interfaceList(self):
            return self.getTypedRuleContext(PhpParser.InterfaceListContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_classDeclaration

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

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




    def classDeclaration(self):

        localctx = PhpParser.ClassDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_classDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 427
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 426
                self.attributes()


            self.state = 430
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==110:
                self.state = 429
                self.match(PhpParser.Private)


            self.state = 433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44 or _la==77:
                self.state = 432
                self.modifier()


            self.state = 436
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==108:
                self.state = 435
                self.match(PhpParser.Partial)


            self.state = 460
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [54, 122]:
                self.state = 438
                self.classEntryType()
                self.state = 439
                self.identifier()
                self.state = 441
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==162:
                    self.state = 440
                    self.typeParameterListInBrackets()


                self.state = 445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==76:
                    self.state = 443
                    self.match(PhpParser.Extends)
                    self.state = 444
                    self.qualifiedStaticTypeRef()


                self.state = 449
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==86:
                    self.state = 447
                    self.match(PhpParser.Implements)
                    self.state = 448
                    self.interfaceList()


                pass
            elif token in [96]:
                self.state = 451
                self.match(PhpParser.Interface)
                self.state = 452
                self.identifier()
                self.state = 454
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==162:
                    self.state = 453
                    self.typeParameterListInBrackets()


                self.state = 458
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==76:
                    self.state = 456
                    self.match(PhpParser.Extends)
                    self.state = 457
                    self.interfaceList()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 462
            self.match(PhpParser.OpenCurlyBracket)
            self.state = 466
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 72083982316994560) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 6757727313330209) != 0):
                self.state = 463
                self.classStatement()
                self.state = 468
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 469
            self.match(PhpParser.CloseCurlyBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassEntryTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Class(self):
            return self.getToken(PhpParser.Class, 0)

        def Trait(self):
            return self.getToken(PhpParser.Trait, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_classEntryType

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

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




    def classEntryType(self):

        localctx = PhpParser.ClassEntryTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_classEntryType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 471
            _la = self._input.LA(1)
            if not(_la==54 or _la==122):
                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 InterfaceListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedStaticTypeRef(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.QualifiedStaticTypeRefContext)
            else:
                return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_interfaceList

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

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




    def interfaceList(self):

        localctx = PhpParser.InterfaceListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_interfaceList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self.qualifiedStaticTypeRef()
            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 474
                self.match(PhpParser.Comma)
                self.state = 475
                self.qualifiedStaticTypeRef()
                self.state = 480
                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 TypeParameterListInBracketsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Lgeneric(self):
            return self.getToken(PhpParser.Lgeneric, 0)

        def typeParameterList(self):
            return self.getTypedRuleContext(PhpParser.TypeParameterListContext,0)


        def Rgeneric(self):
            return self.getToken(PhpParser.Rgeneric, 0)

        def typeParameterWithDefaultsList(self):
            return self.getTypedRuleContext(PhpParser.TypeParameterWithDefaultsListContext,0)


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

        def getRuleIndex(self):
            return PhpParser.RULE_typeParameterListInBrackets

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

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




    def typeParameterListInBrackets(self):

        localctx = PhpParser.TypeParameterListInBracketsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_typeParameterListInBrackets)
        try:
            self.state = 495
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 481
                self.match(PhpParser.Lgeneric)
                self.state = 482
                self.typeParameterList()
                self.state = 483
                self.match(PhpParser.Rgeneric)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 485
                self.match(PhpParser.Lgeneric)
                self.state = 486
                self.typeParameterWithDefaultsList()
                self.state = 487
                self.match(PhpParser.Rgeneric)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 489
                self.match(PhpParser.Lgeneric)
                self.state = 490
                self.typeParameterList()
                self.state = 491
                self.match(PhpParser.Comma)
                self.state = 492
                self.typeParameterWithDefaultsList()
                self.state = 493
                self.match(PhpParser.Rgeneric)
                pass


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


    class TypeParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeParameterDecl(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.TypeParameterDeclContext)
            else:
                return self.getTypedRuleContext(PhpParser.TypeParameterDeclContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_typeParameterList

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

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




    def typeParameterList(self):

        localctx = PhpParser.TypeParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_typeParameterList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 497
            self.typeParameterDecl()
            self.state = 502
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,37,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 498
                    self.match(PhpParser.Comma)
                    self.state = 499
                    self.typeParameterDecl() 
                self.state = 504
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,37,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 TypeParameterWithDefaultsListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeParameterWithDefaultDecl(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.TypeParameterWithDefaultDeclContext)
            else:
                return self.getTypedRuleContext(PhpParser.TypeParameterWithDefaultDeclContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_typeParameterWithDefaultsList

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

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




    def typeParameterWithDefaultsList(self):

        localctx = PhpParser.TypeParameterWithDefaultsListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_typeParameterWithDefaultsList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 505
            self.typeParameterWithDefaultDecl()
            self.state = 510
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 506
                self.match(PhpParser.Comma)
                self.state = 507
                self.typeParameterWithDefaultDecl()
                self.state = 512
                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 TypeParameterDeclContext(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(PhpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_typeParameterDecl

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

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




    def typeParameterDecl(self):

        localctx = PhpParser.TypeParameterDeclContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_typeParameterDecl)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 513
                self.attributes()


            self.state = 516
            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 TypeParameterWithDefaultDeclContext(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(PhpParser.IdentifierContext,0)


        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)

        def qualifiedStaticTypeRef(self):
            return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,0)


        def primitiveType(self):
            return self.getTypedRuleContext(PhpParser.PrimitiveTypeContext,0)


        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_typeParameterWithDefaultDecl

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

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




    def typeParameterWithDefaultDecl(self):

        localctx = PhpParser.TypeParameterWithDefaultDeclContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_typeParameterWithDefaultDecl)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 519
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 518
                self.attributes()


            self.state = 521
            self.identifier()
            self.state = 522
            self.match(PhpParser.Eq)
            self.state = 525
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
            if la_ == 1:
                self.state = 523
                self.qualifiedStaticTypeRef()
                pass

            elif la_ == 2:
                self.state = 524
                self.primitiveType()
                pass


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


    class GenericDynamicArgsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Lgeneric(self):
            return self.getToken(PhpParser.Lgeneric, 0)

        def typeRef(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.TypeRefContext)
            else:
                return self.getTypedRuleContext(PhpParser.TypeRefContext,i)


        def Rgeneric(self):
            return self.getToken(PhpParser.Rgeneric, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_genericDynamicArgs

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

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




    def genericDynamicArgs(self):

        localctx = PhpParser.GenericDynamicArgsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_genericDynamicArgs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527
            self.match(PhpParser.Lgeneric)
            self.state = 528
            self.typeRef()
            self.state = 533
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 529
                self.match(PhpParser.Comma)
                self.state = 530
                self.typeRef()
                self.state = 535
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 536
            self.match(PhpParser.Rgeneric)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def attributeGroup(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.AttributeGroupContext)
            else:
                return self.getTypedRuleContext(PhpParser.AttributeGroupContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_attributes

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

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




    def attributes(self):

        localctx = PhpParser.AttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 538
                self.attributeGroup()
                self.state = 541 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==43):
                    break

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


    class AttributeGroupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AttributeStart(self):
            return self.getToken(PhpParser.AttributeStart, 0)

        def attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.AttributeContext)
            else:
                return self.getTypedRuleContext(PhpParser.AttributeContext,i)


        def CloseSquareBracket(self):
            return self.getToken(PhpParser.CloseSquareBracket, 0)

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


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

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

        def getRuleIndex(self):
            return PhpParser.RULE_attributeGroup

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

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




    def attributeGroup(self):

        localctx = PhpParser.AttributeGroupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_attributeGroup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            self.match(PhpParser.AttributeStart)
            self.state = 547
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.state = 544
                self.identifier()
                self.state = 545
                self.match(PhpParser.Colon)


            self.state = 549
            self.attribute()
            self.state = 554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 550
                self.match(PhpParser.Comma)
                self.state = 551
                self.attribute()
                self.state = 556
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 557
            self.match(PhpParser.CloseSquareBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def arguments(self):
            return self.getTypedRuleContext(PhpParser.ArgumentsContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_attribute

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

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




    def attribute(self):

        localctx = PhpParser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 559
            self.qualifiedNamespaceName()
            self.state = 561
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==212:
                self.state = 560
                self.arguments()


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


    class InnerStatementListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def innerStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.InnerStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.InnerStatementContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_innerStatementList

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

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




    def innerStatementList(self):

        localctx = PhpParser.InnerStatementListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_innerStatementList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 566
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 563
                    self.innerStatement() 
                self.state = 568
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,47,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 InnerStatementContext(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(PhpParser.StatementContext,0)


        def functionDeclaration(self):
            return self.getTypedRuleContext(PhpParser.FunctionDeclarationContext,0)


        def classDeclaration(self):
            return self.getTypedRuleContext(PhpParser.ClassDeclarationContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_innerStatement

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

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




    def innerStatement(self):

        localctx = PhpParser.InnerStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_innerStatement)
        try:
            self.state = 572
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 569
                self.statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 570
                self.functionDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 571
                self.classDeclaration()
                pass


        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 identifier(self):
            return self.getTypedRuleContext(PhpParser.IdentifierContext,0)


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

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


        def ifStatement(self):
            return self.getTypedRuleContext(PhpParser.IfStatementContext,0)


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


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


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


        def switchStatement(self):
            return self.getTypedRuleContext(PhpParser.SwitchStatementContext,0)


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


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


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


        def yieldExpression(self):
            return self.getTypedRuleContext(PhpParser.YieldExpressionContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def globalStatement(self):
            return self.getTypedRuleContext(PhpParser.GlobalStatementContext,0)


        def staticVariableStatement(self):
            return self.getTypedRuleContext(PhpParser.StaticVariableStatementContext,0)


        def echoStatement(self):
            return self.getTypedRuleContext(PhpParser.EchoStatementContext,0)


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


        def unsetStatement(self):
            return self.getTypedRuleContext(PhpParser.UnsetStatementContext,0)


        def foreachStatement(self):
            return self.getTypedRuleContext(PhpParser.ForeachStatementContext,0)


        def tryCatchFinally(self):
            return self.getTypedRuleContext(PhpParser.TryCatchFinallyContext,0)


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


        def gotoStatement(self):
            return self.getTypedRuleContext(PhpParser.GotoStatementContext,0)


        def declareStatement(self):
            return self.getTypedRuleContext(PhpParser.DeclareStatementContext,0)


        def emptyStatement_(self):
            return self.getTypedRuleContext(PhpParser.EmptyStatement_Context,0)


        def inlineHtmlStatement(self):
            return self.getTypedRuleContext(PhpParser.InlineHtmlStatementContext,0)


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_statement)
        try:
            self.state = 601
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 574
                self.identifier()
                self.state = 575
                self.match(PhpParser.Colon)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 577
                self.blockStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 578
                self.ifStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 579
                self.whileStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 580
                self.doWhileStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 581
                self.forStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 582
                self.switchStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 583
                self.breakStatement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 584
                self.continueStatement()
                pass

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

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 586
                self.yieldExpression()
                self.state = 587
                self.match(PhpParser.SemiColon)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 589
                self.globalStatement()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 590
                self.staticVariableStatement()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 591
                self.echoStatement()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 592
                self.expressionStatement()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 593
                self.unsetStatement()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 594
                self.foreachStatement()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 595
                self.tryCatchFinally()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 596
                self.throwStatement()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 597
                self.gotoStatement()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 598
                self.declareStatement()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 599
                self.emptyStatement_()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 600
                self.inlineHtmlStatement()
                pass


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


    class EmptyStatement_Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_emptyStatement_

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

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




    def emptyStatement_(self):

        localctx = PhpParser.EmptyStatement_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_emptyStatement_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 603
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_blockStatement

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

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




    def blockStatement(self):

        localctx = PhpParser.BlockStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_blockStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            self.match(PhpParser.OpenCurlyBracket)
            self.state = 606
            self.innerStatementList()
            self.state = 607
            self.match(PhpParser.CloseCurlyBracket)
        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 If(self):
            return self.getToken(PhpParser.If, 0)

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


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


        def elseIfStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ElseIfStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.ElseIfStatementContext,i)


        def elseStatement(self):
            return self.getTypedRuleContext(PhpParser.ElseStatementContext,0)


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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def EndIf(self):
            return self.getToken(PhpParser.EndIf, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def elseIfColonStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ElseIfColonStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.ElseIfColonStatementContext,i)


        def elseColonStatement(self):
            return self.getTypedRuleContext(PhpParser.ElseColonStatementContext,0)


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_ifStatement)
        self._la = 0 # Token type
        try:
            self.state = 637
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 609
                self.match(PhpParser.If)
                self.state = 610
                self.parentheses()
                self.state = 611
                self.statement()
                self.state = 615
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,50,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 612
                        self.elseIfStatement() 
                    self.state = 617
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,50,self._ctx)

                self.state = 619
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                if la_ == 1:
                    self.state = 618
                    self.elseStatement()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 621
                self.match(PhpParser.If)
                self.state = 622
                self.parentheses()
                self.state = 623
                self.match(PhpParser.Colon)
                self.state = 624
                self.innerStatementList()
                self.state = 628
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==65:
                    self.state = 625
                    self.elseIfColonStatement()
                    self.state = 630
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 632
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==64:
                    self.state = 631
                    self.elseColonStatement()


                self.state = 634
                self.match(PhpParser.EndIf)
                self.state = 635
                self.match(PhpParser.SemiColon)
                pass


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


    class ElseIfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ElseIf(self):
            return self.getToken(PhpParser.ElseIf, 0)

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


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


        def getRuleIndex(self):
            return PhpParser.RULE_elseIfStatement

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

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




    def elseIfStatement(self):

        localctx = PhpParser.ElseIfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_elseIfStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.match(PhpParser.ElseIf)
            self.state = 640
            self.parentheses()
            self.state = 641
            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 ElseIfColonStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ElseIf(self):
            return self.getToken(PhpParser.ElseIf, 0)

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_elseIfColonStatement

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

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




    def elseIfColonStatement(self):

        localctx = PhpParser.ElseIfColonStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_elseIfColonStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 643
            self.match(PhpParser.ElseIf)
            self.state = 644
            self.parentheses()
            self.state = 645
            self.match(PhpParser.Colon)
            self.state = 646
            self.innerStatementList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElseStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return PhpParser.RULE_elseStatement

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

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




    def elseStatement(self):

        localctx = PhpParser.ElseStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_elseStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self.match(PhpParser.Else)
            self.state = 649
            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 ElseColonStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_elseColonStatement

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

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




    def elseColonStatement(self):

        localctx = PhpParser.ElseColonStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_elseColonStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 651
            self.match(PhpParser.Else)
            self.state = 652
            self.match(PhpParser.Colon)
            self.state = 653
            self.innerStatementList()
        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 While(self):
            return self.getToken(PhpParser.While, 0)

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


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


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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def EndWhile(self):
            return self.getToken(PhpParser.EndWhile, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 655
            self.match(PhpParser.While)
            self.state = 656
            self.parentheses()
            self.state = 663
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2, 3, 5, 6, 8, 9, 15, 16, 17, 18, 19, 20, 21, 22, 24, 27, 28, 31, 32, 34, 35, 37, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 165, 166, 194, 200, 202, 203, 207, 208, 209, 212, 214, 216, 220, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235]:
                self.state = 657
                self.statement()
                pass
            elif token in [219]:
                self.state = 658
                self.match(PhpParser.Colon)
                self.state = 659
                self.innerStatementList()
                self.state = 660
                self.match(PhpParser.EndWhile)
                self.state = 661
                self.match(PhpParser.SemiColon)
                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 DoWhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.DoWhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_doWhileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(PhpParser.Do)
            self.state = 666
            self.statement()
            self.state = 667
            self.match(PhpParser.While)
            self.state = 668
            self.parentheses()
            self.state = 669
            self.match(PhpParser.SemiColon)
        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 For(self):
            return self.getToken(PhpParser.For, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

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

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

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


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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def EndFor(self):
            return self.getToken(PhpParser.EndFor, 0)

        def forInit(self):
            return self.getTypedRuleContext(PhpParser.ForInitContext,0)


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


        def forUpdate(self):
            return self.getTypedRuleContext(PhpParser.ForUpdateContext,0)


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            self.match(PhpParser.For)
            self.state = 672
            self.match(PhpParser.OpenRoundBracket)
            self.state = 674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                self.state = 673
                self.forInit()


            self.state = 676
            self.match(PhpParser.SemiColon)
            self.state = 678
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                self.state = 677
                self.expressionList()


            self.state = 680
            self.match(PhpParser.SemiColon)
            self.state = 682
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                self.state = 681
                self.forUpdate()


            self.state = 684
            self.match(PhpParser.CloseRoundBracket)
            self.state = 691
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2, 3, 5, 6, 8, 9, 15, 16, 17, 18, 19, 20, 21, 22, 24, 27, 28, 31, 32, 34, 35, 37, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 165, 166, 194, 200, 202, 203, 207, 208, 209, 212, 214, 216, 220, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235]:
                self.state = 685
                self.statement()
                pass
            elif token in [219]:
                self.state = 686
                self.match(PhpParser.Colon)
                self.state = 687
                self.innerStatementList()
                self.state = 688
                self.match(PhpParser.EndFor)
                self.state = 689
                self.match(PhpParser.SemiColon)
                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 ForInitContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return PhpParser.RULE_forInit

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

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




    def forInit(self):

        localctx = PhpParser.ForInitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_forInit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 693
            self.expressionList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForUpdateContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return PhpParser.RULE_forUpdate

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

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




    def forUpdate(self):

        localctx = PhpParser.ForUpdateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_forUpdate)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 695
            self.expressionList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SwitchStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

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

        def EndSwitch(self):
            return self.getToken(PhpParser.EndSwitch, 0)

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

        def switchBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.SwitchBlockContext)
            else:
                return self.getTypedRuleContext(PhpParser.SwitchBlockContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_switchStatement

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

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




    def switchStatement(self):

        localctx = PhpParser.SwitchStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_switchStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 697
            self.match(PhpParser.Switch)
            self.state = 698
            self.parentheses()
            self.state = 722
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [216]:
                self.state = 699
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 701
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==220:
                    self.state = 700
                    self.match(PhpParser.SemiColon)


                self.state = 706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==52 or _la==59:
                    self.state = 703
                    self.switchBlock()
                    self.state = 708
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 709
                self.match(PhpParser.CloseCurlyBracket)
                pass
            elif token in [219]:
                self.state = 710
                self.match(PhpParser.Colon)
                self.state = 712
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==220:
                    self.state = 711
                    self.match(PhpParser.SemiColon)


                self.state = 717
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==52 or _la==59:
                    self.state = 714
                    self.switchBlock()
                    self.state = 719
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 720
                self.match(PhpParser.EndSwitch)
                self.state = 721
                self.match(PhpParser.SemiColon)
                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 SwitchBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


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

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

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

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


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

        def getRuleIndex(self):
            return PhpParser.RULE_switchBlock

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

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




    def switchBlock(self):

        localctx = PhpParser.SwitchBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_switchBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 727
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [52]:
                        self.state = 724
                        self.match(PhpParser.Case)
                        self.state = 725
                        self.expression(0)
                        pass
                    elif token in [59]:
                        self.state = 726
                        self.match(PhpParser.Default)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 729
                    _la = self._input.LA(1)
                    if not(_la==219 or _la==220):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

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

            self.state = 734
            self.innerStatementList()
        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 Break(self):
            return self.getToken(PhpParser.Break, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

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


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_breakStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 736
            self.match(PhpParser.Break)
            self.state = 738
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                self.state = 737
                self.expression(0)


            self.state = 740
            self.match(PhpParser.SemiColon)
        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 Continue(self):
            return self.getToken(PhpParser.Continue, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

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


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.ContinueStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_continueStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 742
            self.match(PhpParser.Continue)
            self.state = 744
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                self.state = 743
                self.expression(0)


            self.state = 746
            self.match(PhpParser.SemiColon)
        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 Return(self):
            return self.getToken(PhpParser.Return, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

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


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_returnStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 748
            self.match(PhpParser.Return)
            self.state = 750
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                self.state = 749
                self.expression(0)


            self.state = 752
            self.match(PhpParser.SemiColon)
        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(PhpParser.ExpressionContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_expressionStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 754
            self.expression(0)
            self.state = 755
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnsetStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Unset(self):
            return self.getToken(PhpParser.Unset, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def chainList(self):
            return self.getTypedRuleContext(PhpParser.ChainListContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_unsetStatement

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

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




    def unsetStatement(self):

        localctx = PhpParser.UnsetStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_unsetStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 757
            self.match(PhpParser.Unset)
            self.state = 758
            self.match(PhpParser.OpenRoundBracket)
            self.state = 759
            self.chainList()
            self.state = 760
            self.match(PhpParser.CloseRoundBracket)
            self.state = 761
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForeachStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Foreach(self):
            return self.getToken(PhpParser.Foreach, 0)

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

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


        def As(self):
            return self.getToken(PhpParser.As, 0)

        def arrayDestructuring(self):
            return self.getTypedRuleContext(PhpParser.ArrayDestructuringContext,0)


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

        def chain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ChainContext)
            else:
                return self.getTypedRuleContext(PhpParser.ChainContext,i)


        def assignable(self):
            return self.getTypedRuleContext(PhpParser.AssignableContext,0)


        def List(self):
            return self.getToken(PhpParser.List, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(PhpParser.AssignmentListContext,0)


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


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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def EndForeach(self):
            return self.getToken(PhpParser.EndForeach, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

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

        def DoubleArrow(self):
            return self.getToken(PhpParser.DoubleArrow, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_foreachStatement

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

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




    def foreachStatement(self):

        localctx = PhpParser.ForeachStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_foreachStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 763
            self.match(PhpParser.Foreach)
            self.state = 808
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 764
                self.match(PhpParser.OpenRoundBracket)
                self.state = 765
                self.expression(0)
                self.state = 766
                self.match(PhpParser.As)
                self.state = 767
                self.arrayDestructuring()
                self.state = 768
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 2:
                self.state = 770
                self.match(PhpParser.OpenRoundBracket)
                self.state = 771
                self.chain()
                self.state = 772
                self.match(PhpParser.As)
                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==198:
                    self.state = 773
                    self.match(PhpParser.Ampersand)


                self.state = 776
                self.assignable()
                self.state = 782
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 777
                    self.match(PhpParser.DoubleArrow)
                    self.state = 779
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==198:
                        self.state = 778
                        self.match(PhpParser.Ampersand)


                    self.state = 781
                    self.chain()


                self.state = 784
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 3:
                self.state = 786
                self.match(PhpParser.OpenRoundBracket)
                self.state = 787
                self.expression(0)
                self.state = 788
                self.match(PhpParser.As)
                self.state = 789
                self.assignable()
                self.state = 795
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 790
                    self.match(PhpParser.DoubleArrow)
                    self.state = 792
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==198:
                        self.state = 791
                        self.match(PhpParser.Ampersand)


                    self.state = 794
                    self.chain()


                self.state = 797
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 4:
                self.state = 799
                self.match(PhpParser.OpenRoundBracket)
                self.state = 800
                self.chain()
                self.state = 801
                self.match(PhpParser.As)
                self.state = 802
                self.match(PhpParser.List)
                self.state = 803
                self.match(PhpParser.OpenRoundBracket)
                self.state = 804
                self.assignmentList()
                self.state = 805
                self.match(PhpParser.CloseRoundBracket)
                self.state = 806
                self.match(PhpParser.CloseRoundBracket)
                pass


            self.state = 816
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2, 3, 5, 6, 8, 9, 15, 16, 17, 18, 19, 20, 21, 22, 24, 27, 28, 31, 32, 34, 35, 37, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 165, 166, 194, 200, 202, 203, 207, 208, 209, 212, 214, 216, 220, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235]:
                self.state = 810
                self.statement()
                pass
            elif token in [219]:
                self.state = 811
                self.match(PhpParser.Colon)
                self.state = 812
                self.innerStatementList()
                self.state = 813
                self.match(PhpParser.EndForeach)
                self.state = 814
                self.match(PhpParser.SemiColon)
                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 TryCatchFinallyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Try(self):
            return self.getToken(PhpParser.Try, 0)

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


        def finallyStatement(self):
            return self.getTypedRuleContext(PhpParser.FinallyStatementContext,0)


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


        def getRuleIndex(self):
            return PhpParser.RULE_tryCatchFinally

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

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




    def tryCatchFinally(self):

        localctx = PhpParser.TryCatchFinallyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_tryCatchFinally)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 818
            self.match(PhpParser.Try)
            self.state = 819
            self.blockStatement()
            self.state = 835
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.state = 821 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 820
                        self.catchClause()

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

                self.state = 826
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                if la_ == 1:
                    self.state = 825
                    self.finallyStatement()


                pass

            elif la_ == 2:
                self.state = 831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==53:
                    self.state = 828
                    self.catchClause()
                    self.state = 833
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 834
                self.finallyStatement()
                pass


        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 Catch(self):
            return self.getToken(PhpParser.Catch, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def qualifiedStaticTypeRef(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.QualifiedStaticTypeRefContext)
            else:
                return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,i)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


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

        def VarName(self):
            return self.getToken(PhpParser.VarName, 0)

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.CatchClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_catchClause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 837
            self.match(PhpParser.Catch)
            self.state = 838
            self.match(PhpParser.OpenRoundBracket)
            self.state = 839
            self.qualifiedStaticTypeRef()
            self.state = 844
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==199:
                self.state = 840
                self.match(PhpParser.Pipe)
                self.state = 841
                self.qualifiedStaticTypeRef()
                self.state = 846
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 848
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==224:
                self.state = 847
                self.match(PhpParser.VarName)


            self.state = 850
            self.match(PhpParser.CloseRoundBracket)
            self.state = 851
            self.blockStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FinallyStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Finally(self):
            return self.getToken(PhpParser.Finally, 0)

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_finallyStatement

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

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




    def finallyStatement(self):

        localctx = PhpParser.FinallyStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_finallyStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 853
            self.match(PhpParser.Finally)
            self.state = 854
            self.blockStatement()
        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 Throw(self):
            return self.getToken(PhpParser.Throw, 0)

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


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.ThrowStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_throwStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 856
            self.match(PhpParser.Throw)
            self.state = 857
            self.expression(0)
            self.state = 858
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GotoStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_gotoStatement

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

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




    def gotoStatement(self):

        localctx = PhpParser.GotoStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_gotoStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 860
            self.match(PhpParser.Goto)
            self.state = 861
            self.identifier()
            self.state = 862
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclareStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Declare(self):
            return self.getToken(PhpParser.Declare, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def declareList(self):
            return self.getTypedRuleContext(PhpParser.DeclareListContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

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


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

        def innerStatementList(self):
            return self.getTypedRuleContext(PhpParser.InnerStatementListContext,0)


        def EndDeclare(self):
            return self.getToken(PhpParser.EndDeclare, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_declareStatement

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

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




    def declareStatement(self):

        localctx = PhpParser.DeclareStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_declareStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 864
            self.match(PhpParser.Declare)
            self.state = 865
            self.match(PhpParser.OpenRoundBracket)
            self.state = 866
            self.declareList()
            self.state = 867
            self.match(PhpParser.CloseRoundBracket)
            self.state = 874
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [2, 3, 5, 6, 8, 9, 15, 16, 17, 18, 19, 20, 21, 22, 24, 27, 28, 31, 32, 34, 35, 37, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 165, 166, 194, 200, 202, 203, 207, 208, 209, 212, 214, 216, 220, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235]:
                self.state = 868
                self.statement()
                pass
            elif token in [219]:
                self.state = 869
                self.match(PhpParser.Colon)
                self.state = 870
                self.innerStatementList()
                self.state = 871
                self.match(PhpParser.EndDeclare)
                self.state = 872
                self.match(PhpParser.SemiColon)
                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 InlineHtmlStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def inlineHtml(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.InlineHtmlContext)
            else:
                return self.getTypedRuleContext(PhpParser.InlineHtmlContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_inlineHtmlStatement

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

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




    def inlineHtmlStatement(self):

        localctx = PhpParser.InlineHtmlStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_inlineHtmlStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 877 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 876
                    self.inlineHtml()

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

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

        def directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.DirectiveContext)
            else:
                return self.getTypedRuleContext(PhpParser.DirectiveContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_declareList

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

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




    def declareList(self):

        localctx = PhpParser.DeclareListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_declareList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 881
            self.directive()
            self.state = 886
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 882
                self.match(PhpParser.Comma)
                self.state = 883
                self.directive()
                self.state = 888
                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 DirectiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Ticks(self):
            return self.getToken(PhpParser.Ticks, 0)

        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)

        def numericConstant(self):
            return self.getTypedRuleContext(PhpParser.NumericConstantContext,0)


        def Real(self):
            return self.getToken(PhpParser.Real, 0)

        def Encoding(self):
            return self.getToken(PhpParser.Encoding, 0)

        def SingleQuoteString(self):
            return self.getToken(PhpParser.SingleQuoteString, 0)

        def StrictTypes(self):
            return self.getToken(PhpParser.StrictTypes, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_directive

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

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




    def directive(self):

        localctx = PhpParser.DirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_directive)
        try:
            self.state = 901
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [134]:
                self.enterOuterAlt(localctx, 1)
                self.state = 889
                self.match(PhpParser.Ticks)
                self.state = 890
                self.match(PhpParser.Eq)
                self.state = 893
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [226, 227, 229, 230]:
                    self.state = 891
                    self.numericConstant()
                    pass
                elif token in [228]:
                    self.state = 892
                    self.match(PhpParser.Real)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [135]:
                self.enterOuterAlt(localctx, 2)
                self.state = 895
                self.match(PhpParser.Encoding)
                self.state = 896
                self.match(PhpParser.Eq)
                self.state = 897
                self.match(PhpParser.SingleQuoteString)
                pass
            elif token in [136]:
                self.enterOuterAlt(localctx, 3)
                self.state = 898
                self.match(PhpParser.StrictTypes)
                self.state = 899
                self.match(PhpParser.Eq)
                self.state = 900
                self.numericConstant()
                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 FormalParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def formalParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.FormalParameterContext)
            else:
                return self.getTypedRuleContext(PhpParser.FormalParameterContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_formalParameterList

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

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




    def formalParameterList(self):

        localctx = PhpParser.FormalParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_formalParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 904
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 43)) & ~0x3f) == 0 and ((1 << (_la - 43)) & -1) != 0) or ((((_la - 107)) & ~0x3f) == 0 and ((1 << (_la - 107)) & 18014398509481983) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 3221356563) != 0):
                self.state = 903
                self.formalParameter()


            self.state = 910
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,89,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 906
                    self.match(PhpParser.Comma)
                    self.state = 907
                    self.formalParameter() 
                self.state = 912
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,89,self._ctx)

            self.state = 914
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==218:
                self.state = 913
                self.match(PhpParser.Comma)


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


    class FormalParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variableInitializer(self):
            return self.getTypedRuleContext(PhpParser.VariableInitializerContext,0)


        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def memberModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.MemberModifierContext)
            else:
                return self.getTypedRuleContext(PhpParser.MemberModifierContext,i)


        def QuestionMark(self):
            return self.getToken(PhpParser.QuestionMark, 0)

        def typeHint(self):
            return self.getTypedRuleContext(PhpParser.TypeHintContext,0)


        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_formalParameter

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

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




    def formalParameter(self):

        localctx = PhpParser.FormalParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_formalParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 917
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 916
                self.attributes()


            self.state = 922
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,92,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 919
                    self.memberModifier() 
                self.state = 924
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,92,self._ctx)

            self.state = 926
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==211:
                self.state = 925
                self.match(PhpParser.QuestionMark)


            self.state = 929
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 9007199254740991) != 0) or _la==194 or _la==225:
                self.state = 928
                self.typeHint(0)


            self.state = 932
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==198:
                self.state = 931
                self.match(PhpParser.Ampersand)


            self.state = 935
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==195:
                self.state = 934
                self.match(PhpParser.Ellipsis)


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


    class TypeHintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedStaticTypeRef(self):
            return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,0)


        def Callable(self):
            return self.getToken(PhpParser.Callable, 0)

        def primitiveType(self):
            return self.getTypedRuleContext(PhpParser.PrimitiveTypeContext,0)


        def typeHint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.TypeHintContext)
            else:
                return self.getTypedRuleContext(PhpParser.TypeHintContext,i)


        def Pipe(self):
            return self.getToken(PhpParser.Pipe, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_typeHint

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

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



    def typeHint(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PhpParser.TypeHintContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 118
        self.enterRecursionRule(localctx, 118, self.RULE_typeHint, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 943
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.state = 940
                self.qualifiedStaticTypeRef()
                pass

            elif la_ == 2:
                self.state = 941
                self.match(PhpParser.Callable)
                pass

            elif la_ == 3:
                self.state = 942
                self.primitiveType()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 950
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,98,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 = PhpParser.TypeHintContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeHint)
                    self.state = 945
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 946
                    self.match(PhpParser.Pipe)
                    self.state = 947
                    self.typeHint(2) 
                self.state = 952
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,98,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 GlobalStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Global(self):
            return self.getToken(PhpParser.Global, 0)

        def globalVar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.GlobalVarContext)
            else:
                return self.getTypedRuleContext(PhpParser.GlobalVarContext,i)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_globalStatement

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

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




    def globalStatement(self):

        localctx = PhpParser.GlobalStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_globalStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 953
            self.match(PhpParser.Global)
            self.state = 954
            self.globalVar()
            self.state = 959
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 955
                self.match(PhpParser.Comma)
                self.state = 956
                self.globalVar()
                self.state = 961
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 962
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GlobalVarContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VarName(self):
            return self.getToken(PhpParser.VarName, 0)

        def Dollar(self):
            return self.getToken(PhpParser.Dollar, 0)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

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


        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_globalVar

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

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




    def globalVar(self):

        localctx = PhpParser.GlobalVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_globalVar)
        try:
            self.state = 972
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 964
                self.match(PhpParser.VarName)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 965
                self.match(PhpParser.Dollar)
                self.state = 966
                self.chain()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 967
                self.match(PhpParser.Dollar)
                self.state = 968
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 969
                self.expression(0)
                self.state = 970
                self.match(PhpParser.CloseCurlyBracket)
                pass


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


    class EchoStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Echo(self):
            return self.getToken(PhpParser.Echo, 0)

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


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_echoStatement

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

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




    def echoStatement(self):

        localctx = PhpParser.EchoStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_echoStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 974
            self.match(PhpParser.Echo)
            self.state = 975
            self.expressionList()
            self.state = 976
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StaticVariableStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def variableInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.VariableInitializerContext)
            else:
                return self.getTypedRuleContext(PhpParser.VariableInitializerContext,i)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_staticVariableStatement

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

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




    def staticVariableStatement(self):

        localctx = PhpParser.StaticVariableStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_staticVariableStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 978
            self.match(PhpParser.Static)
            self.state = 979
            self.variableInitializer()
            self.state = 984
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 980
                self.match(PhpParser.Comma)
                self.state = 981
                self.variableInitializer()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 987
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def propertyModifiers(self):
            return self.getTypedRuleContext(PhpParser.PropertyModifiersContext,0)


        def variableInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.VariableInitializerContext)
            else:
                return self.getTypedRuleContext(PhpParser.VariableInitializerContext,i)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def Const(self):
            return self.getToken(PhpParser.Const, 0)

        def identifierInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.IdentifierInitializerContext)
            else:
                return self.getTypedRuleContext(PhpParser.IdentifierInitializerContext,i)


        def Function_(self):
            return self.getToken(PhpParser.Function_, 0)

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


        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(PhpParser.FormalParameterListContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def methodBody(self):
            return self.getTypedRuleContext(PhpParser.MethodBodyContext,0)


        def typeHint(self):
            return self.getTypedRuleContext(PhpParser.TypeHintContext,0)


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

        def memberModifiers(self):
            return self.getTypedRuleContext(PhpParser.MemberModifiersContext,0)


        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def typeParameterListInBrackets(self):
            return self.getTypedRuleContext(PhpParser.TypeParameterListInBracketsContext,0)


        def baseCtorCall(self):
            return self.getTypedRuleContext(PhpParser.BaseCtorCallContext,0)


        def returnTypeDecl(self):
            return self.getTypedRuleContext(PhpParser.ReturnTypeDeclContext,0)


        def Use(self):
            return self.getToken(PhpParser.Use, 0)

        def qualifiedNamespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameListContext,0)


        def traitAdaptations(self):
            return self.getTypedRuleContext(PhpParser.TraitAdaptationsContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_classStatement

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

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




    def classStatement(self):

        localctx = PhpParser.ClassStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_classStatement)
        self._la = 0 # Token type
        try:
            self.state = 1048
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [43, 44, 56, 77, 82, 110, 111, 112, 113, 118, 129]:
                self.enterOuterAlt(localctx, 1)
                self.state = 990
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 989
                    self.attributes()


                self.state = 1042
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 992
                    self.propertyModifiers()
                    self.state = 994
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 9007199254740991) != 0) or _la==194 or _la==225:
                        self.state = 993
                        self.typeHint(0)


                    self.state = 996
                    self.variableInitializer()
                    self.state = 1001
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==218:
                        self.state = 997
                        self.match(PhpParser.Comma)
                        self.state = 998
                        self.variableInitializer()
                        self.state = 1003
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1004
                    self.match(PhpParser.SemiColon)
                    pass

                elif la_ == 2:
                    self.state = 1007
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==44 or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 2327872274433) != 0):
                        self.state = 1006
                        self.memberModifiers()


                    self.state = 1040
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [56]:
                        self.state = 1009
                        self.match(PhpParser.Const)
                        self.state = 1011
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
                        if la_ == 1:
                            self.state = 1010
                            self.typeHint(0)


                        self.state = 1013
                        self.identifierInitializer()
                        self.state = 1018
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==218:
                            self.state = 1014
                            self.match(PhpParser.Comma)
                            self.state = 1015
                            self.identifierInitializer()
                            self.state = 1020
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1021
                        self.match(PhpParser.SemiColon)
                        pass
                    elif token in [82]:
                        self.state = 1023
                        self.match(PhpParser.Function_)
                        self.state = 1025
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==198:
                            self.state = 1024
                            self.match(PhpParser.Ampersand)


                        self.state = 1027
                        self.identifier()
                        self.state = 1029
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==162:
                            self.state = 1028
                            self.typeParameterListInBrackets()


                        self.state = 1031
                        self.match(PhpParser.OpenRoundBracket)
                        self.state = 1032
                        self.formalParameterList()
                        self.state = 1033
                        self.match(PhpParser.CloseRoundBracket)
                        self.state = 1036
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
                        if la_ == 1:
                            self.state = 1034
                            self.baseCtorCall()

                        elif la_ == 2:
                            self.state = 1035
                            self.returnTypeDecl()


                        self.state = 1038
                        self.methodBody()
                        pass
                    else:
                        raise NoViableAltException(self)

                    pass


                pass
            elif token in [128]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1044
                self.match(PhpParser.Use)
                self.state = 1045
                self.qualifiedNamespaceNameList()
                self.state = 1046
                self.traitAdaptations()
                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 TraitAdaptationsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def traitAdaptationStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.TraitAdaptationStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.TraitAdaptationStatementContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_traitAdaptations

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

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




    def traitAdaptations(self):

        localctx = PhpParser.TraitAdaptationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_traitAdaptations)
        self._la = 0 # Token type
        try:
            self.state = 1059
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [220]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1050
                self.match(PhpParser.SemiColon)
                pass
            elif token in [216]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1051
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 1055
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 9007199254740991) != 0) or _la==194 or _la==225:
                    self.state = 1052
                    self.traitAdaptationStatement()
                    self.state = 1057
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1058
                self.match(PhpParser.CloseCurlyBracket)
                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 TraitAdaptationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def traitPrecedence(self):
            return self.getTypedRuleContext(PhpParser.TraitPrecedenceContext,0)


        def traitAlias(self):
            return self.getTypedRuleContext(PhpParser.TraitAliasContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_traitAdaptationStatement

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

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




    def traitAdaptationStatement(self):

        localctx = PhpParser.TraitAdaptationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_traitAdaptationStatement)
        try:
            self.state = 1063
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1061
                self.traitPrecedence()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1062
                self.traitAlias()
                pass


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


    class TraitPrecedenceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def DoubleColon(self):
            return self.getToken(PhpParser.DoubleColon, 0)

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


        def InsteadOf(self):
            return self.getToken(PhpParser.InsteadOf, 0)

        def qualifiedNamespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameListContext,0)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_traitPrecedence

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

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




    def traitPrecedence(self):

        localctx = PhpParser.TraitPrecedenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_traitPrecedence)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1065
            self.qualifiedNamespaceName()
            self.state = 1066
            self.match(PhpParser.DoubleColon)
            self.state = 1067
            self.identifier()
            self.state = 1068
            self.match(PhpParser.InsteadOf)
            self.state = 1069
            self.qualifiedNamespaceNameList()
            self.state = 1070
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TraitAliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def traitMethodReference(self):
            return self.getTypedRuleContext(PhpParser.TraitMethodReferenceContext,0)


        def As(self):
            return self.getToken(PhpParser.As, 0)

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def memberModifier(self):
            return self.getTypedRuleContext(PhpParser.MemberModifierContext,0)


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


        def getRuleIndex(self):
            return PhpParser.RULE_traitAlias

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

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




    def traitAlias(self):

        localctx = PhpParser.TraitAliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_traitAlias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1072
            self.traitMethodReference()
            self.state = 1073
            self.match(PhpParser.As)
            self.state = 1079
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
            if la_ == 1:
                self.state = 1074
                self.memberModifier()
                pass

            elif la_ == 2:
                self.state = 1076
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                if la_ == 1:
                    self.state = 1075
                    self.memberModifier()


                self.state = 1078
                self.identifier()
                pass


            self.state = 1081
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TraitMethodReferenceContext(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(PhpParser.IdentifierContext,0)


        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def DoubleColon(self):
            return self.getToken(PhpParser.DoubleColon, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_traitMethodReference

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

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




    def traitMethodReference(self):

        localctx = PhpParser.TraitMethodReferenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_traitMethodReference)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1086
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.state = 1083
                self.qualifiedNamespaceName()
                self.state = 1084
                self.match(PhpParser.DoubleColon)


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

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

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

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


        def arguments(self):
            return self.getTypedRuleContext(PhpParser.ArgumentsContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_baseCtorCall

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

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




    def baseCtorCall(self):

        localctx = PhpParser.BaseCtorCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_baseCtorCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1090
            self.match(PhpParser.Colon)
            self.state = 1091
            self.identifier()
            self.state = 1093
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==212:
                self.state = 1092
                self.arguments()


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


    class ReturnTypeDeclContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def typeHint(self):
            return self.getTypedRuleContext(PhpParser.TypeHintContext,0)


        def QuestionMark(self):
            return self.getToken(PhpParser.QuestionMark, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_returnTypeDecl

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

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




    def returnTypeDecl(self):

        localctx = PhpParser.ReturnTypeDeclContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_returnTypeDecl)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1095
            self.match(PhpParser.Colon)
            self.state = 1097
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==211:
                self.state = 1096
                self.match(PhpParser.QuestionMark)


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


    class MethodBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_methodBody

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

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




    def methodBody(self):

        localctx = PhpParser.MethodBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_methodBody)
        try:
            self.state = 1103
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [220]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1101
                self.match(PhpParser.SemiColon)
                pass
            elif token in [216]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1102
                self.blockStatement()
                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 PropertyModifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def memberModifiers(self):
            return self.getTypedRuleContext(PhpParser.MemberModifiersContext,0)


        def Var(self):
            return self.getToken(PhpParser.Var, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_propertyModifiers

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

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




    def propertyModifiers(self):

        localctx = PhpParser.PropertyModifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_propertyModifiers)
        try:
            self.state = 1107
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [44, 77, 110, 111, 112, 113, 118]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1105
                self.memberModifiers()
                pass
            elif token in [129]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1106
                self.match(PhpParser.Var)
                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 MemberModifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def memberModifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.MemberModifierContext)
            else:
                return self.getTypedRuleContext(PhpParser.MemberModifierContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_memberModifiers

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

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




    def memberModifiers(self):

        localctx = PhpParser.MemberModifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_memberModifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1110 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1109
                    self.memberModifier()

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

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

        def VarName(self):
            return self.getToken(PhpParser.VarName, 0)

        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)

        def constantInitializer(self):
            return self.getTypedRuleContext(PhpParser.ConstantInitializerContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_variableInitializer

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

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




    def variableInitializer(self):

        localctx = PhpParser.VariableInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_variableInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1114
            self.match(PhpParser.VarName)
            self.state = 1117
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==221:
                self.state = 1115
                self.match(PhpParser.Eq)
                self.state = 1116
                self.constantInitializer()


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


    class IdentifierInitializerContext(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(PhpParser.IdentifierContext,0)


        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)

        def constantInitializer(self):
            return self.getTypedRuleContext(PhpParser.ConstantInitializerContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_identifierInitializer

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

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




    def identifierInitializer(self):

        localctx = PhpParser.IdentifierInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_identifierInitializer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1119
            self.identifier()
            self.state = 1120
            self.match(PhpParser.Eq)
            self.state = 1121
            self.constantInitializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GlobalConstantDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Const(self):
            return self.getToken(PhpParser.Const, 0)

        def identifierInitializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.IdentifierInitializerContext)
            else:
                return self.getTypedRuleContext(PhpParser.IdentifierInitializerContext,i)


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


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

        def getRuleIndex(self):
            return PhpParser.RULE_globalConstantDeclaration

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

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




    def globalConstantDeclaration(self):

        localctx = PhpParser.GlobalConstantDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_globalConstantDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1124
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 1123
                self.attributes()


            self.state = 1126
            self.match(PhpParser.Const)
            self.state = 1127
            self.identifierInitializer()
            self.state = 1132
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1128
                self.match(PhpParser.Comma)
                self.state = 1129
                self.identifierInitializer()
                self.state = 1134
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1135
            self.match(PhpParser.SemiColon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Enum_(self):
            return self.getToken(PhpParser.Enum_, 0)

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


        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

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

        def Implements(self):
            return self.getToken(PhpParser.Implements, 0)

        def interfaceList(self):
            return self.getTypedRuleContext(PhpParser.InterfaceListContext,0)


        def enumItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.EnumItemContext)
            else:
                return self.getTypedRuleContext(PhpParser.EnumItemContext,i)


        def IntType(self):
            return self.getToken(PhpParser.IntType, 0)

        def StringType(self):
            return self.getToken(PhpParser.StringType, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_enumDeclaration

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

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




    def enumDeclaration(self):

        localctx = PhpParser.EnumDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_enumDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1137
            self.match(PhpParser.Enum_)
            self.state = 1138
            self.identifier()
            self.state = 1141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==219:
                self.state = 1139
                self.match(PhpParser.Colon)
                self.state = 1140
                _la = self._input.LA(1)
                if not(_la==95 or _la==119):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1145
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==86:
                self.state = 1143
                self.match(PhpParser.Implements)
                self.state = 1144
                self.interfaceList()


            self.state = 1147
            self.match(PhpParser.OpenCurlyBracket)
            self.state = 1151
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4529987906437120) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 2254127685959713) != 0):
                self.state = 1148
                self.enumItem()
                self.state = 1153
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1154
            self.match(PhpParser.CloseCurlyBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EnumItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def SemiColon(self):
            return self.getToken(PhpParser.SemiColon, 0)

        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)

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


        def functionDeclaration(self):
            return self.getTypedRuleContext(PhpParser.FunctionDeclarationContext,0)


        def memberModifiers(self):
            return self.getTypedRuleContext(PhpParser.MemberModifiersContext,0)


        def Use(self):
            return self.getToken(PhpParser.Use, 0)

        def qualifiedNamespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameListContext,0)


        def traitAdaptations(self):
            return self.getTypedRuleContext(PhpParser.TraitAdaptationsContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_enumItem

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

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




    def enumItem(self):

        localctx = PhpParser.EnumItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_enumItem)
        self._la = 0 # Token type
        try:
            self.state = 1172
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [52]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1156
                self.match(PhpParser.Case)
                self.state = 1157
                self.identifier()
                self.state = 1160
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==221:
                    self.state = 1158
                    self.match(PhpParser.Eq)
                    self.state = 1159
                    self.expression(0)


                self.state = 1162
                self.match(PhpParser.SemiColon)
                pass
            elif token in [43, 44, 77, 82, 110, 111, 112, 113, 118]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1165
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44 or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 2327872274433) != 0):
                    self.state = 1164
                    self.memberModifiers()


                self.state = 1167
                self.functionDeclaration()
                pass
            elif token in [128]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1168
                self.match(PhpParser.Use)
                self.state = 1169
                self.qualifiedNamespaceNameList()
                self.state = 1170
                self.traitAdaptations()
                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 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(PhpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(PhpParser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1174
            self.expression(0)
            self.state = 1179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1175
                self.match(PhpParser.Comma)
                self.state = 1176
                self.expression(0)
                self.state = 1181
                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 ParenthesesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

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


        def yieldExpression(self):
            return self.getTypedRuleContext(PhpParser.YieldExpressionContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_parentheses

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

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




    def parentheses(self):

        localctx = PhpParser.ParenthesesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_parentheses)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1182
            self.match(PhpParser.OpenRoundBracket)
            self.state = 1185
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
            if la_ == 1:
                self.state = 1183
                self.expression(0)
                pass

            elif la_ == 2:
                self.state = 1184
                self.yieldExpression()
                pass


            self.state = 1187
            self.match(PhpParser.CloseRoundBracket)
        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 getRuleIndex(self):
            return PhpParser.RULE_expression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class ChainExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


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

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


    class SpecialWordExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Yield(self):
            return self.getToken(PhpParser.Yield, 0)
        def List(self):
            return self.getToken(PhpParser.List, 0)
        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)
        def assignmentList(self):
            return self.getTypedRuleContext(PhpParser.AssignmentListContext,0)

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)
        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)
        def expression(self):
            return self.getTypedRuleContext(PhpParser.ExpressionContext,0)

        def IsSet(self):
            return self.getToken(PhpParser.IsSet, 0)
        def chainList(self):
            return self.getTypedRuleContext(PhpParser.ChainListContext,0)

        def Empty(self):
            return self.getToken(PhpParser.Empty, 0)
        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)

        def Eval(self):
            return self.getToken(PhpParser.Eval, 0)
        def Exit(self):
            return self.getToken(PhpParser.Exit, 0)
        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)

        def Include(self):
            return self.getToken(PhpParser.Include, 0)
        def IncludeOnce(self):
            return self.getToken(PhpParser.IncludeOnce, 0)
        def Require(self):
            return self.getToken(PhpParser.Require, 0)
        def RequireOnce(self):
            return self.getToken(PhpParser.RequireOnce, 0)
        def Throw(self):
            return self.getToken(PhpParser.Throw, 0)

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

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


    class ArrayCreationExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def arrayCreation(self):
            return self.getTypedRuleContext(PhpParser.ArrayCreationContext,0)


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

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


    class BackQuoteStringExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BackQuoteString(self):
            return self.getToken(PhpParser.BackQuoteString, 0)

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

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


    class MatchExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def matchExpr(self):
            return self.getTypedRuleContext(PhpParser.MatchExprContext,0)


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

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


    class LogicalExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def LogicalAnd(self):
            return self.getToken(PhpParser.LogicalAnd, 0)
        def LogicalXor(self):
            return self.getToken(PhpParser.LogicalXor, 0)
        def LogicalOr(self):
            return self.getToken(PhpParser.LogicalOr, 0)

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

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


    class PrintExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Print(self):
            return self.getToken(PhpParser.Print, 0)
        def expression(self):
            return self.getTypedRuleContext(PhpParser.ExpressionContext,0)


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

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


    class AssignmentExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def assignable(self):
            return self.getTypedRuleContext(PhpParser.AssignableContext,0)

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

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

        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)

        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)
        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)
        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)

        def newExpr(self):
            return self.getTypedRuleContext(PhpParser.NewExprContext,0)


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

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


    class PostfixIncDecExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)

        def Inc(self):
            return self.getToken(PhpParser.Inc, 0)
        def Dec(self):
            return self.getToken(PhpParser.Dec, 0)

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

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


    class CloneExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Clone(self):
            return self.getToken(PhpParser.Clone, 0)
        def expression(self):
            return self.getTypedRuleContext(PhpParser.ExpressionContext,0)


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

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


    class UnaryOperatorExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def Tilde(self):
            return self.getToken(PhpParser.Tilde, 0)
        def SuppressWarnings(self):
            return self.getToken(PhpParser.SuppressWarnings, 0)
        def Bang(self):
            return self.getToken(PhpParser.Bang, 0)
        def Plus(self):
            return self.getToken(PhpParser.Plus, 0)
        def Minus(self):
            return self.getToken(PhpParser.Minus, 0)

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

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


    class NewExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def newExpr(self):
            return self.getTypedRuleContext(PhpParser.NewExprContext,0)


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

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


    class ParenthesisExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


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

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


    class SpaceshipExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def Spaceship(self):
            return self.getToken(PhpParser.Spaceship, 0)

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

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


    class ConditionalExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def Colon(self):
            return self.getToken(PhpParser.Colon, 0)
        def QuestionMark(self):
            return self.getToken(PhpParser.QuestionMark, 0)

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

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


    class NullCoalescingExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def NullCoalescing(self):
            return self.getToken(PhpParser.NullCoalescing, 0)

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

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


    class ArithmeticExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def Pow(self):
            return self.getToken(PhpParser.Pow, 0)
        def Asterisk(self):
            return self.getToken(PhpParser.Asterisk, 0)
        def Divide(self):
            return self.getToken(PhpParser.Divide, 0)
        def Percent(self):
            return self.getToken(PhpParser.Percent, 0)
        def Plus(self):
            return self.getToken(PhpParser.Plus, 0)
        def Minus(self):
            return self.getToken(PhpParser.Minus, 0)
        def Dot(self):
            return self.getToken(PhpParser.Dot, 0)

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

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


    class IndexerExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def stringConstant(self):
            return self.getTypedRuleContext(PhpParser.StringConstantContext,0)

        def OpenSquareBracket(self):
            return self.getToken(PhpParser.OpenSquareBracket, 0)
        def expression(self):
            return self.getTypedRuleContext(PhpParser.ExpressionContext,0)

        def CloseSquareBracket(self):
            return self.getToken(PhpParser.CloseSquareBracket, 0)

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

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


    class ScalarExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def constant(self):
            return self.getTypedRuleContext(PhpParser.ConstantContext,0)

        def string(self):
            return self.getTypedRuleContext(PhpParser.StringContext,0)

        def Label(self):
            return self.getToken(PhpParser.Label, 0)

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

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


    class PrefixIncDecExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)

        def Inc(self):
            return self.getToken(PhpParser.Inc, 0)
        def Dec(self):
            return self.getToken(PhpParser.Dec, 0)

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

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


    class ComparisonExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def ShiftLeft(self):
            return self.getToken(PhpParser.ShiftLeft, 0)
        def ShiftRight(self):
            return self.getToken(PhpParser.ShiftRight, 0)
        def Less(self):
            return self.getToken(PhpParser.Less, 0)
        def IsSmallerOrEqual(self):
            return self.getToken(PhpParser.IsSmallerOrEqual, 0)
        def Greater(self):
            return self.getToken(PhpParser.Greater, 0)
        def IsGreaterOrEqual(self):
            return self.getToken(PhpParser.IsGreaterOrEqual, 0)
        def IsIdentical(self):
            return self.getToken(PhpParser.IsIdentical, 0)
        def IsNoidentical(self):
            return self.getToken(PhpParser.IsNoidentical, 0)
        def IsEqual(self):
            return self.getToken(PhpParser.IsEqual, 0)
        def IsNotEq(self):
            return self.getToken(PhpParser.IsNotEq, 0)

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

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


    class CastExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)
        def castOperation(self):
            return self.getTypedRuleContext(PhpParser.CastOperationContext,0)

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)
        def expression(self):
            return self.getTypedRuleContext(PhpParser.ExpressionContext,0)


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

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


    class InstanceOfExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def InstanceOf(self):
            return self.getToken(PhpParser.InstanceOf, 0)
        def typeRef(self):
            return self.getTypedRuleContext(PhpParser.TypeRefContext,0)


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

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


    class ArrayDestructExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def arrayDestructuring(self):
            return self.getTypedRuleContext(PhpParser.ArrayDestructuringContext,0)

        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)
        def expression(self):
            return self.getTypedRuleContext(PhpParser.ExpressionContext,0)


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

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


    class LambdaFunctionExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def lambdaFunctionExpr(self):
            return self.getTypedRuleContext(PhpParser.LambdaFunctionExprContext,0)


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

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


    class BitwiseExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PhpParser.ExpressionContext
            super().__init__(parser)
            self.op = None # Token
            self.copyFrom(ctx)

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

        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)
        def Caret(self):
            return self.getToken(PhpParser.Caret, 0)
        def Pipe(self):
            return self.getToken(PhpParser.Pipe, 0)
        def BooleanAnd(self):
            return self.getToken(PhpParser.BooleanAnd, 0)
        def BooleanOr(self):
            return self.getToken(PhpParser.BooleanOr, 0)

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

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



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PhpParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 164
        self.enterRecursionRule(localctx, 164, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1279
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
            if la_ == 1:
                localctx = PhpParser.CloneExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 1190
                self.match(PhpParser.Clone)
                self.state = 1191
                self.expression(48)
                pass

            elif la_ == 2:
                localctx = PhpParser.NewExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1192
                self.newExpr()
                pass

            elif la_ == 3:
                localctx = PhpParser.IndexerExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1193
                self.stringConstant()
                self.state = 1194
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1195
                self.expression(0)
                self.state = 1196
                self.match(PhpParser.CloseSquareBracket)
                pass

            elif la_ == 4:
                localctx = PhpParser.CastExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1198
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1199
                self.castOperation()
                self.state = 1200
                self.match(PhpParser.CloseRoundBracket)
                self.state = 1201
                self.expression(45)
                pass

            elif la_ == 5:
                localctx = PhpParser.UnaryOperatorExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1203
                _la = self._input.LA(1)
                if not(_la==207 or _la==208):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1204
                self.expression(44)
                pass

            elif la_ == 6:
                localctx = PhpParser.UnaryOperatorExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1205
                _la = self._input.LA(1)
                if not(((((_la - 200)) & ~0x3f) == 0 and ((1 << (_la - 200)) & 13) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1206
                self.expression(43)
                pass

            elif la_ == 7:
                localctx = PhpParser.PrefixIncDecExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1207
                _la = self._input.LA(1)
                if not(_la==165 or _la==166):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1208
                self.chain()
                pass

            elif la_ == 8:
                localctx = PhpParser.PostfixIncDecExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1209
                self.chain()
                self.state = 1210
                _la = self._input.LA(1)
                if not(_la==165 or _la==166):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 9:
                localctx = PhpParser.PrintExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1212
                self.match(PhpParser.Print)
                self.state = 1213
                self.expression(40)
                pass

            elif la_ == 10:
                localctx = PhpParser.ArrayCreationExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1214
                self.arrayCreation()
                pass

            elif la_ == 11:
                localctx = PhpParser.ChainExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1215
                self.chain()
                pass

            elif la_ == 12:
                localctx = PhpParser.ScalarExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1216
                self.constant()
                pass

            elif la_ == 13:
                localctx = PhpParser.ScalarExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1217
                self.string()
                pass

            elif la_ == 14:
                localctx = PhpParser.ScalarExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1218
                self.match(PhpParser.Label)
                pass

            elif la_ == 15:
                localctx = PhpParser.BackQuoteStringExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1219
                self.match(PhpParser.BackQuoteString)
                pass

            elif la_ == 16:
                localctx = PhpParser.ParenthesisExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1220
                self.parentheses()
                pass

            elif la_ == 17:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1221
                self.match(PhpParser.Yield)
                pass

            elif la_ == 18:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1222
                self.match(PhpParser.List)
                self.state = 1223
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1224
                self.assignmentList()
                self.state = 1225
                self.match(PhpParser.CloseRoundBracket)
                self.state = 1226
                self.match(PhpParser.Eq)
                self.state = 1227
                self.expression(31)
                pass

            elif la_ == 19:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1229
                self.match(PhpParser.IsSet)
                self.state = 1230
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1231
                self.chainList()
                self.state = 1232
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 20:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1234
                self.match(PhpParser.Empty)
                self.state = 1235
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1236
                self.chain()
                self.state = 1237
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 21:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1239
                self.match(PhpParser.Eval)
                self.state = 1240
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1241
                self.expression(0)
                self.state = 1242
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 22:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1244
                self.match(PhpParser.Exit)
                self.state = 1248
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                if la_ == 1:
                    self.state = 1245
                    self.match(PhpParser.OpenRoundBracket)
                    self.state = 1246
                    self.match(PhpParser.CloseRoundBracket)

                elif la_ == 2:
                    self.state = 1247
                    self.parentheses()


                pass

            elif la_ == 23:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1250
                _la = self._input.LA(1)
                if not(_la==88 or _la==89):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1251
                self.expression(26)
                pass

            elif la_ == 24:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1252
                _la = self._input.LA(1)
                if not(_la==114 or _la==115):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1253
                self.expression(25)
                pass

            elif la_ == 25:
                localctx = PhpParser.LambdaFunctionExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1254
                self.lambdaFunctionExpr()
                pass

            elif la_ == 26:
                localctx = PhpParser.MatchExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1255
                self.matchExpr()
                pass

            elif la_ == 27:
                localctx = PhpParser.SpecialWordExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1256
                self.match(PhpParser.Throw)
                self.state = 1257
                self.expression(7)
                pass

            elif la_ == 28:
                localctx = PhpParser.ArrayDestructExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1258
                self.arrayDestructuring()
                self.state = 1259
                self.match(PhpParser.Eq)
                self.state = 1260
                self.expression(6)
                pass

            elif la_ == 29:
                localctx = PhpParser.AssignmentExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1262
                self.assignable()
                self.state = 1263
                self.assignmentOperator()
                self.state = 1265
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 1264
                    self.attributes()


                self.state = 1267
                self.expression(5)
                pass

            elif la_ == 30:
                localctx = PhpParser.AssignmentExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 1269
                self.assignable()
                self.state = 1270
                self.match(PhpParser.Eq)
                self.state = 1272
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 1271
                    self.attributes()


                self.state = 1274
                self.match(PhpParser.Ampersand)
                self.state = 1277
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
                if la_ == 1:
                    self.state = 1275
                    self.chain()
                    pass

                elif la_ == 2:
                    self.state = 1276
                    self.newExpr()
                    pass


                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1341
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,143,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 = 1339
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
                    if la_ == 1:
                        localctx = PhpParser.ArithmeticExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1281
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 1282
                        localctx.op = self.match(PhpParser.Pow)
                        self.state = 1283
                        self.expression(22)
                        pass

                    elif la_ == 2:
                        localctx = PhpParser.ArithmeticExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1284
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 1285
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 204)) & ~0x3f) == 0 and ((1 << (_la - 204)) & 7) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1286
                        self.expression(21)
                        pass

                    elif la_ == 3:
                        localctx = PhpParser.ArithmeticExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1287
                        if not self.precpred(self._ctx, 19):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
                        self.state = 1288
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & 259) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1289
                        self.expression(20)
                        pass

                    elif la_ == 4:
                        localctx = PhpParser.ComparisonExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1290
                        if not self.precpred(self._ctx, 18):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
                        self.state = 1291
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==190 or _la==191):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1292
                        self.expression(19)
                        pass

                    elif la_ == 5:
                        localctx = PhpParser.ComparisonExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1293
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 1294
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 171)) & ~0x3f) == 0 and ((1 << (_la - 171)) & 100663299) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1295
                        self.expression(18)
                        pass

                    elif la_ == 6:
                        localctx = PhpParser.ComparisonExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1296
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 1297
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 167)) & ~0x3f) == 0 and ((1 << (_la - 167)) & 15) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1298
                        self.expression(17)
                        pass

                    elif la_ == 7:
                        localctx = PhpParser.BitwiseExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1299
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 1300
                        localctx.op = self.match(PhpParser.Ampersand)
                        self.state = 1301
                        self.expression(16)
                        pass

                    elif la_ == 8:
                        localctx = PhpParser.BitwiseExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1302
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1303
                        localctx.op = self.match(PhpParser.Caret)
                        self.state = 1304
                        self.expression(15)
                        pass

                    elif la_ == 9:
                        localctx = PhpParser.BitwiseExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1305
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 1306
                        localctx.op = self.match(PhpParser.Pipe)
                        self.state = 1307
                        self.expression(14)
                        pass

                    elif la_ == 10:
                        localctx = PhpParser.BitwiseExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1308
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1309
                        localctx.op = self.match(PhpParser.BooleanAnd)
                        self.state = 1310
                        self.expression(13)
                        pass

                    elif la_ == 11:
                        localctx = PhpParser.BitwiseExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1311
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1312
                        localctx.op = self.match(PhpParser.BooleanOr)
                        self.state = 1313
                        self.expression(12)
                        pass

                    elif la_ == 12:
                        localctx = PhpParser.ConditionalExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1314
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1315
                        localctx.op = self.match(PhpParser.QuestionMark)
                        self.state = 1317
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                            self.state = 1316
                            self.expression(0)


                        self.state = 1319
                        self.match(PhpParser.Colon)
                        self.state = 1320
                        self.expression(11)
                        pass

                    elif la_ == 13:
                        localctx = PhpParser.NullCoalescingExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1321
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1322
                        localctx.op = self.match(PhpParser.NullCoalescing)
                        self.state = 1323
                        self.expression(10)
                        pass

                    elif la_ == 14:
                        localctx = PhpParser.SpaceshipExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1324
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1325
                        localctx.op = self.match(PhpParser.Spaceship)
                        self.state = 1326
                        self.expression(9)
                        pass

                    elif la_ == 15:
                        localctx = PhpParser.LogicalExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1327
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1328
                        localctx.op = self.match(PhpParser.LogicalAnd)
                        self.state = 1329
                        self.expression(4)
                        pass

                    elif la_ == 16:
                        localctx = PhpParser.LogicalExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1330
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1331
                        localctx.op = self.match(PhpParser.LogicalXor)
                        self.state = 1332
                        self.expression(3)
                        pass

                    elif la_ == 17:
                        localctx = PhpParser.LogicalExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1333
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1334
                        localctx.op = self.match(PhpParser.LogicalOr)
                        self.state = 1335
                        self.expression(2)
                        pass

                    elif la_ == 18:
                        localctx = PhpParser.InstanceOfExpressionContext(self, PhpParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1336
                        if not self.precpred(self._ctx, 21):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                        self.state = 1337
                        self.match(PhpParser.InstanceOf)
                        self.state = 1338
                        self.typeRef()
                        pass

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

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

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def arrayCreation(self):
            return self.getTypedRuleContext(PhpParser.ArrayCreationContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_assignable

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

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




    def assignable(self):

        localctx = PhpParser.AssignableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_assignable)
        try:
            self.state = 1346
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1344
                self.chain()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1345
                self.arrayCreation()
                pass


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


    class ArrayCreationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Array(self):
            return self.getToken(PhpParser.Array, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

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

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

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


        def arrayItemList(self):
            return self.getTypedRuleContext(PhpParser.ArrayItemListContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_arrayCreation

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

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




    def arrayCreation(self):

        localctx = PhpParser.ArrayCreationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_arrayCreation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1359
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [45]:
                self.state = 1348
                self.match(PhpParser.Array)
                self.state = 1349
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1351
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138193) != 0):
                    self.state = 1350
                    self.arrayItemList()


                self.state = 1353
                self.match(PhpParser.CloseRoundBracket)
                pass
            elif token in [214]:
                self.state = 1354
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1356
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138193) != 0):
                    self.state = 1355
                    self.arrayItemList()


                self.state = 1358
                self.match(PhpParser.CloseSquareBracket)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1365
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.state = 1361
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1362
                self.expression(0)
                self.state = 1363
                self.match(PhpParser.CloseSquareBracket)


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


    class ArrayDestructuringContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenSquareBracket(self):
            return self.getToken(PhpParser.OpenSquareBracket, 0)

        def indexedDestructItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.IndexedDestructItemContext)
            else:
                return self.getTypedRuleContext(PhpParser.IndexedDestructItemContext,i)


        def CloseSquareBracket(self):
            return self.getToken(PhpParser.CloseSquareBracket, 0)

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

        def keyedDestructItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.KeyedDestructItemContext)
            else:
                return self.getTypedRuleContext(PhpParser.KeyedDestructItemContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_arrayDestructuring

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

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




    def arrayDestructuring(self):

        localctx = PhpParser.ArrayDestructuringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_arrayDestructuring)
        self._la = 0 # Token type
        try:
            self.state = 1412
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1367
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1371
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==218:
                    self.state = 1368
                    self.match(PhpParser.Comma)
                    self.state = 1373
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1374
                self.indexedDestructItem()
                self.state = 1383
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,151,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1376 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 1375
                            self.match(PhpParser.Comma)
                            self.state = 1378 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==218):
                                break

                        self.state = 1380
                        self.indexedDestructItem() 
                    self.state = 1385
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,151,self._ctx)

                self.state = 1389
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==218:
                    self.state = 1386
                    self.match(PhpParser.Comma)
                    self.state = 1391
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1392
                self.match(PhpParser.CloseSquareBracket)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1394
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1395
                self.keyedDestructItem()
                self.state = 1404
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,154,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1397 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 1396
                            self.match(PhpParser.Comma)
                            self.state = 1399 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==218):
                                break

                        self.state = 1401
                        self.keyedDestructItem() 
                    self.state = 1406
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,154,self._ctx)

                self.state = 1408
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==218:
                    self.state = 1407
                    self.match(PhpParser.Comma)


                self.state = 1410
                self.match(PhpParser.CloseSquareBracket)
                pass


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


    class IndexedDestructItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_indexedDestructItem

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

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




    def indexedDestructItem(self):

        localctx = PhpParser.IndexedDestructItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_indexedDestructItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==198:
                self.state = 1414
                self.match(PhpParser.Ampersand)


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


    class KeyedDestructItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


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


        def DoubleArrow(self):
            return self.getToken(PhpParser.DoubleArrow, 0)

        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_keyedDestructItem

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

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




    def keyedDestructItem(self):

        localctx = PhpParser.KeyedDestructItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_keyedDestructItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1422
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
            if la_ == 1:
                self.state = 1419
                self.expression(0)
                self.state = 1420
                self.match(PhpParser.DoubleArrow)


            self.state = 1425
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==198:
                self.state = 1424
                self.match(PhpParser.Ampersand)


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


    class LambdaFunctionExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Function_(self):
            return self.getToken(PhpParser.Function_, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(PhpParser.FormalParameterListContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def blockStatement(self):
            return self.getTypedRuleContext(PhpParser.BlockStatementContext,0)


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

        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def lambdaFunctionUseVars(self):
            return self.getTypedRuleContext(PhpParser.LambdaFunctionUseVarsContext,0)


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

        def typeHint(self):
            return self.getTypedRuleContext(PhpParser.TypeHintContext,0)


        def LambdaFn(self):
            return self.getToken(PhpParser.LambdaFn, 0)

        def DoubleArrow(self):
            return self.getToken(PhpParser.DoubleArrow, 0)

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


        def getRuleIndex(self):
            return PhpParser.RULE_lambdaFunctionExpr

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

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




    def lambdaFunctionExpr(self):

        localctx = PhpParser.LambdaFunctionExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_lambdaFunctionExpr)
        self._la = 0 # Token type
        try:
            self.state = 1455
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [82, 118]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1430
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==118:
                    self.state = 1429
                    self.match(PhpParser.Static)


                self.state = 1432
                self.match(PhpParser.Function_)
                self.state = 1434
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==198:
                    self.state = 1433
                    self.match(PhpParser.Ampersand)


                self.state = 1436
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1437
                self.formalParameterList()
                self.state = 1438
                self.match(PhpParser.CloseRoundBracket)
                self.state = 1440
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==128:
                    self.state = 1439
                    self.lambdaFunctionUseVars()


                self.state = 1444
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==219:
                    self.state = 1442
                    self.match(PhpParser.Colon)
                    self.state = 1443
                    self.typeHint(0)


                self.state = 1446
                self.blockStatement()
                pass
            elif token in [133]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1448
                self.match(PhpParser.LambdaFn)
                self.state = 1449
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1450
                self.formalParameterList()
                self.state = 1451
                self.match(PhpParser.CloseRoundBracket)
                self.state = 1452
                self.match(PhpParser.DoubleArrow)
                self.state = 1453
                self.expression(0)
                pass
            else:
                raise NoViableAltException(self)

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


    class MatchExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Match_(self):
            return self.getToken(PhpParser.Match_, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

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


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def matchItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.MatchItemContext)
            else:
                return self.getTypedRuleContext(PhpParser.MatchItemContext,i)


        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_matchExpr

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

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




    def matchExpr(self):

        localctx = PhpParser.MatchExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_matchExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1457
            self.match(PhpParser.Match_)
            self.state = 1458
            self.match(PhpParser.OpenRoundBracket)
            self.state = 1459
            self.expression(0)
            self.state = 1460
            self.match(PhpParser.CloseRoundBracket)
            self.state = 1461
            self.match(PhpParser.OpenCurlyBracket)
            self.state = 1462
            self.matchItem()
            self.state = 1467
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,165,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1463
                    self.match(PhpParser.Comma)
                    self.state = 1464
                    self.matchItem() 
                self.state = 1469
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,165,self._ctx)

            self.state = 1471
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==218:
                self.state = 1470
                self.match(PhpParser.Comma)


            self.state = 1473
            self.match(PhpParser.CloseCurlyBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MatchItemContext(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(PhpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(PhpParser.ExpressionContext,i)


        def DoubleArrow(self):
            return self.getToken(PhpParser.DoubleArrow, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_matchItem

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

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




    def matchItem(self):

        localctx = PhpParser.MatchItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_matchItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1475
            self.expression(0)
            self.state = 1480
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1476
                self.match(PhpParser.Comma)
                self.state = 1477
                self.expression(0)
                self.state = 1482
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1483
            self.match(PhpParser.DoubleArrow)
            self.state = 1484
            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 NewExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def typeRef(self):
            return self.getTypedRuleContext(PhpParser.TypeRefContext,0)


        def arguments(self):
            return self.getTypedRuleContext(PhpParser.ArgumentsContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_newExpr

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

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




    def newExpr(self):

        localctx = PhpParser.NewExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_newExpr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1486
            self.match(PhpParser.New)
            self.state = 1487
            self.typeRef()
            self.state = 1489
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
            if la_ == 1:
                self.state = 1488
                self.arguments()


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


    class AssignmentOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Eq(self):
            return self.getToken(PhpParser.Eq, 0)

        def PlusEqual(self):
            return self.getToken(PhpParser.PlusEqual, 0)

        def MinusEqual(self):
            return self.getToken(PhpParser.MinusEqual, 0)

        def MulEqual(self):
            return self.getToken(PhpParser.MulEqual, 0)

        def PowEqual(self):
            return self.getToken(PhpParser.PowEqual, 0)

        def DivEqual(self):
            return self.getToken(PhpParser.DivEqual, 0)

        def Concaequal(self):
            return self.getToken(PhpParser.Concaequal, 0)

        def ModEqual(self):
            return self.getToken(PhpParser.ModEqual, 0)

        def AndEqual(self):
            return self.getToken(PhpParser.AndEqual, 0)

        def OrEqual(self):
            return self.getToken(PhpParser.OrEqual, 0)

        def XorEqual(self):
            return self.getToken(PhpParser.XorEqual, 0)

        def ShiftLeftEqual(self):
            return self.getToken(PhpParser.ShiftLeftEqual, 0)

        def ShiftRightEqual(self):
            return self.getToken(PhpParser.ShiftRightEqual, 0)

        def NullCoalescingEqual(self):
            return self.getToken(PhpParser.NullCoalescingEqual, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_assignmentOperator

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

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




    def assignmentOperator(self):

        localctx = PhpParser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1491
            _la = self._input.LA(1)
            if not(((((_la - 173)) & ~0x3f) == 0 and ((1 << (_la - 173)) & 281474976784375) != 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 YieldExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Yield(self):
            return self.getToken(PhpParser.Yield, 0)

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


        def From(self):
            return self.getToken(PhpParser.From, 0)

        def DoubleArrow(self):
            return self.getToken(PhpParser.DoubleArrow, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_yieldExpression

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

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




    def yieldExpression(self):

        localctx = PhpParser.YieldExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_yieldExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1493
            self.match(PhpParser.Yield)
            self.state = 1501
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
            if la_ == 1:
                self.state = 1494
                self.expression(0)
                self.state = 1497
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1495
                    self.match(PhpParser.DoubleArrow)
                    self.state = 1496
                    self.expression(0)


                pass

            elif la_ == 2:
                self.state = 1499
                self.match(PhpParser.From)
                self.state = 1500
                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 ArrayItemListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def arrayItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ArrayItemContext)
            else:
                return self.getTypedRuleContext(PhpParser.ArrayItemContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_arrayItemList

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

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




    def arrayItemList(self):

        localctx = PhpParser.ArrayItemListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_arrayItemList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1503
            self.arrayItem()
            self.state = 1508
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,171,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1504
                    self.match(PhpParser.Comma)
                    self.state = 1505
                    self.arrayItem() 
                self.state = 1510
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,171,self._ctx)

            self.state = 1512
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
            if la_ == 1:
                self.state = 1511
                self.match(PhpParser.Comma)


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


    class ArrayItemContext(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(PhpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(PhpParser.ExpressionContext,i)


        def DoubleArrow(self):
            return self.getToken(PhpParser.DoubleArrow, 0)

        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_arrayItem

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

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




    def arrayItem(self):

        localctx = PhpParser.ArrayItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_arrayItem)
        self._la = 0 # Token type
        try:
            self.state = 1526
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1514
                self.expression(0)
                self.state = 1517
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1515
                    self.match(PhpParser.DoubleArrow)
                    self.state = 1516
                    self.expression(0)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1522
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                    self.state = 1519
                    self.expression(0)
                    self.state = 1520
                    self.match(PhpParser.DoubleArrow)


                self.state = 1524
                self.match(PhpParser.Ampersand)
                self.state = 1525
                self.chain()
                pass


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


    class LambdaFunctionUseVarsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Use(self):
            return self.getToken(PhpParser.Use, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def lambdaFunctionUseVar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.LambdaFunctionUseVarContext)
            else:
                return self.getTypedRuleContext(PhpParser.LambdaFunctionUseVarContext,i)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_lambdaFunctionUseVars

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

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




    def lambdaFunctionUseVars(self):

        localctx = PhpParser.LambdaFunctionUseVarsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_lambdaFunctionUseVars)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1528
            self.match(PhpParser.Use)
            self.state = 1529
            self.match(PhpParser.OpenRoundBracket)
            self.state = 1530
            self.lambdaFunctionUseVar()
            self.state = 1535
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1531
                self.match(PhpParser.Comma)
                self.state = 1532
                self.lambdaFunctionUseVar()
                self.state = 1537
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1538
            self.match(PhpParser.CloseRoundBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LambdaFunctionUseVarContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VarName(self):
            return self.getToken(PhpParser.VarName, 0)

        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_lambdaFunctionUseVar

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

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




    def lambdaFunctionUseVar(self):

        localctx = PhpParser.LambdaFunctionUseVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_lambdaFunctionUseVar)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1541
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==198:
                self.state = 1540
                self.match(PhpParser.Ampersand)


            self.state = 1543
            self.match(PhpParser.VarName)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedStaticTypeRefContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def genericDynamicArgs(self):
            return self.getTypedRuleContext(PhpParser.GenericDynamicArgsContext,0)


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

        def getRuleIndex(self):
            return PhpParser.RULE_qualifiedStaticTypeRef

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

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




    def qualifiedStaticTypeRef(self):

        localctx = PhpParser.QualifiedStaticTypeRefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_qualifiedStaticTypeRef)
        try:
            self.state = 1550
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,179,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1545
                self.qualifiedNamespaceName()
                self.state = 1547
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
                if la_ == 1:
                    self.state = 1546
                    self.genericDynamicArgs()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1549
                self.match(PhpParser.Static)
                pass


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


    class TypeRefContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def indirectTypeRef(self):
            return self.getTypedRuleContext(PhpParser.IndirectTypeRefContext,0)


        def genericDynamicArgs(self):
            return self.getTypedRuleContext(PhpParser.GenericDynamicArgsContext,0)


        def primitiveType(self):
            return self.getTypedRuleContext(PhpParser.PrimitiveTypeContext,0)


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

        def anonymousClass(self):
            return self.getTypedRuleContext(PhpParser.AnonymousClassContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_typeRef

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

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




    def typeRef(self):

        localctx = PhpParser.TypeRefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_typeRef)
        try:
            self.state = 1562
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,182,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1554
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
                if la_ == 1:
                    self.state = 1552
                    self.qualifiedNamespaceName()
                    pass

                elif la_ == 2:
                    self.state = 1553
                    self.indirectTypeRef()
                    pass


                self.state = 1557
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
                if la_ == 1:
                    self.state = 1556
                    self.genericDynamicArgs()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1559
                self.primitiveType()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1560
                self.match(PhpParser.Static)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1561
                self.anonymousClass()
                pass


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


    class AnonymousClassContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def classEntryType(self):
            return self.getTypedRuleContext(PhpParser.ClassEntryTypeContext,0)


        def Interface(self):
            return self.getToken(PhpParser.Interface, 0)

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


        def attributes(self):
            return self.getTypedRuleContext(PhpParser.AttributesContext,0)


        def Private(self):
            return self.getToken(PhpParser.Private, 0)

        def modifier(self):
            return self.getTypedRuleContext(PhpParser.ModifierContext,0)


        def Partial(self):
            return self.getToken(PhpParser.Partial, 0)

        def classStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ClassStatementContext)
            else:
                return self.getTypedRuleContext(PhpParser.ClassStatementContext,i)


        def typeParameterListInBrackets(self):
            return self.getTypedRuleContext(PhpParser.TypeParameterListInBracketsContext,0)


        def Extends(self):
            return self.getToken(PhpParser.Extends, 0)

        def qualifiedStaticTypeRef(self):
            return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,0)


        def Implements(self):
            return self.getToken(PhpParser.Implements, 0)

        def interfaceList(self):
            return self.getTypedRuleContext(PhpParser.InterfaceListContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_anonymousClass

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

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




    def anonymousClass(self):

        localctx = PhpParser.AnonymousClassContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_anonymousClass)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1565
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 1564
                self.attributes()


            self.state = 1568
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==110:
                self.state = 1567
                self.match(PhpParser.Private)


            self.state = 1571
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44 or _la==77:
                self.state = 1570
                self.modifier()


            self.state = 1574
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==108:
                self.state = 1573
                self.match(PhpParser.Partial)


            self.state = 1597
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [54, 122]:
                self.state = 1576
                self.classEntryType()
                self.state = 1578
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==162:
                    self.state = 1577
                    self.typeParameterListInBrackets()


                self.state = 1582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==76:
                    self.state = 1580
                    self.match(PhpParser.Extends)
                    self.state = 1581
                    self.qualifiedStaticTypeRef()


                self.state = 1586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==86:
                    self.state = 1584
                    self.match(PhpParser.Implements)
                    self.state = 1585
                    self.interfaceList()


                pass
            elif token in [96]:
                self.state = 1588
                self.match(PhpParser.Interface)
                self.state = 1589
                self.identifier()
                self.state = 1591
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==162:
                    self.state = 1590
                    self.typeParameterListInBrackets()


                self.state = 1595
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==76:
                    self.state = 1593
                    self.match(PhpParser.Extends)
                    self.state = 1594
                    self.interfaceList()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 1599
            self.match(PhpParser.OpenCurlyBracket)
            self.state = 1603
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 72083982316994560) != 0) or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 6757727313330209) != 0):
                self.state = 1600
                self.classStatement()
                self.state = 1605
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1606
            self.match(PhpParser.CloseCurlyBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IndirectTypeRefContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def chainBase(self):
            return self.getTypedRuleContext(PhpParser.ChainBaseContext,0)


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

        def keyedFieldName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.KeyedFieldNameContext)
            else:
                return self.getTypedRuleContext(PhpParser.KeyedFieldNameContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_indirectTypeRef

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

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




    def indirectTypeRef(self):

        localctx = PhpParser.IndirectTypeRefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_indirectTypeRef)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1608
            self.chainBase()
            self.state = 1613
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,194,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1609
                    self.match(PhpParser.ObjectOperator)
                    self.state = 1610
                    self.keyedFieldName() 
                self.state = 1615
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,194,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 QualifiedNamespaceNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespaceNameList(self):
            return self.getTypedRuleContext(PhpParser.NamespaceNameListContext,0)


        def Namespace(self):
            return self.getToken(PhpParser.Namespace, 0)

        def NamespaceSeparator(self):
            return self.getToken(PhpParser.NamespaceSeparator, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_qualifiedNamespaceName

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

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




    def qualifiedNamespaceName(self):

        localctx = PhpParser.QualifiedNamespaceNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_qualifiedNamespaceName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1617
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.state = 1616
                self.match(PhpParser.Namespace)


            self.state = 1620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==194:
                self.state = 1619
                self.match(PhpParser.NamespaceSeparator)


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


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


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

        def namespaceNameTail(self):
            return self.getTypedRuleContext(PhpParser.NamespaceNameTailContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_namespaceNameList

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

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




    def namespaceNameList(self):

        localctx = PhpParser.NamespaceNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_namespaceNameList)
        try:
            self.state = 1637
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1624
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1625
                self.identifier()
                self.state = 1630
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1626
                        self.match(PhpParser.NamespaceSeparator)
                        self.state = 1627
                        self.identifier() 
                    self.state = 1632
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,197,self._ctx)

                self.state = 1635
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
                if la_ == 1:
                    self.state = 1633
                    self.match(PhpParser.NamespaceSeparator)
                    self.state = 1634
                    self.namespaceNameTail()


                pass


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


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


        def As(self):
            return self.getToken(PhpParser.As, 0)

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def namespaceNameTail(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.NamespaceNameTailContext)
            else:
                return self.getTypedRuleContext(PhpParser.NamespaceNameTailContext,i)


        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

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

        def getRuleIndex(self):
            return PhpParser.RULE_namespaceNameTail

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

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




    def namespaceNameTail(self):

        localctx = PhpParser.NamespaceNameTailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_namespaceNameTail)
        self._la = 0 # Token type
        try:
            self.state = 1658
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 225]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1639
                self.identifier()
                self.state = 1642
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
                if la_ == 1:
                    self.state = 1640
                    self.match(PhpParser.As)
                    self.state = 1641
                    self.identifier()


                pass
            elif token in [216]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1644
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 1645
                self.namespaceNameTail()
                self.state = 1650
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,201,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1646
                        self.match(PhpParser.Comma)
                        self.state = 1647
                        self.namespaceNameTail() 
                    self.state = 1652
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,201,self._ctx)

                self.state = 1654
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==218:
                    self.state = 1653
                    self.match(PhpParser.Comma)


                self.state = 1656
                self.match(PhpParser.CloseCurlyBracket)
                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 QualifiedNamespaceNameListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedNamespaceName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.QualifiedNamespaceNameContext)
            else:
                return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_qualifiedNamespaceNameList

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

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




    def qualifiedNamespaceNameList(self):

        localctx = PhpParser.QualifiedNamespaceNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_qualifiedNamespaceNameList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1660
            self.qualifiedNamespaceName()
            self.state = 1665
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1661
                self.match(PhpParser.Comma)
                self.state = 1662
                self.qualifiedNamespaceName()
                self.state = 1667
                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 ArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def actualArgument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ActualArgumentContext)
            else:
                return self.getTypedRuleContext(PhpParser.ActualArgumentContext,i)


        def yieldExpression(self):
            return self.getTypedRuleContext(PhpParser.YieldExpressionContext,0)


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

        def getRuleIndex(self):
            return PhpParser.RULE_arguments

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

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




    def arguments(self):

        localctx = PhpParser.ArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_arguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1668
            self.match(PhpParser.OpenRoundBracket)
            self.state = 1678
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.state = 1669
                self.actualArgument()
                self.state = 1674
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,205,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1670
                        self.match(PhpParser.Comma)
                        self.state = 1671
                        self.actualArgument() 
                    self.state = 1676
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,205,self._ctx)


            elif la_ == 2:
                self.state = 1677
                self.yieldExpression()


            self.state = 1681
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==218:
                self.state = 1680
                self.match(PhpParser.Comma)


            self.state = 1683
            self.match(PhpParser.CloseRoundBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ActualArgumentContext(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(PhpParser.ExpressionContext,0)


        def argumentName(self):
            return self.getTypedRuleContext(PhpParser.ArgumentNameContext,0)


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

        def Ampersand(self):
            return self.getToken(PhpParser.Ampersand, 0)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_actualArgument

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

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




    def actualArgument(self):

        localctx = PhpParser.ActualArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_actualArgument)
        self._la = 0 # Token type
        try:
            self.state = 1694
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 165, 166, 194, 195, 200, 202, 203, 207, 208, 209, 212, 214, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1686
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
                if la_ == 1:
                    self.state = 1685
                    self.argumentName()


                self.state = 1689
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==195:
                    self.state = 1688
                    self.match(PhpParser.Ellipsis)


                self.state = 1691
                self.expression(0)
                pass
            elif token in [198]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1692
                self.match(PhpParser.Ampersand)
                self.state = 1693
                self.chain()
                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 ArgumentNameContext(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(PhpParser.IdentifierContext,0)


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

        def getRuleIndex(self):
            return PhpParser.RULE_argumentName

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

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




    def argumentName(self):

        localctx = PhpParser.ArgumentNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_argumentName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1696
            self.identifier()
            self.state = 1697
            self.match(PhpParser.Colon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstantInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constant(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ConstantContext)
            else:
                return self.getTypedRuleContext(PhpParser.ConstantContext,i)


        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.StringContext)
            else:
                return self.getTypedRuleContext(PhpParser.StringContext,i)


        def Array(self):
            return self.getToken(PhpParser.Array, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def arrayItemList(self):
            return self.getTypedRuleContext(PhpParser.ArrayItemListContext,0)


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

        def OpenSquareBracket(self):
            return self.getToken(PhpParser.OpenSquareBracket, 0)

        def CloseSquareBracket(self):
            return self.getToken(PhpParser.CloseSquareBracket, 0)

        def constantInitializer(self):
            return self.getTypedRuleContext(PhpParser.ConstantInitializerContext,0)


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

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

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

        def getRuleIndex(self):
            return PhpParser.RULE_constantInitializer

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

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




    def constantInitializer(self):

        localctx = PhpParser.ConstantInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_constantInitializer)
        self._la = 0 # Token type
        try:
            self.state = 1734
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,218,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1699
                self.constant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1700
                self.string()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1701
                self.match(PhpParser.Array)
                self.state = 1702
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1707
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138193) != 0):
                    self.state = 1703
                    self.arrayItemList()
                    self.state = 1705
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==218:
                        self.state = 1704
                        self.match(PhpParser.Comma)




                self.state = 1709
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1710
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1715
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138193) != 0):
                    self.state = 1711
                    self.arrayItemList()
                    self.state = 1713
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==218:
                        self.state = 1712
                        self.match(PhpParser.Comma)




                self.state = 1717
                self.match(PhpParser.CloseSquareBracket)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1718
                _la = self._input.LA(1)
                if not(_la==202 or _la==203):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1719
                self.constantInitializer()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1722
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,215,self._ctx)
                if la_ == 1:
                    self.state = 1720
                    self.string()
                    pass

                elif la_ == 2:
                    self.state = 1721
                    self.constant()
                    pass


                self.state = 1731
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==210:
                    self.state = 1724
                    self.match(PhpParser.Dot)
                    self.state = 1727
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
                    if la_ == 1:
                        self.state = 1725
                        self.string()
                        pass

                    elif la_ == 2:
                        self.state = 1726
                        self.constant()
                        pass


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

                pass


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


    class ConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Null(self):
            return self.getToken(PhpParser.Null, 0)

        def literalConstant(self):
            return self.getTypedRuleContext(PhpParser.LiteralConstantContext,0)


        def magicConstant(self):
            return self.getTypedRuleContext(PhpParser.MagicConstantContext,0)


        def classConstant(self):
            return self.getTypedRuleContext(PhpParser.ClassConstantContext,0)


        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_constant

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

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




    def constant(self):

        localctx = PhpParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_constant)
        try:
            self.state = 1741
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1736
                self.match(PhpParser.Null)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1737
                self.literalConstant()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1738
                self.magicConstant()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1739
                self.classConstant()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1740
                self.qualifiedNamespaceName()
                pass


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


    class LiteralConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(PhpParser.Real, 0)

        def BooleanConstant(self):
            return self.getToken(PhpParser.BooleanConstant, 0)

        def numericConstant(self):
            return self.getTypedRuleContext(PhpParser.NumericConstantContext,0)


        def stringConstant(self):
            return self.getTypedRuleContext(PhpParser.StringConstantContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_literalConstant

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

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




    def literalConstant(self):

        localctx = PhpParser.LiteralConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_literalConstant)
        try:
            self.state = 1747
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [228]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1743
                self.match(PhpParser.Real)
                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1744
                self.match(PhpParser.BooleanConstant)
                pass
            elif token in [226, 227, 229, 230]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1745
                self.numericConstant()
                pass
            elif token in [225]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1746
                self.stringConstant()
                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 NumericConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Octal(self):
            return self.getToken(PhpParser.Octal, 0)

        def Decimal(self):
            return self.getToken(PhpParser.Decimal, 0)

        def Hex(self):
            return self.getToken(PhpParser.Hex, 0)

        def Binary(self):
            return self.getToken(PhpParser.Binary, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_numericConstant

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

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




    def numericConstant(self):

        localctx = PhpParser.NumericConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_numericConstant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1749
            _la = self._input.LA(1)
            if not(((((_la - 226)) & ~0x3f) == 0 and ((1 << (_la - 226)) & 27) != 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 ClassConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DoubleColon(self):
            return self.getToken(PhpParser.DoubleColon, 0)

        def Class(self):
            return self.getToken(PhpParser.Class, 0)

        def Parent_(self):
            return self.getToken(PhpParser.Parent_, 0)

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


        def Constructor(self):
            return self.getToken(PhpParser.Constructor, 0)

        def Get(self):
            return self.getToken(PhpParser.Get, 0)

        def Set(self):
            return self.getToken(PhpParser.Set, 0)

        def qualifiedStaticTypeRef(self):
            return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,0)


        def keyedVariable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.KeyedVariableContext)
            else:
                return self.getTypedRuleContext(PhpParser.KeyedVariableContext,i)


        def string(self):
            return self.getTypedRuleContext(PhpParser.StringContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_classConstant

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

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




    def classConstant(self):

        localctx = PhpParser.ClassConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_classConstant)
        self._la = 0 # Token type
        try:
            self.state = 1769
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,224,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1751
                _la = self._input.LA(1)
                if not(_la==54 or _la==107):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1752
                self.match(PhpParser.DoubleColon)
                self.state = 1757
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,221,self._ctx)
                if la_ == 1:
                    self.state = 1753
                    self.identifier()
                    pass

                elif la_ == 2:
                    self.state = 1754
                    self.match(PhpParser.Constructor)
                    pass

                elif la_ == 3:
                    self.state = 1755
                    self.match(PhpParser.Get)
                    pass

                elif la_ == 4:
                    self.state = 1756
                    self.match(PhpParser.Set)
                    pass


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1762
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 194, 225]:
                    self.state = 1759
                    self.qualifiedStaticTypeRef()
                    pass
                elif token in [209, 224]:
                    self.state = 1760
                    self.keyedVariable()
                    pass
                elif token in [232, 233, 234, 235]:
                    self.state = 1761
                    self.string()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1764
                self.match(PhpParser.DoubleColon)
                self.state = 1767
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 225]:
                    self.state = 1765
                    self.identifier()
                    pass
                elif token in [209, 224]:
                    self.state = 1766
                    self.keyedVariable()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


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


    class StringConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Label(self):
            return self.getToken(PhpParser.Label, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_stringConstant

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

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




    def stringConstant(self):

        localctx = PhpParser.StringConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_stringConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1771
            self.match(PhpParser.Label)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def StartHereDoc(self):
            return self.getToken(PhpParser.StartHereDoc, 0)

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

        def StartNowDoc(self):
            return self.getToken(PhpParser.StartNowDoc, 0)

        def SingleQuoteString(self):
            return self.getToken(PhpParser.SingleQuoteString, 0)

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

        def interpolatedStringPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.InterpolatedStringPartContext)
            else:
                return self.getTypedRuleContext(PhpParser.InterpolatedStringPartContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_string

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

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




    def string(self):

        localctx = PhpParser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_string)
        try:
            self.state = 1794
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [235]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1773
                self.match(PhpParser.StartHereDoc)
                self.state = 1775 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1774
                        self.match(PhpParser.HereDocText)

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

                pass
            elif token in [234]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1779
                self.match(PhpParser.StartNowDoc)
                self.state = 1781 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1780
                        self.match(PhpParser.HereDocText)

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

                pass
            elif token in [232]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1785
                self.match(PhpParser.SingleQuoteString)
                pass
            elif token in [233]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1786
                self.match(PhpParser.DoubleQuote)
                self.state = 1790
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,227,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1787
                        self.interpolatedStringPart() 
                    self.state = 1792
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,227,self._ctx)

                self.state = 1793
                self.match(PhpParser.DoubleQuote)
                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 InterpolatedStringPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def StringPart(self):
            return self.getToken(PhpParser.StringPart, 0)

        def UnicodeEscape(self):
            return self.getToken(PhpParser.UnicodeEscape, 0)

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_interpolatedStringPart

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

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




    def interpolatedStringPart(self):

        localctx = PhpParser.InterpolatedStringPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_interpolatedStringPart)
        try:
            self.state = 1799
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [239]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1796
                self.match(PhpParser.StringPart)
                pass
            elif token in [238]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1797
                self.match(PhpParser.UnicodeEscape)
                pass
            elif token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 194, 209, 212, 224, 225, 232, 233, 234, 235]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1798
                self.chain()
                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 ChainListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def chain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ChainContext)
            else:
                return self.getTypedRuleContext(PhpParser.ChainContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_chainList

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

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




    def chainList(self):

        localctx = PhpParser.ChainListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_chainList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1801
            self.chain()
            self.state = 1806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1802
                self.match(PhpParser.Comma)
                self.state = 1803
                self.chain()
                self.state = 1808
                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 ChainContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def chainOrigin(self):
            return self.getTypedRuleContext(PhpParser.ChainOriginContext,0)


        def memberAccess(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.MemberAccessContext)
            else:
                return self.getTypedRuleContext(PhpParser.MemberAccessContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_chain

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

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




    def chain(self):

        localctx = PhpParser.ChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_chain)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1809
            self.chainOrigin()
            self.state = 1813
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,231,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1810
                    self.memberAccess() 
                self.state = 1815
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,231,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 ChainOriginContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def chainBase(self):
            return self.getTypedRuleContext(PhpParser.ChainBaseContext,0)


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


        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def newExpr(self):
            return self.getTypedRuleContext(PhpParser.NewExprContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_chainOrigin

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

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




    def chainOrigin(self):

        localctx = PhpParser.ChainOriginContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_chainOrigin)
        try:
            self.state = 1822
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,232,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1816
                self.chainBase()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1817
                self.functionCall()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1818
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1819
                self.newExpr()
                self.state = 1820
                self.match(PhpParser.CloseRoundBracket)
                pass


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


    class MemberAccessContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ObjectOperator(self):
            return self.getToken(PhpParser.ObjectOperator, 0)

        def keyedFieldName(self):
            return self.getTypedRuleContext(PhpParser.KeyedFieldNameContext,0)


        def actualArguments(self):
            return self.getTypedRuleContext(PhpParser.ActualArgumentsContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_memberAccess

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

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




    def memberAccess(self):

        localctx = PhpParser.MemberAccessContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_memberAccess)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1824
            self.match(PhpParser.ObjectOperator)
            self.state = 1825
            self.keyedFieldName()
            self.state = 1827
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
            if la_ == 1:
                self.state = 1826
                self.actualArguments()


        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 functionCallName(self):
            return self.getTypedRuleContext(PhpParser.FunctionCallNameContext,0)


        def actualArguments(self):
            return self.getTypedRuleContext(PhpParser.ActualArgumentsContext,0)


        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_functionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1829
            self.functionCallName()
            self.state = 1830
            self.actualArguments()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedNamespaceName(self):
            return self.getTypedRuleContext(PhpParser.QualifiedNamespaceNameContext,0)


        def classConstant(self):
            return self.getTypedRuleContext(PhpParser.ClassConstantContext,0)


        def chainBase(self):
            return self.getTypedRuleContext(PhpParser.ChainBaseContext,0)


        def parentheses(self):
            return self.getTypedRuleContext(PhpParser.ParenthesesContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_functionCallName

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

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




    def functionCallName(self):

        localctx = PhpParser.FunctionCallNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_functionCallName)
        try:
            self.state = 1836
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1832
                self.qualifiedNamespaceName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1833
                self.classConstant()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1834
                self.chainBase()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1835
                self.parentheses()
                pass


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


    class ActualArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def genericDynamicArgs(self):
            return self.getTypedRuleContext(PhpParser.GenericDynamicArgsContext,0)


        def arguments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.ArgumentsContext)
            else:
                return self.getTypedRuleContext(PhpParser.ArgumentsContext,i)


        def squareCurlyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.SquareCurlyExpressionContext)
            else:
                return self.getTypedRuleContext(PhpParser.SquareCurlyExpressionContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_actualArguments

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

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




    def actualArguments(self):

        localctx = PhpParser.ActualArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_actualArguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1839
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==162:
                self.state = 1838
                self.genericDynamicArgs()


            self.state = 1842 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1841
                    self.arguments()

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

            self.state = 1849
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,237,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1846
                    self.squareCurlyExpression() 
                self.state = 1851
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,237,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 ChainBaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def keyedVariable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.KeyedVariableContext)
            else:
                return self.getTypedRuleContext(PhpParser.KeyedVariableContext,i)


        def DoubleColon(self):
            return self.getToken(PhpParser.DoubleColon, 0)

        def qualifiedStaticTypeRef(self):
            return self.getTypedRuleContext(PhpParser.QualifiedStaticTypeRefContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_chainBase

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

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




    def chainBase(self):

        localctx = PhpParser.ChainBaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_chainBase)
        try:
            self.state = 1861
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [209, 224]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1852
                self.keyedVariable()
                self.state = 1855
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
                if la_ == 1:
                    self.state = 1853
                    self.match(PhpParser.DoubleColon)
                    self.state = 1854
                    self.keyedVariable()


                pass
            elif token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 194, 225]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1857
                self.qualifiedStaticTypeRef()
                self.state = 1858
                self.match(PhpParser.DoubleColon)
                self.state = 1859
                self.keyedVariable()
                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 KeyedFieldNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def keyedSimpleFieldName(self):
            return self.getTypedRuleContext(PhpParser.KeyedSimpleFieldNameContext,0)


        def keyedVariable(self):
            return self.getTypedRuleContext(PhpParser.KeyedVariableContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_keyedFieldName

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

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




    def keyedFieldName(self):

        localctx = PhpParser.KeyedFieldNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_keyedFieldName)
        try:
            self.state = 1865
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 216, 225]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1863
                self.keyedSimpleFieldName()
                pass
            elif token in [209, 224]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1864
                self.keyedVariable()
                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 KeyedSimpleFieldNameContext(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(PhpParser.IdentifierContext,0)


        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

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


        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def squareCurlyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.SquareCurlyExpressionContext)
            else:
                return self.getTypedRuleContext(PhpParser.SquareCurlyExpressionContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_keyedSimpleFieldName

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

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




    def keyedSimpleFieldName(self):

        localctx = PhpParser.KeyedSimpleFieldNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_keyedSimpleFieldName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1872
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 225]:
                self.state = 1867
                self.identifier()
                pass
            elif token in [216]:
                self.state = 1868
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 1869
                self.expression(0)
                self.state = 1870
                self.match(PhpParser.CloseCurlyBracket)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1877
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,242,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1874
                    self.squareCurlyExpression() 
                self.state = 1879
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,242,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 KeyedVariableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VarName(self):
            return self.getToken(PhpParser.VarName, 0)

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

        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

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


        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def squareCurlyExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.SquareCurlyExpressionContext)
            else:
                return self.getTypedRuleContext(PhpParser.SquareCurlyExpressionContext,i)


        def getRuleIndex(self):
            return PhpParser.RULE_keyedVariable

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

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




    def keyedVariable(self):

        localctx = PhpParser.KeyedVariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_keyedVariable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1883
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,243,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1880
                    self.match(PhpParser.Dollar) 
                self.state = 1885
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,243,self._ctx)

            self.state = 1892
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [224]:
                self.state = 1886
                self.match(PhpParser.VarName)
                pass
            elif token in [209]:
                self.state = 1887
                self.match(PhpParser.Dollar)
                self.state = 1888
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 1889
                self.expression(0)
                self.state = 1890
                self.match(PhpParser.CloseCurlyBracket)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1897
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,245,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1894
                    self.squareCurlyExpression() 
                self.state = 1899
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,245,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 SquareCurlyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OpenSquareBracket(self):
            return self.getToken(PhpParser.OpenSquareBracket, 0)

        def CloseSquareBracket(self):
            return self.getToken(PhpParser.CloseSquareBracket, 0)

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


        def OpenCurlyBracket(self):
            return self.getToken(PhpParser.OpenCurlyBracket, 0)

        def CloseCurlyBracket(self):
            return self.getToken(PhpParser.CloseCurlyBracket, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_squareCurlyExpression

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

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




    def squareCurlyExpression(self):

        localctx = PhpParser.SquareCurlyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_squareCurlyExpression)
        self._la = 0 # Token type
        try:
            self.state = 1909
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [214]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1900
                self.match(PhpParser.OpenSquareBracket)
                self.state = 1902
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138177) != 0):
                    self.state = 1901
                    self.expression(0)


                self.state = 1904
                self.match(PhpParser.CloseSquareBracket)
                pass
            elif token in [216]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1905
                self.match(PhpParser.OpenCurlyBracket)
                self.state = 1906
                self.expression(0)
                self.state = 1907
                self.match(PhpParser.CloseCurlyBracket)
                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 AssignmentListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assignmentListElement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PhpParser.AssignmentListElementContext)
            else:
                return self.getTypedRuleContext(PhpParser.AssignmentListElementContext,i)


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

        def getRuleIndex(self):
            return PhpParser.RULE_assignmentList

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

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




    def assignmentList(self):

        localctx = PhpParser.AssignmentListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_assignmentList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1912
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138193) != 0):
                self.state = 1911
                self.assignmentListElement()


            self.state = 1920
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==218:
                self.state = 1914
                self.match(PhpParser.Comma)
                self.state = 1916
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 441352763482308607) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 4396974138193) != 0):
                    self.state = 1915
                    self.assignmentListElement()


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

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

        def chain(self):
            return self.getTypedRuleContext(PhpParser.ChainContext,0)


        def List(self):
            return self.getToken(PhpParser.List, 0)

        def OpenRoundBracket(self):
            return self.getToken(PhpParser.OpenRoundBracket, 0)

        def assignmentList(self):
            return self.getTypedRuleContext(PhpParser.AssignmentListContext,0)


        def CloseRoundBracket(self):
            return self.getToken(PhpParser.CloseRoundBracket, 0)

        def arrayItem(self):
            return self.getTypedRuleContext(PhpParser.ArrayItemContext,0)


        def getRuleIndex(self):
            return PhpParser.RULE_assignmentListElement

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

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




    def assignmentListElement(self):

        localctx = PhpParser.AssignmentListElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_assignmentListElement)
        try:
            self.state = 1930
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1923
                self.chain()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1924
                self.match(PhpParser.List)
                self.state = 1925
                self.match(PhpParser.OpenRoundBracket)
                self.state = 1926
                self.assignmentList()
                self.state = 1927
                self.match(PhpParser.CloseRoundBracket)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1929
                self.arrayItem()
                pass


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


    class ModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Abstract(self):
            return self.getToken(PhpParser.Abstract, 0)

        def Final(self):
            return self.getToken(PhpParser.Final, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_modifier

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

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




    def modifier(self):

        localctx = PhpParser.ModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_modifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1932
            _la = self._input.LA(1)
            if not(_la==44 or _la==77):
                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 IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Label(self):
            return self.getToken(PhpParser.Label, 0)

        def Abstract(self):
            return self.getToken(PhpParser.Abstract, 0)

        def Array(self):
            return self.getToken(PhpParser.Array, 0)

        def As(self):
            return self.getToken(PhpParser.As, 0)

        def BinaryCast(self):
            return self.getToken(PhpParser.BinaryCast, 0)

        def BoolType(self):
            return self.getToken(PhpParser.BoolType, 0)

        def BooleanConstant(self):
            return self.getToken(PhpParser.BooleanConstant, 0)

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

        def Callable(self):
            return self.getToken(PhpParser.Callable, 0)

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

        def Catch(self):
            return self.getToken(PhpParser.Catch, 0)

        def Class(self):
            return self.getToken(PhpParser.Class, 0)

        def Clone(self):
            return self.getToken(PhpParser.Clone, 0)

        def Const(self):
            return self.getToken(PhpParser.Const, 0)

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

        def Declare(self):
            return self.getToken(PhpParser.Declare, 0)

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

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

        def DoubleCast(self):
            return self.getToken(PhpParser.DoubleCast, 0)

        def DoubleType(self):
            return self.getToken(PhpParser.DoubleType, 0)

        def Echo(self):
            return self.getToken(PhpParser.Echo, 0)

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

        def ElseIf(self):
            return self.getToken(PhpParser.ElseIf, 0)

        def Empty(self):
            return self.getToken(PhpParser.Empty, 0)

        def EndDeclare(self):
            return self.getToken(PhpParser.EndDeclare, 0)

        def EndFor(self):
            return self.getToken(PhpParser.EndFor, 0)

        def EndForeach(self):
            return self.getToken(PhpParser.EndForeach, 0)

        def EndIf(self):
            return self.getToken(PhpParser.EndIf, 0)

        def EndSwitch(self):
            return self.getToken(PhpParser.EndSwitch, 0)

        def EndWhile(self):
            return self.getToken(PhpParser.EndWhile, 0)

        def Eval(self):
            return self.getToken(PhpParser.Eval, 0)

        def Exit(self):
            return self.getToken(PhpParser.Exit, 0)

        def Extends(self):
            return self.getToken(PhpParser.Extends, 0)

        def Final(self):
            return self.getToken(PhpParser.Final, 0)

        def Finally(self):
            return self.getToken(PhpParser.Finally, 0)

        def FloatCast(self):
            return self.getToken(PhpParser.FloatCast, 0)

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

        def Foreach(self):
            return self.getToken(PhpParser.Foreach, 0)

        def Function_(self):
            return self.getToken(PhpParser.Function_, 0)

        def Global(self):
            return self.getToken(PhpParser.Global, 0)

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

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

        def Implements(self):
            return self.getToken(PhpParser.Implements, 0)

        def Import(self):
            return self.getToken(PhpParser.Import, 0)

        def Include(self):
            return self.getToken(PhpParser.Include, 0)

        def IncludeOnce(self):
            return self.getToken(PhpParser.IncludeOnce, 0)

        def InstanceOf(self):
            return self.getToken(PhpParser.InstanceOf, 0)

        def InsteadOf(self):
            return self.getToken(PhpParser.InsteadOf, 0)

        def Int16Cast(self):
            return self.getToken(PhpParser.Int16Cast, 0)

        def Int64Type(self):
            return self.getToken(PhpParser.Int64Type, 0)

        def Int8Cast(self):
            return self.getToken(PhpParser.Int8Cast, 0)

        def Interface(self):
            return self.getToken(PhpParser.Interface, 0)

        def IntType(self):
            return self.getToken(PhpParser.IntType, 0)

        def IsSet(self):
            return self.getToken(PhpParser.IsSet, 0)

        def LambdaFn(self):
            return self.getToken(PhpParser.LambdaFn, 0)

        def List(self):
            return self.getToken(PhpParser.List, 0)

        def LogicalAnd(self):
            return self.getToken(PhpParser.LogicalAnd, 0)

        def LogicalOr(self):
            return self.getToken(PhpParser.LogicalOr, 0)

        def LogicalXor(self):
            return self.getToken(PhpParser.LogicalXor, 0)

        def Namespace(self):
            return self.getToken(PhpParser.Namespace, 0)

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

        def Null(self):
            return self.getToken(PhpParser.Null, 0)

        def ObjectType(self):
            return self.getToken(PhpParser.ObjectType, 0)

        def Parent_(self):
            return self.getToken(PhpParser.Parent_, 0)

        def Partial(self):
            return self.getToken(PhpParser.Partial, 0)

        def Print(self):
            return self.getToken(PhpParser.Print, 0)

        def Private(self):
            return self.getToken(PhpParser.Private, 0)

        def Protected(self):
            return self.getToken(PhpParser.Protected, 0)

        def Public(self):
            return self.getToken(PhpParser.Public, 0)

        def Readonly(self):
            return self.getToken(PhpParser.Readonly, 0)

        def Require(self):
            return self.getToken(PhpParser.Require, 0)

        def RequireOnce(self):
            return self.getToken(PhpParser.RequireOnce, 0)

        def Resource(self):
            return self.getToken(PhpParser.Resource, 0)

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

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

        def StringType(self):
            return self.getToken(PhpParser.StringType, 0)

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

        def Throw(self):
            return self.getToken(PhpParser.Throw, 0)

        def Trait(self):
            return self.getToken(PhpParser.Trait, 0)

        def Try(self):
            return self.getToken(PhpParser.Try, 0)

        def Typeof(self):
            return self.getToken(PhpParser.Typeof, 0)

        def UintCast(self):
            return self.getToken(PhpParser.UintCast, 0)

        def UnicodeCast(self):
            return self.getToken(PhpParser.UnicodeCast, 0)

        def Unset(self):
            return self.getToken(PhpParser.Unset, 0)

        def Use(self):
            return self.getToken(PhpParser.Use, 0)

        def Var(self):
            return self.getToken(PhpParser.Var, 0)

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

        def Yield(self):
            return self.getToken(PhpParser.Yield, 0)

        def From(self):
            return self.getToken(PhpParser.From, 0)

        def Enum_(self):
            return self.getToken(PhpParser.Enum_, 0)

        def Match_(self):
            return self.getToken(PhpParser.Match_, 0)

        def Ticks(self):
            return self.getToken(PhpParser.Ticks, 0)

        def Encoding(self):
            return self.getToken(PhpParser.Encoding, 0)

        def StrictTypes(self):
            return self.getToken(PhpParser.StrictTypes, 0)

        def Get(self):
            return self.getToken(PhpParser.Get, 0)

        def Set(self):
            return self.getToken(PhpParser.Set, 0)

        def Call(self):
            return self.getToken(PhpParser.Call, 0)

        def CallStatic(self):
            return self.getToken(PhpParser.CallStatic, 0)

        def Constructor(self):
            return self.getToken(PhpParser.Constructor, 0)

        def Destruct(self):
            return self.getToken(PhpParser.Destruct, 0)

        def Wakeup(self):
            return self.getToken(PhpParser.Wakeup, 0)

        def Sleep(self):
            return self.getToken(PhpParser.Sleep, 0)

        def Autoload(self):
            return self.getToken(PhpParser.Autoload, 0)

        def IsSet__(self):
            return self.getToken(PhpParser.IsSet__, 0)

        def Unset__(self):
            return self.getToken(PhpParser.Unset__, 0)

        def ToString__(self):
            return self.getToken(PhpParser.ToString__, 0)

        def Invoke(self):
            return self.getToken(PhpParser.Invoke, 0)

        def SetState(self):
            return self.getToken(PhpParser.SetState, 0)

        def Clone__(self):
            return self.getToken(PhpParser.Clone__, 0)

        def DebugInfo(self):
            return self.getToken(PhpParser.DebugInfo, 0)

        def Namespace__(self):
            return self.getToken(PhpParser.Namespace__, 0)

        def Class__(self):
            return self.getToken(PhpParser.Class__, 0)

        def Traic__(self):
            return self.getToken(PhpParser.Traic__, 0)

        def Function__(self):
            return self.getToken(PhpParser.Function__, 0)

        def Method__(self):
            return self.getToken(PhpParser.Method__, 0)

        def Line__(self):
            return self.getToken(PhpParser.Line__, 0)

        def File__(self):
            return self.getToken(PhpParser.File__, 0)

        def Dir__(self):
            return self.getToken(PhpParser.Dir__, 0)

        def getRuleIndex(self):
            return PhpParser.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 = PhpParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1934
            _la = self._input.LA(1)
            if not(((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & -1) != 0) or ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 9007199254740991) != 0) or _la==225):
                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 MemberModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Public(self):
            return self.getToken(PhpParser.Public, 0)

        def Protected(self):
            return self.getToken(PhpParser.Protected, 0)

        def Private(self):
            return self.getToken(PhpParser.Private, 0)

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

        def Abstract(self):
            return self.getToken(PhpParser.Abstract, 0)

        def Final(self):
            return self.getToken(PhpParser.Final, 0)

        def Readonly(self):
            return self.getToken(PhpParser.Readonly, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_memberModifier

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

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




    def memberModifier(self):

        localctx = PhpParser.MemberModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_memberModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1936
            _la = self._input.LA(1)
            if not(_la==44 or ((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & 2327872274433) != 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 MagicConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Namespace__(self):
            return self.getToken(PhpParser.Namespace__, 0)

        def Class__(self):
            return self.getToken(PhpParser.Class__, 0)

        def Traic__(self):
            return self.getToken(PhpParser.Traic__, 0)

        def Function__(self):
            return self.getToken(PhpParser.Function__, 0)

        def Method__(self):
            return self.getToken(PhpParser.Method__, 0)

        def Line__(self):
            return self.getToken(PhpParser.Line__, 0)

        def File__(self):
            return self.getToken(PhpParser.File__, 0)

        def Dir__(self):
            return self.getToken(PhpParser.Dir__, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_magicConstant

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

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




    def magicConstant(self):

        localctx = PhpParser.MagicConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_magicConstant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1938
            _la = self._input.LA(1)
            if not(((((_la - 153)) & ~0x3f) == 0 and ((1 << (_la - 153)) & 255) != 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 MagicMethodContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Get(self):
            return self.getToken(PhpParser.Get, 0)

        def Set(self):
            return self.getToken(PhpParser.Set, 0)

        def Call(self):
            return self.getToken(PhpParser.Call, 0)

        def CallStatic(self):
            return self.getToken(PhpParser.CallStatic, 0)

        def Constructor(self):
            return self.getToken(PhpParser.Constructor, 0)

        def Destruct(self):
            return self.getToken(PhpParser.Destruct, 0)

        def Wakeup(self):
            return self.getToken(PhpParser.Wakeup, 0)

        def Sleep(self):
            return self.getToken(PhpParser.Sleep, 0)

        def Autoload(self):
            return self.getToken(PhpParser.Autoload, 0)

        def IsSet__(self):
            return self.getToken(PhpParser.IsSet__, 0)

        def Unset__(self):
            return self.getToken(PhpParser.Unset__, 0)

        def ToString__(self):
            return self.getToken(PhpParser.ToString__, 0)

        def Invoke(self):
            return self.getToken(PhpParser.Invoke, 0)

        def SetState(self):
            return self.getToken(PhpParser.SetState, 0)

        def Clone__(self):
            return self.getToken(PhpParser.Clone__, 0)

        def DebugInfo(self):
            return self.getToken(PhpParser.DebugInfo, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_magicMethod

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

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




    def magicMethod(self):

        localctx = PhpParser.MagicMethodContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_magicMethod)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1940
            _la = self._input.LA(1)
            if not(((((_la - 137)) & ~0x3f) == 0 and ((1 << (_la - 137)) & 65535) != 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 PrimitiveTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BoolType(self):
            return self.getToken(PhpParser.BoolType, 0)

        def IntType(self):
            return self.getToken(PhpParser.IntType, 0)

        def Int64Type(self):
            return self.getToken(PhpParser.Int64Type, 0)

        def DoubleType(self):
            return self.getToken(PhpParser.DoubleType, 0)

        def StringType(self):
            return self.getToken(PhpParser.StringType, 0)

        def Resource(self):
            return self.getToken(PhpParser.Resource, 0)

        def ObjectType(self):
            return self.getToken(PhpParser.ObjectType, 0)

        def Array(self):
            return self.getToken(PhpParser.Array, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_primitiveType

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

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




    def primitiveType(self):

        localctx = PhpParser.PrimitiveTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_primitiveType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1942
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 4612002677776187392) != 0) or ((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & 37752835) != 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 CastOperationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BoolType(self):
            return self.getToken(PhpParser.BoolType, 0)

        def Int8Cast(self):
            return self.getToken(PhpParser.Int8Cast, 0)

        def Int16Cast(self):
            return self.getToken(PhpParser.Int16Cast, 0)

        def IntType(self):
            return self.getToken(PhpParser.IntType, 0)

        def Int64Type(self):
            return self.getToken(PhpParser.Int64Type, 0)

        def UintCast(self):
            return self.getToken(PhpParser.UintCast, 0)

        def DoubleCast(self):
            return self.getToken(PhpParser.DoubleCast, 0)

        def DoubleType(self):
            return self.getToken(PhpParser.DoubleType, 0)

        def FloatCast(self):
            return self.getToken(PhpParser.FloatCast, 0)

        def StringType(self):
            return self.getToken(PhpParser.StringType, 0)

        def BinaryCast(self):
            return self.getToken(PhpParser.BinaryCast, 0)

        def UnicodeCast(self):
            return self.getToken(PhpParser.UnicodeCast, 0)

        def Array(self):
            return self.getToken(PhpParser.Array, 0)

        def ObjectType(self):
            return self.getToken(PhpParser.ObjectType, 0)

        def Resource(self):
            return self.getToken(PhpParser.Resource, 0)

        def Unset(self):
            return self.getToken(PhpParser.Unset, 0)

        def getRuleIndex(self):
            return PhpParser.RULE_castOperation

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

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




    def castOperation(self):

        localctx = PhpParser.CastOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_castOperation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1944
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 6917986424478236672) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & 493818294165505) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[59] = self.typeHint_sempred
        self._predicates[82] = 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 typeHint_sempred(self, localctx:TypeHintContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 22)
         

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if predIndex == 18:
                return self.precpred(self._ctx, 21)
         




