MyGrammarParser.py

# Generated from MyGrammar.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,51,653,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,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,3,1,174,8,1,1,2,1,2,1,2,1,2,1,2,1,2,5,2,182,8,2,10,2,12,2,185,
        9,2,1,3,1,3,1,3,1,3,1,3,1,3,5,3,193,8,3,10,3,12,3,196,9,3,1,4,1,
        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
        4,1,4,1,4,1,4,5,4,219,8,4,10,4,12,4,222,9,4,1,5,1,5,1,5,1,5,1,5,
        1,5,1,5,1,5,1,5,5,5,233,8,5,10,5,12,5,236,9,5,1,6,1,6,1,6,1,6,1,
        6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,5,6,250,8,6,10,6,12,6,253,9,6,1,7,
        1,7,1,7,1,7,1,7,1,7,1,7,3,7,262,8,7,1,8,1,8,1,8,1,8,1,8,3,8,269,
        8,8,1,9,1,9,1,9,1,9,1,9,3,9,276,8,9,1,9,1,9,1,10,1,10,1,10,1,11,
        1,11,1,11,1,11,1,11,3,11,288,8,11,1,11,1,11,1,11,1,11,1,11,1,11,
        1,11,1,11,1,11,1,11,3,11,300,8,11,1,12,1,12,1,12,3,12,305,8,12,1,
        13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,314,8,13,1,14,1,14,1,15,1,
        15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,326,8,15,1,16,1,16,1,17,1,
        17,1,18,1,18,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,343,
        8,20,1,21,1,21,1,22,1,22,5,22,349,8,22,10,22,12,22,352,9,22,1,22,
        3,22,355,8,22,1,22,1,22,3,22,359,8,22,1,23,1,23,1,23,1,23,1,23,1,
        23,1,24,1,24,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,5,25,378,
        8,25,10,25,12,25,381,9,25,1,25,1,25,1,25,3,25,386,8,25,1,26,1,26,
        1,26,1,26,3,26,392,8,26,1,26,1,26,5,26,396,8,26,10,26,12,26,399,
        9,26,1,26,1,26,3,26,403,8,26,1,26,3,26,406,8,26,1,27,1,27,1,27,1,
        27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,
        28,1,29,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,
        30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,447,8,31,1,
        31,1,31,1,31,1,31,1,31,3,31,454,8,31,1,31,1,31,3,31,458,8,31,1,31,
        1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,33,4,33,470,8,33,11,33,
        12,33,471,1,33,4,33,475,8,33,11,33,12,33,476,3,33,479,8,33,1,34,
        1,34,3,34,483,8,34,1,34,1,34,5,34,487,8,34,10,34,12,34,490,9,34,
        1,34,1,34,3,34,494,8,34,1,34,3,34,497,8,34,1,35,1,35,1,35,1,35,1,
        35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,37,1,
        37,3,37,517,8,37,1,37,5,37,520,8,37,10,37,12,37,523,9,37,1,37,1,
        37,3,37,527,8,37,1,37,3,37,530,8,37,1,38,1,38,1,38,1,38,1,38,1,39,
        1,39,1,39,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,40,1,40,
        1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,42,1,42,1,42,1,42,5,42,562,
        8,42,10,42,12,42,565,9,42,1,42,3,42,568,8,42,1,42,1,42,1,42,3,42,
        573,8,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,
        1,45,1,45,1,46,1,46,1,46,3,46,591,8,46,1,46,1,46,1,47,1,47,3,47,
        597,8,47,1,47,1,47,1,47,1,47,1,47,3,47,604,8,47,1,47,1,47,1,47,3,
        47,609,8,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,618,8,47,1,47,
        1,47,3,47,622,8,47,1,48,1,48,3,48,626,8,48,1,48,1,48,1,48,1,48,1,
        48,3,48,633,8,48,1,48,1,48,1,48,3,48,638,8,48,1,48,1,48,1,48,1,48,
        1,48,1,48,1,48,3,48,647,8,48,1,48,1,48,3,48,651,8,48,1,48,0,5,4,
        6,8,10,12,49,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,0,1,1,0,19,22,705,0,98,1,0,0,0,2,173,1,0,
        0,0,4,175,1,0,0,0,6,186,1,0,0,0,8,197,1,0,0,0,10,223,1,0,0,0,12,
        237,1,0,0,0,14,261,1,0,0,0,16,268,1,0,0,0,18,270,1,0,0,0,20,279,
        1,0,0,0,22,299,1,0,0,0,24,304,1,0,0,0,26,313,1,0,0,0,28,315,1,0,
        0,0,30,325,1,0,0,0,32,327,1,0,0,0,34,329,1,0,0,0,36,331,1,0,0,0,
        38,333,1,0,0,0,40,342,1,0,0,0,42,344,1,0,0,0,44,358,1,0,0,0,46,360,
        1,0,0,0,48,366,1,0,0,0,50,385,1,0,0,0,52,405,1,0,0,0,54,407,1,0,
        0,0,56,415,1,0,0,0,58,424,1,0,0,0,60,429,1,0,0,0,62,437,1,0,0,0,
        64,464,1,0,0,0,66,478,1,0,0,0,68,496,1,0,0,0,70,498,1,0,0,0,72,507,
        1,0,0,0,74,529,1,0,0,0,76,531,1,0,0,0,78,536,1,0,0,0,80,543,1,0,
        0,0,82,552,1,0,0,0,84,572,1,0,0,0,86,574,1,0,0,0,88,582,1,0,0,0,
        90,585,1,0,0,0,92,587,1,0,0,0,94,621,1,0,0,0,96,650,1,0,0,0,98,99,
        3,2,1,0,99,1,1,0,0,0,100,101,3,94,47,0,101,102,5,1,0,0,102,103,3,
        2,1,0,103,174,1,0,0,0,104,105,3,96,48,0,105,106,5,1,0,0,106,107,
        3,2,1,0,107,174,1,0,0,0,108,109,3,4,2,0,109,110,5,1,0,0,110,174,
        1,0,0,0,111,112,3,4,2,0,112,113,5,1,0,0,113,114,3,2,1,0,114,174,
        1,0,0,0,115,116,3,66,33,0,116,117,3,2,1,0,117,174,1,0,0,0,118,119,
        3,70,35,0,119,120,3,2,1,0,120,174,1,0,0,0,121,122,3,72,36,0,122,
        123,3,2,1,0,123,174,1,0,0,0,124,125,3,76,38,0,125,126,5,1,0,0,126,
        127,3,2,1,0,127,174,1,0,0,0,128,129,3,18,9,0,129,130,3,2,1,0,130,
        174,1,0,0,0,131,132,3,20,10,0,132,133,5,1,0,0,133,134,3,2,1,0,134,
        174,1,0,0,0,135,136,3,86,43,0,136,137,3,2,1,0,137,174,1,0,0,0,138,
        139,3,22,11,0,139,140,5,1,0,0,140,141,3,2,1,0,141,174,1,0,0,0,142,
        143,3,46,23,0,143,144,3,2,1,0,144,174,1,0,0,0,145,146,3,64,32,0,
        146,147,3,2,1,0,147,174,1,0,0,0,148,149,3,44,22,0,149,150,3,2,1,
        0,150,174,1,0,0,0,151,152,5,42,0,0,152,153,5,1,0,0,153,174,3,2,1,
        0,154,155,5,43,0,0,155,156,5,1,0,0,156,174,3,2,1,0,157,158,3,92,
        46,0,158,159,3,2,1,0,159,174,1,0,0,0,160,161,3,78,39,0,161,162,3,
        2,1,0,162,174,1,0,0,0,163,164,3,80,40,0,164,165,3,2,1,0,165,174,
        1,0,0,0,166,167,3,88,44,0,167,168,3,2,1,0,168,174,1,0,0,0,169,170,
        3,48,24,0,170,171,3,2,1,0,171,174,1,0,0,0,172,174,1,0,0,0,173,100,
        1,0,0,0,173,104,1,0,0,0,173,108,1,0,0,0,173,111,1,0,0,0,173,115,
        1,0,0,0,173,118,1,0,0,0,173,121,1,0,0,0,173,124,1,0,0,0,173,128,
        1,0,0,0,173,131,1,0,0,0,173,135,1,0,0,0,173,138,1,0,0,0,173,142,
        1,0,0,0,173,145,1,0,0,0,173,148,1,0,0,0,173,151,1,0,0,0,173,154,
        1,0,0,0,173,157,1,0,0,0,173,160,1,0,0,0,173,163,1,0,0,0,173,166,
        1,0,0,0,173,169,1,0,0,0,173,172,1,0,0,0,174,3,1,0,0,0,175,176,6,
        2,-1,0,176,177,3,6,3,0,177,183,1,0,0,0,178,179,10,2,0,0,179,180,
        5,2,0,0,180,182,3,6,3,0,181,178,1,0,0,0,182,185,1,0,0,0,183,181,
        1,0,0,0,183,184,1,0,0,0,184,5,1,0,0,0,185,183,1,0,0,0,186,187,6,
        3,-1,0,187,188,3,8,4,0,188,194,1,0,0,0,189,190,10,2,0,0,190,191,
        5,3,0,0,191,193,3,8,4,0,192,189,1,0,0,0,193,196,1,0,0,0,194,192,
        1,0,0,0,194,195,1,0,0,0,195,7,1,0,0,0,196,194,1,0,0,0,197,198,6,
        4,-1,0,198,199,3,10,5,0,199,220,1,0,0,0,200,201,10,7,0,0,201,202,
        5,4,0,0,202,219,3,10,5,0,203,204,10,6,0,0,204,205,5,5,0,0,205,219,
        3,10,5,0,206,207,10,5,0,0,207,208,5,6,0,0,208,219,3,10,5,0,209,210,
        10,4,0,0,210,211,5,7,0,0,211,219,3,10,5,0,212,213,10,3,0,0,213,214,
        5,8,0,0,214,219,3,10,5,0,215,216,10,2,0,0,216,217,5,9,0,0,217,219,
        3,10,5,0,218,200,1,0,0,0,218,203,1,0,0,0,218,206,1,0,0,0,218,209,
        1,0,0,0,218,212,1,0,0,0,218,215,1,0,0,0,219,222,1,0,0,0,220,218,
        1,0,0,0,220,221,1,0,0,0,221,9,1,0,0,0,222,220,1,0,0,0,223,224,6,
        5,-1,0,224,225,3,12,6,0,225,234,1,0,0,0,226,227,10,3,0,0,227,228,
        5,10,0,0,228,233,3,12,6,0,229,230,10,2,0,0,230,231,5,11,0,0,231,
        233,3,12,6,0,232,226,1,0,0,0,232,229,1,0,0,0,233,236,1,0,0,0,234,
        232,1,0,0,0,234,235,1,0,0,0,235,11,1,0,0,0,236,234,1,0,0,0,237,238,
        6,6,-1,0,238,239,3,14,7,0,239,251,1,0,0,0,240,241,10,4,0,0,241,242,
        5,40,0,0,242,250,3,14,7,0,243,244,10,3,0,0,244,245,5,12,0,0,245,
        250,3,14,7,0,246,247,10,2,0,0,247,248,5,13,0,0,248,250,3,14,7,0,
        249,240,1,0,0,0,249,243,1,0,0,0,249,246,1,0,0,0,250,253,1,0,0,0,
        251,249,1,0,0,0,251,252,1,0,0,0,252,13,1,0,0,0,253,251,1,0,0,0,254,
        255,5,10,0,0,255,262,3,16,8,0,256,257,5,11,0,0,257,262,3,16,8,0,
        258,259,5,14,0,0,259,262,3,16,8,0,260,262,3,16,8,0,261,254,1,0,0,
        0,261,256,1,0,0,0,261,258,1,0,0,0,261,260,1,0,0,0,262,15,1,0,0,0,
        263,264,5,15,0,0,264,265,3,4,2,0,265,266,5,16,0,0,266,269,1,0,0,
        0,267,269,3,30,15,0,268,263,1,0,0,0,268,267,1,0,0,0,269,17,1,0,0,
        0,270,271,3,20,10,0,271,275,5,17,0,0,272,276,3,4,2,0,273,276,3,76,
        38,0,274,276,3,82,41,0,275,272,1,0,0,0,275,273,1,0,0,0,275,274,1,
        0,0,0,276,277,1,0,0,0,277,278,5,1,0,0,278,19,1,0,0,0,279,280,3,24,
        12,0,280,281,3,40,20,0,281,21,1,0,0,0,282,283,3,40,20,0,283,287,
        5,17,0,0,284,288,3,10,5,0,285,288,3,76,38,0,286,288,3,82,41,0,287,
        284,1,0,0,0,287,285,1,0,0,0,287,286,1,0,0,0,288,300,1,0,0,0,289,
        290,3,30,15,0,290,291,5,17,0,0,291,292,3,10,5,0,292,300,1,0,0,0,
        293,294,5,15,0,0,294,295,3,4,2,0,295,296,5,16,0,0,296,297,5,17,0,
        0,297,298,3,4,2,0,298,300,1,0,0,0,299,282,1,0,0,0,299,289,1,0,0,
        0,299,293,1,0,0,0,300,23,1,0,0,0,301,302,5,18,0,0,302,305,3,26,13,
        0,303,305,3,26,13,0,304,301,1,0,0,0,304,303,1,0,0,0,305,25,1,0,0,
        0,306,307,3,28,14,0,307,308,5,40,0,0,308,314,1,0,0,0,309,310,3,28,
        14,0,310,311,5,41,0,0,311,314,1,0,0,0,312,314,3,28,14,0,313,306,
        1,0,0,0,313,309,1,0,0,0,313,312,1,0,0,0,314,27,1,0,0,0,315,316,7,
        0,0,0,316,29,1,0,0,0,317,326,3,32,16,0,318,326,3,34,17,0,319,326,
        3,36,18,0,320,326,3,40,20,0,321,326,3,76,38,0,322,326,3,82,41,0,
        323,326,3,94,47,0,324,326,3,96,48,0,325,317,1,0,0,0,325,318,1,0,
        0,0,325,319,1,0,0,0,325,320,1,0,0,0,325,321,1,0,0,0,325,322,1,0,
        0,0,325,323,1,0,0,0,325,324,1,0,0,0,326,31,1,0,0,0,327,328,5,47,
        0,0,328,33,1,0,0,0,329,330,5,48,0,0,330,35,1,0,0,0,331,332,5,45,
        0,0,332,37,1,0,0,0,333,334,5,46,0,0,334,39,1,0,0,0,335,336,5,23,
        0,0,336,343,3,42,21,0,337,338,5,40,0,0,338,343,3,42,21,0,339,340,
        5,41,0,0,340,343,3,42,21,0,341,343,3,42,21,0,342,335,1,0,0,0,342,
        337,1,0,0,0,342,339,1,0,0,0,342,341,1,0,0,0,343,41,1,0,0,0,344,345,
        5,44,0,0,345,43,1,0,0,0,346,350,3,54,27,0,347,349,3,56,28,0,348,
        347,1,0,0,0,349,352,1,0,0,0,350,348,1,0,0,0,350,351,1,0,0,0,351,
        354,1,0,0,0,352,350,1,0,0,0,353,355,3,58,29,0,354,353,1,0,0,0,354,
        355,1,0,0,0,355,359,1,0,0,0,356,359,3,60,30,0,357,359,3,62,31,0,
        358,346,1,0,0,0,358,356,1,0,0,0,358,357,1,0,0,0,359,45,1,0,0,0,360,
        361,5,24,0,0,361,362,5,15,0,0,362,363,3,52,26,0,363,364,5,16,0,0,
        364,365,5,1,0,0,365,47,1,0,0,0,366,367,5,25,0,0,367,368,5,15,0,0,
        368,369,3,50,25,0,369,370,5,16,0,0,370,371,5,1,0,0,371,49,1,0,0,
        0,372,373,3,38,19,0,373,379,5,26,0,0,374,375,3,40,20,0,375,376,5,
        26,0,0,376,378,1,0,0,0,377,374,1,0,0,0,378,381,1,0,0,0,379,377,1,
        0,0,0,379,380,1,0,0,0,380,382,1,0,0,0,381,379,1,0,0,0,382,383,3,
        40,20,0,383,386,1,0,0,0,384,386,3,38,19,0,385,372,1,0,0,0,385,384,
        1,0,0,0,386,51,1,0,0,0,387,388,3,38,19,0,388,397,5,26,0,0,389,392,
        3,4,2,0,390,392,3,38,19,0,391,389,1,0,0,0,391,390,1,0,0,0,392,393,
        1,0,0,0,393,394,5,26,0,0,394,396,1,0,0,0,395,391,1,0,0,0,396,399,
        1,0,0,0,397,395,1,0,0,0,397,398,1,0,0,0,398,402,1,0,0,0,399,397,
        1,0,0,0,400,403,3,4,2,0,401,403,3,38,19,0,402,400,1,0,0,0,402,401,
        1,0,0,0,403,406,1,0,0,0,404,406,3,38,19,0,405,387,1,0,0,0,405,404,
        1,0,0,0,406,53,1,0,0,0,407,408,5,27,0,0,408,409,5,15,0,0,409,410,
        3,4,2,0,410,411,5,16,0,0,411,412,5,28,0,0,412,413,3,90,45,0,413,
        414,5,29,0,0,414,55,1,0,0,0,415,416,5,30,0,0,416,417,5,27,0,0,417,
        418,5,15,0,0,418,419,3,4,2,0,419,420,5,16,0,0,420,421,5,28,0,0,421,
        422,3,90,45,0,422,423,5,29,0,0,423,57,1,0,0,0,424,425,5,30,0,0,425,
        426,5,28,0,0,426,427,3,90,45,0,427,428,5,29,0,0,428,59,1,0,0,0,429,
        430,5,31,0,0,430,431,5,15,0,0,431,432,3,4,2,0,432,433,5,16,0,0,433,
        434,5,28,0,0,434,435,3,90,45,0,435,436,5,29,0,0,436,61,1,0,0,0,437,
        438,5,32,0,0,438,457,5,15,0,0,439,440,3,20,10,0,440,441,5,1,0,0,
        441,447,1,0,0,0,442,447,3,18,9,0,443,444,3,22,11,0,444,445,5,1,0,
        0,445,447,1,0,0,0,446,439,1,0,0,0,446,442,1,0,0,0,446,443,1,0,0,
        0,447,448,1,0,0,0,448,449,3,4,2,0,449,453,5,1,0,0,450,454,3,22,11,
        0,451,454,3,94,47,0,452,454,3,96,48,0,453,450,1,0,0,0,453,451,1,
        0,0,0,453,452,1,0,0,0,454,458,1,0,0,0,455,456,5,1,0,0,456,458,5,
        1,0,0,457,446,1,0,0,0,457,455,1,0,0,0,458,459,1,0,0,0,459,460,5,
        16,0,0,460,461,5,28,0,0,461,462,3,90,45,0,462,463,5,29,0,0,463,63,
        1,0,0,0,464,465,5,28,0,0,465,466,3,90,45,0,466,467,5,29,0,0,467,
        65,1,0,0,0,468,470,5,50,0,0,469,468,1,0,0,0,470,471,1,0,0,0,471,
        469,1,0,0,0,471,472,1,0,0,0,472,479,1,0,0,0,473,475,5,49,0,0,474,
        473,1,0,0,0,475,476,1,0,0,0,476,474,1,0,0,0,476,477,1,0,0,0,477,
        479,1,0,0,0,478,469,1,0,0,0,478,474,1,0,0,0,479,67,1,0,0,0,480,482,
        3,24,12,0,481,483,5,44,0,0,482,481,1,0,0,0,482,483,1,0,0,0,483,484,
        1,0,0,0,484,485,5,26,0,0,485,487,1,0,0,0,486,480,1,0,0,0,487,490,
        1,0,0,0,488,486,1,0,0,0,488,489,1,0,0,0,489,491,1,0,0,0,490,488,
        1,0,0,0,491,493,3,24,12,0,492,494,5,44,0,0,493,492,1,0,0,0,493,494,
        1,0,0,0,494,497,1,0,0,0,495,497,1,0,0,0,496,488,1,0,0,0,496,495,
        1,0,0,0,497,69,1,0,0,0,498,499,3,24,12,0,499,500,5,44,0,0,500,501,
        5,15,0,0,501,502,3,68,34,0,502,503,5,16,0,0,503,504,5,28,0,0,504,
        505,3,90,45,0,505,506,5,29,0,0,506,71,1,0,0,0,507,508,3,24,12,0,
        508,509,5,44,0,0,509,510,5,15,0,0,510,511,3,68,34,0,511,512,5,16,
        0,0,512,513,5,1,0,0,513,73,1,0,0,0,514,517,5,44,0,0,515,517,3,4,
        2,0,516,514,1,0,0,0,516,515,1,0,0,0,517,518,1,0,0,0,518,520,5,26,
        0,0,519,516,1,0,0,0,520,523,1,0,0,0,521,519,1,0,0,0,521,522,1,0,
        0,0,522,526,1,0,0,0,523,521,1,0,0,0,524,527,5,44,0,0,525,527,3,4,
        2,0,526,524,1,0,0,0,526,525,1,0,0,0,527,530,1,0,0,0,528,530,1,0,
        0,0,529,521,1,0,0,0,529,528,1,0,0,0,530,75,1,0,0,0,531,532,5,44,
        0,0,532,533,5,15,0,0,533,534,3,74,37,0,534,535,5,16,0,0,535,77,1,
        0,0,0,536,537,3,24,12,0,537,538,5,44,0,0,538,539,5,33,0,0,539,540,
        3,4,2,0,540,541,5,34,0,0,541,542,5,1,0,0,542,79,1,0,0,0,543,544,
        3,24,12,0,544,545,5,44,0,0,545,546,5,33,0,0,546,547,3,4,2,0,547,
        548,5,34,0,0,548,549,5,17,0,0,549,550,3,84,42,0,550,551,5,1,0,0,
        551,81,1,0,0,0,552,553,3,42,21,0,553,554,5,33,0,0,554,555,3,4,2,
        0,555,556,5,34,0,0,556,83,1,0,0,0,557,563,5,28,0,0,558,559,3,30,
        15,0,559,560,5,26,0,0,560,562,1,0,0,0,561,558,1,0,0,0,562,565,1,
        0,0,0,563,561,1,0,0,0,563,564,1,0,0,0,564,567,1,0,0,0,565,563,1,
        0,0,0,566,568,3,30,15,0,567,566,1,0,0,0,567,568,1,0,0,0,568,569,
        1,0,0,0,569,573,5,29,0,0,570,571,5,28,0,0,571,573,5,29,0,0,572,557,
        1,0,0,0,572,570,1,0,0,0,573,85,1,0,0,0,574,575,5,44,0,0,575,576,
        5,33,0,0,576,577,3,4,2,0,577,578,5,34,0,0,578,579,5,17,0,0,579,580,
        3,30,15,0,580,581,5,1,0,0,581,87,1,0,0,0,582,583,5,35,0,0,583,584,
        5,36,0,0,584,89,1,0,0,0,585,586,3,2,1,0,586,91,1,0,0,0,587,590,5,
        37,0,0,588,591,3,4,2,0,589,591,1,0,0,0,590,588,1,0,0,0,590,589,1,
        0,0,0,591,592,1,0,0,0,592,593,5,1,0,0,593,93,1,0,0,0,594,597,3,40,
        20,0,595,597,3,82,41,0,596,594,1,0,0,0,596,595,1,0,0,0,597,598,1,
        0,0,0,598,599,5,38,0,0,599,622,1,0,0,0,600,603,5,38,0,0,601,604,
        3,40,20,0,602,604,3,82,41,0,603,601,1,0,0,0,603,602,1,0,0,0,604,
        622,1,0,0,0,605,608,5,15,0,0,606,609,3,40,20,0,607,609,3,82,41,0,
        608,606,1,0,0,0,608,607,1,0,0,0,609,610,1,0,0,0,610,611,5,16,0,0,
        611,612,5,38,0,0,612,622,1,0,0,0,613,614,5,38,0,0,614,617,5,15,0,
        0,615,618,3,40,20,0,616,618,3,82,41,0,617,615,1,0,0,0,617,616,1,
        0,0,0,618,619,1,0,0,0,619,620,5,16,0,0,620,622,1,0,0,0,621,596,1,
        0,0,0,621,600,1,0,0,0,621,605,1,0,0,0,621,613,1,0,0,0,622,95,1,0,
        0,0,623,626,3,40,20,0,624,626,3,82,41,0,625,623,1,0,0,0,625,624,
        1,0,0,0,626,627,1,0,0,0,627,628,5,39,0,0,628,651,1,0,0,0,629,632,
        5,39,0,0,630,633,3,40,20,0,631,633,3,82,41,0,632,630,1,0,0,0,632,
        631,1,0,0,0,633,651,1,0,0,0,634,637,5,15,0,0,635,638,3,40,20,0,636,
        638,3,82,41,0,637,635,1,0,0,0,637,636,1,0,0,0,638,639,1,0,0,0,639,
        640,5,16,0,0,640,641,5,39,0,0,641,651,1,0,0,0,642,643,5,39,0,0,643,
        646,5,15,0,0,644,647,3,40,20,0,645,647,3,82,41,0,646,644,1,0,0,0,
        646,645,1,0,0,0,647,648,1,0,0,0,648,649,5,16,0,0,649,651,1,0,0,0,
        650,625,1,0,0,0,650,629,1,0,0,0,650,634,1,0,0,0,650,642,1,0,0,0,
        651,97,1,0,0,0,55,173,183,194,218,220,232,234,249,251,261,268,275,
        287,299,304,313,325,342,350,354,358,379,385,391,397,402,405,446,
        453,457,471,476,478,482,488,493,496,516,521,526,529,563,567,572,
        590,596,603,608,617,621,625,632,637,646,650
    ]

class MyGrammarParser ( Parser ):

    grammarFileName = "MyGrammar.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "'&&'", "'||'", "'=='", "'<='", 
                     "'>='", "'!='", "'<'", "'>'", "'+'", "'-'", "'/'", 
                     "'%'", "'!'", "'('", "')'", "'='", "'const'", "'int'", 
                     "'float'", "'char'", "'void'", "'&'", "'printf'", "'scanf'", 
                     "','", "'if'", "'{'", "'}'", "'else'", "'while'", "'for'", 
                     "'['", "']'", "'#include'", "'<stdio.h>'", "'return'", 
                     "'++'", "'--'", "'*'", "<INVALID>", "'break'", "'continue'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "POINTER", "POINTERS", "BREAK", "CONTINUE", "ID", 
                      "CHAR", "STRING", "INT", "FLOAT", "COMMENT", "BLOCK_COMMENT", 
                      "WS" ]

    RULE_prog = 0
    RULE_expr = 1
    RULE_opAnd = 2
    RULE_opOr = 3
    RULE_opCompare = 4
    RULE_opAddOrSub = 5
    RULE_opMultOrDiv = 6
    RULE_opUnary = 7
    RULE_brackets = 8
    RULE_variableDefinition = 9
    RULE_variableDeclaration = 10
    RULE_assignmentStatement = 11
    RULE_constWord = 12
    RULE_pointerWord = 13
    RULE_reservedWord = 14
    RULE_dataTypes = 15
    RULE_int = 16
    RULE_float = 17
    RULE_char = 18
    RULE_string = 19
    RULE_referenceID = 20
    RULE_nameIdentifier = 21
    RULE_conditionStatement = 22
    RULE_printFunction = 23
    RULE_scanFunction = 24
    RULE_scanArg = 25
    RULE_printArg = 26
    RULE_ifStatement = 27
    RULE_elifStatement = 28
    RULE_elseStatement = 29
    RULE_whileStatement = 30
    RULE_forLoop = 31
    RULE_unNamedScope = 32
    RULE_comment = 33
    RULE_argument = 34
    RULE_funcDefinition = 35
    RULE_funcDeclaration = 36
    RULE_argumentCall = 37
    RULE_functionCall = 38
    RULE_arrDecl = 39
    RULE_arrDef = 40
    RULE_arrCall = 41
    RULE_arrArg = 42
    RULE_arrAssign = 43
    RULE_lib = 44
    RULE_body = 45
    RULE_returnStatement = 46
    RULE_increment = 47
    RULE_decrement = 48

    ruleNames =  [ "prog", "expr", "opAnd", "opOr", "opCompare", "opAddOrSub", 
                   "opMultOrDiv", "opUnary", "brackets", "variableDefinition", 
                   "variableDeclaration", "assignmentStatement", "constWord", 
                   "pointerWord", "reservedWord", "dataTypes", "int", "float", 
                   "char", "string", "referenceID", "nameIdentifier", "conditionStatement", 
                   "printFunction", "scanFunction", "scanArg", "printArg", 
                   "ifStatement", "elifStatement", "elseStatement", "whileStatement", 
                   "forLoop", "unNamedScope", "comment", "argument", "funcDefinition", 
                   "funcDeclaration", "argumentCall", "functionCall", "arrDecl", 
                   "arrDef", "arrCall", "arrArg", "arrAssign", "lib", "body", 
                   "returnStatement", "increment", "decrement" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    POINTER=40
    POINTERS=41
    BREAK=42
    CONTINUE=43
    ID=44
    CHAR=45
    STRING=46
    INT=47
    FLOAT=48
    COMMENT=49
    BLOCK_COMMENT=50
    WS=51

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

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

        def expr(self):
            return self.getTypedRuleContext(MyGrammarParser.ExprContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_prog

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

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




    def prog(self):

        localctx = MyGrammarParser.ProgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_prog)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 98
            self.expr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def increment(self):
            return self.getTypedRuleContext(MyGrammarParser.IncrementContext,0)


        def expr(self):
            return self.getTypedRuleContext(MyGrammarParser.ExprContext,0)


        def decrement(self):
            return self.getTypedRuleContext(MyGrammarParser.DecrementContext,0)


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def comment(self):
            return self.getTypedRuleContext(MyGrammarParser.CommentContext,0)


        def funcDefinition(self):
            return self.getTypedRuleContext(MyGrammarParser.FuncDefinitionContext,0)


        def funcDeclaration(self):
            return self.getTypedRuleContext(MyGrammarParser.FuncDeclarationContext,0)


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


        def variableDefinition(self):
            return self.getTypedRuleContext(MyGrammarParser.VariableDefinitionContext,0)


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


        def arrAssign(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrAssignContext,0)


        def assignmentStatement(self):
            return self.getTypedRuleContext(MyGrammarParser.AssignmentStatementContext,0)


        def printFunction(self):
            return self.getTypedRuleContext(MyGrammarParser.PrintFunctionContext,0)


        def unNamedScope(self):
            return self.getTypedRuleContext(MyGrammarParser.UnNamedScopeContext,0)


        def conditionStatement(self):
            return self.getTypedRuleContext(MyGrammarParser.ConditionStatementContext,0)


        def BREAK(self):
            return self.getToken(MyGrammarParser.BREAK, 0)

        def CONTINUE(self):
            return self.getToken(MyGrammarParser.CONTINUE, 0)

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


        def arrDecl(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrDeclContext,0)


        def arrDef(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrDefContext,0)


        def lib(self):
            return self.getTypedRuleContext(MyGrammarParser.LibContext,0)


        def scanFunction(self):
            return self.getTypedRuleContext(MyGrammarParser.ScanFunctionContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_expr

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

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




    def expr(self):

        localctx = MyGrammarParser.ExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_expr)
        try:
            self.state = 173
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 100
                self.increment()
                self.state = 101
                self.match(MyGrammarParser.T__0)
                self.state = 102
                self.expr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 104
                self.decrement()
                self.state = 105
                self.match(MyGrammarParser.T__0)
                self.state = 106
                self.expr()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 108
                self.opAnd(0)
                self.state = 109
                self.match(MyGrammarParser.T__0)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 111
                self.opAnd(0)
                self.state = 112
                self.match(MyGrammarParser.T__0)
                self.state = 113
                self.expr()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 115
                self.comment()
                self.state = 116
                self.expr()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 118
                self.funcDefinition()
                self.state = 119
                self.expr()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 121
                self.funcDeclaration()
                self.state = 122
                self.expr()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 124
                self.functionCall()
                self.state = 125
                self.match(MyGrammarParser.T__0)
                self.state = 126
                self.expr()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 128
                self.variableDefinition()
                self.state = 129
                self.expr()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 131
                self.variableDeclaration()
                self.state = 132
                self.match(MyGrammarParser.T__0)
                self.state = 133
                self.expr()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 135
                self.arrAssign()
                self.state = 136
                self.expr()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 138
                self.assignmentStatement()
                self.state = 139
                self.match(MyGrammarParser.T__0)
                self.state = 140
                self.expr()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 142
                self.printFunction()
                self.state = 143
                self.expr()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 145
                self.unNamedScope()
                self.state = 146
                self.expr()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 148
                self.conditionStatement()
                self.state = 149
                self.expr()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 151
                self.match(MyGrammarParser.BREAK)
                self.state = 152
                self.match(MyGrammarParser.T__0)
                self.state = 153
                self.expr()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 154
                self.match(MyGrammarParser.CONTINUE)
                self.state = 155
                self.match(MyGrammarParser.T__0)
                self.state = 156
                self.expr()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 157
                self.returnStatement()
                self.state = 158
                self.expr()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 160
                self.arrDecl()
                self.state = 161
                self.expr()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 163
                self.arrDef()
                self.state = 164
                self.expr()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 166
                self.lib()
                self.state = 167
                self.expr()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 169
                self.scanFunction()
                self.state = 170
                self.expr()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)

                pass


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


    class OpAndContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def opOr(self):
            return self.getTypedRuleContext(MyGrammarParser.OpOrContext,0)


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_opAnd

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

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



    def opAnd(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = MyGrammarParser.OpAndContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 4
        self.enterRecursionRule(localctx, 4, self.RULE_opAnd, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 176
            self.opOr(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 183
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,1,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 = MyGrammarParser.OpAndContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_opAnd)
                    self.state = 178
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 179
                    self.match(MyGrammarParser.T__1)
                    self.state = 180
                    self.opOr(0) 
                self.state = 185
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,1,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 OpOrContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def opCompare(self):
            return self.getTypedRuleContext(MyGrammarParser.OpCompareContext,0)


        def opOr(self):
            return self.getTypedRuleContext(MyGrammarParser.OpOrContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_opOr

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

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



    def opOr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = MyGrammarParser.OpOrContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 6
        self.enterRecursionRule(localctx, 6, self.RULE_opOr, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 187
            self.opCompare(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 194
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,2,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 = MyGrammarParser.OpOrContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_opOr)
                    self.state = 189
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 190
                    self.match(MyGrammarParser.T__2)
                    self.state = 191
                    self.opCompare(0) 
                self.state = 196
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,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 OpCompareContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def opAddOrSub(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAddOrSubContext,0)


        def opCompare(self):
            return self.getTypedRuleContext(MyGrammarParser.OpCompareContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_opCompare

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

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



    def opCompare(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = MyGrammarParser.OpCompareContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 8
        self.enterRecursionRule(localctx, 8, self.RULE_opCompare, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 198
            self.opAddOrSub(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 220
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,4,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 = 218
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
                    if la_ == 1:
                        localctx = MyGrammarParser.OpCompareContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opCompare)
                        self.state = 200
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 201
                        self.match(MyGrammarParser.T__3)
                        self.state = 202
                        self.opAddOrSub(0)
                        pass

                    elif la_ == 2:
                        localctx = MyGrammarParser.OpCompareContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opCompare)
                        self.state = 203
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 204
                        self.match(MyGrammarParser.T__4)
                        self.state = 205
                        self.opAddOrSub(0)
                        pass

                    elif la_ == 3:
                        localctx = MyGrammarParser.OpCompareContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opCompare)
                        self.state = 206
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 207
                        self.match(MyGrammarParser.T__5)
                        self.state = 208
                        self.opAddOrSub(0)
                        pass

                    elif la_ == 4:
                        localctx = MyGrammarParser.OpCompareContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opCompare)
                        self.state = 209
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 210
                        self.match(MyGrammarParser.T__6)
                        self.state = 211
                        self.opAddOrSub(0)
                        pass

                    elif la_ == 5:
                        localctx = MyGrammarParser.OpCompareContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opCompare)
                        self.state = 212
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 213
                        self.match(MyGrammarParser.T__7)
                        self.state = 214
                        self.opAddOrSub(0)
                        pass

                    elif la_ == 6:
                        localctx = MyGrammarParser.OpCompareContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opCompare)
                        self.state = 215
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 216
                        self.match(MyGrammarParser.T__8)
                        self.state = 217
                        self.opAddOrSub(0)
                        pass

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

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

        def opMultOrDiv(self):
            return self.getTypedRuleContext(MyGrammarParser.OpMultOrDivContext,0)


        def opAddOrSub(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAddOrSubContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_opAddOrSub

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

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



    def opAddOrSub(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = MyGrammarParser.OpAddOrSubContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 10
        self.enterRecursionRule(localctx, 10, self.RULE_opAddOrSub, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 224
            self.opMultOrDiv(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 234
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,6,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 = 232
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
                    if la_ == 1:
                        localctx = MyGrammarParser.OpAddOrSubContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opAddOrSub)
                        self.state = 226
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 227
                        self.match(MyGrammarParser.T__9)
                        self.state = 228
                        self.opMultOrDiv(0)
                        pass

                    elif la_ == 2:
                        localctx = MyGrammarParser.OpAddOrSubContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opAddOrSub)
                        self.state = 229
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 230
                        self.match(MyGrammarParser.T__10)
                        self.state = 231
                        self.opMultOrDiv(0)
                        pass

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

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

        def opUnary(self):
            return self.getTypedRuleContext(MyGrammarParser.OpUnaryContext,0)


        def opMultOrDiv(self):
            return self.getTypedRuleContext(MyGrammarParser.OpMultOrDivContext,0)


        def POINTER(self):
            return self.getToken(MyGrammarParser.POINTER, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_opMultOrDiv

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

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



    def opMultOrDiv(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = MyGrammarParser.OpMultOrDivContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 12
        self.enterRecursionRule(localctx, 12, self.RULE_opMultOrDiv, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self.opUnary()
            self._ctx.stop = self._input.LT(-1)
            self.state = 251
            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:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 249
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                    if la_ == 1:
                        localctx = MyGrammarParser.OpMultOrDivContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opMultOrDiv)
                        self.state = 240
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 241
                        self.match(MyGrammarParser.POINTER)
                        self.state = 242
                        self.opUnary()
                        pass

                    elif la_ == 2:
                        localctx = MyGrammarParser.OpMultOrDivContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opMultOrDiv)
                        self.state = 243
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 244
                        self.match(MyGrammarParser.T__11)
                        self.state = 245
                        self.opUnary()
                        pass

                    elif la_ == 3:
                        localctx = MyGrammarParser.OpMultOrDivContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_opMultOrDiv)
                        self.state = 246
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 247
                        self.match(MyGrammarParser.T__12)
                        self.state = 248
                        self.opUnary()
                        pass

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

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

        def brackets(self):
            return self.getTypedRuleContext(MyGrammarParser.BracketsContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_opUnary

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

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




    def opUnary(self):

        localctx = MyGrammarParser.OpUnaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_opUnary)
        try:
            self.state = 261
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10]:
                self.enterOuterAlt(localctx, 1)
                self.state = 254
                self.match(MyGrammarParser.T__9)
                self.state = 255
                self.brackets()
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 2)
                self.state = 256
                self.match(MyGrammarParser.T__10)
                self.state = 257
                self.brackets()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 3)
                self.state = 258
                self.match(MyGrammarParser.T__13)
                self.state = 259
                self.brackets()
                pass
            elif token in [15, 23, 38, 39, 40, 41, 44, 45, 47, 48]:
                self.enterOuterAlt(localctx, 4)
                self.state = 260
                self.brackets()
                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 BracketsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def dataTypes(self):
            return self.getTypedRuleContext(MyGrammarParser.DataTypesContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_brackets

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

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




    def brackets(self):

        localctx = MyGrammarParser.BracketsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_brackets)
        try:
            self.state = 268
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 263
                self.match(MyGrammarParser.T__14)
                self.state = 264
                self.opAnd(0)
                self.state = 265
                self.match(MyGrammarParser.T__15)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 267
                self.dataTypes()
                pass


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


    class VariableDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


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


        def arrCall(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrCallContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_variableDefinition

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

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




    def variableDefinition(self):

        localctx = MyGrammarParser.VariableDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_variableDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.variableDeclaration()
            self.state = 271
            self.match(MyGrammarParser.T__16)
            self.state = 275
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.state = 272
                self.opAnd(0)
                pass

            elif la_ == 2:
                self.state = 273
                self.functionCall()
                pass

            elif la_ == 3:
                self.state = 274
                self.arrCall()
                pass


            self.state = 277
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariableDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constWord(self):
            return self.getTypedRuleContext(MyGrammarParser.ConstWordContext,0)


        def referenceID(self):
            return self.getTypedRuleContext(MyGrammarParser.ReferenceIDContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_variableDeclaration

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

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




    def variableDeclaration(self):

        localctx = MyGrammarParser.VariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_variableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 279
            self.constWord()
            self.state = 280
            self.referenceID()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def referenceID(self):
            return self.getTypedRuleContext(MyGrammarParser.ReferenceIDContext,0)


        def opAddOrSub(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAddOrSubContext,0)


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


        def arrCall(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrCallContext,0)


        def dataTypes(self):
            return self.getTypedRuleContext(MyGrammarParser.DataTypesContext,0)


        def opAnd(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.OpAndContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.OpAndContext,i)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_assignmentStatement

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

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




    def assignmentStatement(self):

        localctx = MyGrammarParser.AssignmentStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_assignmentStatement)
        try:
            self.state = 299
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 282
                self.referenceID()
                self.state = 283
                self.match(MyGrammarParser.T__16)
                self.state = 287
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                if la_ == 1:
                    self.state = 284
                    self.opAddOrSub(0)
                    pass

                elif la_ == 2:
                    self.state = 285
                    self.functionCall()
                    pass

                elif la_ == 3:
                    self.state = 286
                    self.arrCall()
                    pass


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 289
                self.dataTypes()
                self.state = 290
                self.match(MyGrammarParser.T__16)
                self.state = 291
                self.opAddOrSub(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 293
                self.match(MyGrammarParser.T__14)
                self.state = 294
                self.opAnd(0)
                self.state = 295
                self.match(MyGrammarParser.T__15)
                self.state = 296
                self.match(MyGrammarParser.T__16)
                self.state = 297
                self.opAnd(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 ConstWordContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pointerWord(self):
            return self.getTypedRuleContext(MyGrammarParser.PointerWordContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_constWord

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

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




    def constWord(self):

        localctx = MyGrammarParser.ConstWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_constWord)
        try:
            self.state = 304
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [18]:
                self.enterOuterAlt(localctx, 1)
                self.state = 301
                self.match(MyGrammarParser.T__17)
                self.state = 302
                self.pointerWord()
                pass
            elif token in [19, 20, 21, 22]:
                self.enterOuterAlt(localctx, 2)
                self.state = 303
                self.pointerWord()
                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 PointerWordContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def reservedWord(self):
            return self.getTypedRuleContext(MyGrammarParser.ReservedWordContext,0)


        def POINTER(self):
            return self.getToken(MyGrammarParser.POINTER, 0)

        def POINTERS(self):
            return self.getToken(MyGrammarParser.POINTERS, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_pointerWord

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

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




    def pointerWord(self):

        localctx = MyGrammarParser.PointerWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_pointerWord)
        try:
            self.state = 313
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 306
                self.reservedWord()
                self.state = 307
                self.match(MyGrammarParser.POINTER)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 309
                self.reservedWord()
                self.state = 310
                self.match(MyGrammarParser.POINTERS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 312
                self.reservedWord()
                pass


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


    class ReservedWordContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return MyGrammarParser.RULE_reservedWord

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

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




    def reservedWord(self):

        localctx = MyGrammarParser.ReservedWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_reservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 315
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 7864320) != 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 DataTypesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def int_(self):
            return self.getTypedRuleContext(MyGrammarParser.IntContext,0)


        def float_(self):
            return self.getTypedRuleContext(MyGrammarParser.FloatContext,0)


        def char(self):
            return self.getTypedRuleContext(MyGrammarParser.CharContext,0)


        def referenceID(self):
            return self.getTypedRuleContext(MyGrammarParser.ReferenceIDContext,0)


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


        def arrCall(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrCallContext,0)


        def increment(self):
            return self.getTypedRuleContext(MyGrammarParser.IncrementContext,0)


        def decrement(self):
            return self.getTypedRuleContext(MyGrammarParser.DecrementContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_dataTypes

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

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




    def dataTypes(self):

        localctx = MyGrammarParser.DataTypesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_dataTypes)
        try:
            self.state = 325
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self.int_()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 318
                self.float_()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 319
                self.char()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 320
                self.referenceID()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 321
                self.functionCall()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 322
                self.arrCall()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 323
                self.increment()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 324
                self.decrement()
                pass


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


    class IntContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INT(self):
            return self.getToken(MyGrammarParser.INT, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_int

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

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




    def int_(self):

        localctx = MyGrammarParser.IntContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_int)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(MyGrammarParser.INT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FloatContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FLOAT(self):
            return self.getToken(MyGrammarParser.FLOAT, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_float

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

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




    def float_(self):

        localctx = MyGrammarParser.FloatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_float)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 329
            self.match(MyGrammarParser.FLOAT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CharContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHAR(self):
            return self.getToken(MyGrammarParser.CHAR, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_char

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

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




    def char(self):

        localctx = MyGrammarParser.CharContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_char)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 331
            self.match(MyGrammarParser.CHAR)
        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 STRING(self):
            return self.getToken(MyGrammarParser.STRING, 0)

        def getRuleIndex(self):
            return MyGrammarParser.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 = MyGrammarParser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_string)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            self.match(MyGrammarParser.STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReferenceIDContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nameIdentifier(self):
            return self.getTypedRuleContext(MyGrammarParser.NameIdentifierContext,0)


        def POINTER(self):
            return self.getToken(MyGrammarParser.POINTER, 0)

        def POINTERS(self):
            return self.getToken(MyGrammarParser.POINTERS, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_referenceID

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

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




    def referenceID(self):

        localctx = MyGrammarParser.ReferenceIDContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_referenceID)
        try:
            self.state = 342
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [23]:
                self.enterOuterAlt(localctx, 1)
                self.state = 335
                self.match(MyGrammarParser.T__22)
                self.state = 336
                self.nameIdentifier()
                pass
            elif token in [40]:
                self.enterOuterAlt(localctx, 2)
                self.state = 337
                self.match(MyGrammarParser.POINTER)
                self.state = 338
                self.nameIdentifier()
                pass
            elif token in [41]:
                self.enterOuterAlt(localctx, 3)
                self.state = 339
                self.match(MyGrammarParser.POINTERS)
                self.state = 340
                self.nameIdentifier()
                pass
            elif token in [44]:
                self.enterOuterAlt(localctx, 4)
                self.state = 341
                self.nameIdentifier()
                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 NameIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def getRuleIndex(self):
            return MyGrammarParser.RULE_nameIdentifier

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

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




    def nameIdentifier(self):

        localctx = MyGrammarParser.NameIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_nameIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 344
            self.match(MyGrammarParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConditionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def elifStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.ElifStatementContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.ElifStatementContext,i)


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


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


        def forLoop(self):
            return self.getTypedRuleContext(MyGrammarParser.ForLoopContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_conditionStatement

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

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




    def conditionStatement(self):

        localctx = MyGrammarParser.ConditionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_conditionStatement)
        self._la = 0 # Token type
        try:
            self.state = 358
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [27]:
                self.enterOuterAlt(localctx, 1)
                self.state = 346
                self.ifStatement()
                self.state = 350
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,18,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 347
                        self.elifStatement() 
                    self.state = 352
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,18,self._ctx)

                self.state = 354
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==30:
                    self.state = 353
                    self.elseStatement()


                pass
            elif token in [31]:
                self.enterOuterAlt(localctx, 2)
                self.state = 356
                self.whileStatement()
                pass
            elif token in [32]:
                self.enterOuterAlt(localctx, 3)
                self.state = 357
                self.forLoop()
                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 PrintFunctionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def printArg(self):
            return self.getTypedRuleContext(MyGrammarParser.PrintArgContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_printFunction

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

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




    def printFunction(self):

        localctx = MyGrammarParser.PrintFunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_printFunction)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self.match(MyGrammarParser.T__23)
            self.state = 361
            self.match(MyGrammarParser.T__14)
            self.state = 362
            self.printArg()
            self.state = 363
            self.match(MyGrammarParser.T__15)
            self.state = 364
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ScanFunctionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def scanArg(self):
            return self.getTypedRuleContext(MyGrammarParser.ScanArgContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_scanFunction

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

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




    def scanFunction(self):

        localctx = MyGrammarParser.ScanFunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_scanFunction)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self.match(MyGrammarParser.T__24)
            self.state = 367
            self.match(MyGrammarParser.T__14)
            self.state = 368
            self.scanArg()
            self.state = 369
            self.match(MyGrammarParser.T__15)
            self.state = 370
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ScanArgContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def string(self):
            return self.getTypedRuleContext(MyGrammarParser.StringContext,0)


        def referenceID(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.ReferenceIDContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.ReferenceIDContext,i)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_scanArg

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

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




    def scanArg(self):

        localctx = MyGrammarParser.ScanArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_scanArg)
        try:
            self.state = 385
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 372
                self.string()
                self.state = 373
                self.match(MyGrammarParser.T__25)
                self.state = 379
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 374
                        self.referenceID()
                        self.state = 375
                        self.match(MyGrammarParser.T__25) 
                    self.state = 381
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,21,self._ctx)

                self.state = 382
                self.referenceID()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 384
                self.string()
                pass


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


    class PrintArgContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def string(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.StringContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.StringContext,i)


        def opAnd(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.OpAndContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.OpAndContext,i)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_printArg

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

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




    def printArg(self):

        localctx = MyGrammarParser.PrintArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_printArg)
        try:
            self.state = 405
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 387
                self.string()
                self.state = 388
                self.match(MyGrammarParser.T__25)
                self.state = 397
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 391
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [10, 11, 14, 15, 23, 38, 39, 40, 41, 44, 45, 47, 48]:
                            self.state = 389
                            self.opAnd(0)
                            pass
                        elif token in [46]:
                            self.state = 390
                            self.string()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 393
                        self.match(MyGrammarParser.T__25) 
                    self.state = 399
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,24,self._ctx)

                self.state = 402
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [10, 11, 14, 15, 23, 38, 39, 40, 41, 44, 45, 47, 48]:
                    self.state = 400
                    self.opAnd(0)
                    pass
                elif token in [46]:
                    self.state = 401
                    self.string()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

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


        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 opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.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 = MyGrammarParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_ifStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 407
            self.match(MyGrammarParser.T__26)
            self.state = 408
            self.match(MyGrammarParser.T__14)
            self.state = 409
            self.opAnd(0)
            self.state = 410
            self.match(MyGrammarParser.T__15)
            self.state = 411
            self.match(MyGrammarParser.T__27)
            self.state = 412
            self.body()
            self.state = 413
            self.match(MyGrammarParser.T__28)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElifStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_elifStatement

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

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




    def elifStatement(self):

        localctx = MyGrammarParser.ElifStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_elifStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            self.match(MyGrammarParser.T__29)
            self.state = 416
            self.match(MyGrammarParser.T__26)
            self.state = 417
            self.match(MyGrammarParser.T__14)
            self.state = 418
            self.opAnd(0)
            self.state = 419
            self.match(MyGrammarParser.T__15)
            self.state = 420
            self.match(MyGrammarParser.T__27)
            self.state = 421
            self.body()
            self.state = 422
            self.match(MyGrammarParser.T__28)
        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 body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.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 = MyGrammarParser.ElseStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_elseStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424
            self.match(MyGrammarParser.T__29)
            self.state = 425
            self.match(MyGrammarParser.T__27)
            self.state = 426
            self.body()
            self.state = 427
            self.match(MyGrammarParser.T__28)
        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 opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.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 = MyGrammarParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429
            self.match(MyGrammarParser.T__30)
            self.state = 430
            self.match(MyGrammarParser.T__14)
            self.state = 431
            self.opAnd(0)
            self.state = 432
            self.match(MyGrammarParser.T__15)
            self.state = 433
            self.match(MyGrammarParser.T__27)
            self.state = 434
            self.body()
            self.state = 435
            self.match(MyGrammarParser.T__28)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForLoopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


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


        def variableDefinition(self):
            return self.getTypedRuleContext(MyGrammarParser.VariableDefinitionContext,0)


        def assignmentStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.AssignmentStatementContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.AssignmentStatementContext,i)


        def increment(self):
            return self.getTypedRuleContext(MyGrammarParser.IncrementContext,0)


        def decrement(self):
            return self.getTypedRuleContext(MyGrammarParser.DecrementContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_forLoop

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

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




    def forLoop(self):

        localctx = MyGrammarParser.ForLoopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_forLoop)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 437
            self.match(MyGrammarParser.T__31)
            self.state = 438
            self.match(MyGrammarParser.T__14)
            self.state = 457
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [15, 18, 19, 20, 21, 22, 23, 38, 39, 40, 41, 44, 45, 47, 48]:
                self.state = 446
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                if la_ == 1:
                    self.state = 439
                    self.variableDeclaration()
                    self.state = 440
                    self.match(MyGrammarParser.T__0)
                    pass

                elif la_ == 2:
                    self.state = 442
                    self.variableDefinition()
                    pass

                elif la_ == 3:
                    self.state = 443
                    self.assignmentStatement()
                    self.state = 444
                    self.match(MyGrammarParser.T__0)
                    pass


                self.state = 448
                self.opAnd(0)
                self.state = 449
                self.match(MyGrammarParser.T__0)
                self.state = 453
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
                if la_ == 1:
                    self.state = 450
                    self.assignmentStatement()
                    pass

                elif la_ == 2:
                    self.state = 451
                    self.increment()
                    pass

                elif la_ == 3:
                    self.state = 452
                    self.decrement()
                    pass


                pass
            elif token in [1]:
                self.state = 455
                self.match(MyGrammarParser.T__0)
                self.state = 456
                self.match(MyGrammarParser.T__0)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 459
            self.match(MyGrammarParser.T__15)
            self.state = 460
            self.match(MyGrammarParser.T__27)
            self.state = 461
            self.body()
            self.state = 462
            self.match(MyGrammarParser.T__28)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnNamedScopeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_unNamedScope

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

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




    def unNamedScope(self):

        localctx = MyGrammarParser.UnNamedScopeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_unNamedScope)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 464
            self.match(MyGrammarParser.T__27)
            self.state = 465
            self.body()
            self.state = 466
            self.match(MyGrammarParser.T__28)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return MyGrammarParser.RULE_comment

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

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




    def comment(self):

        localctx = MyGrammarParser.CommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_comment)
        try:
            self.state = 478
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [50]:
                self.enterOuterAlt(localctx, 1)
                self.state = 469 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 468
                        self.match(MyGrammarParser.BLOCK_COMMENT)

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

                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 2)
                self.state = 474 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 473
                        self.match(MyGrammarParser.COMMENT)

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

                pass
            else:
                raise NoViableAltException(self)

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


    class ArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constWord(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.ConstWordContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.ConstWordContext,i)


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

        def getRuleIndex(self):
            return MyGrammarParser.RULE_argument

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

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




    def argument(self):

        localctx = MyGrammarParser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_argument)
        self._la = 0 # Token type
        try:
            self.state = 496
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [18, 19, 20, 21, 22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 488
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 480
                        self.constWord()
                        self.state = 482
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==44:
                            self.state = 481
                            self.match(MyGrammarParser.ID)


                        self.state = 484
                        self.match(MyGrammarParser.T__25) 
                    self.state = 490
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

                self.state = 491
                self.constWord()
                self.state = 493
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 492
                    self.match(MyGrammarParser.ID)


                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 2)

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

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

        def constWord(self):
            return self.getTypedRuleContext(MyGrammarParser.ConstWordContext,0)


        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def argument(self):
            return self.getTypedRuleContext(MyGrammarParser.ArgumentContext,0)


        def body(self):
            return self.getTypedRuleContext(MyGrammarParser.BodyContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_funcDefinition

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

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




    def funcDefinition(self):

        localctx = MyGrammarParser.FuncDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_funcDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 498
            self.constWord()
            self.state = 499
            self.match(MyGrammarParser.ID)
            self.state = 500
            self.match(MyGrammarParser.T__14)
            self.state = 501
            self.argument()
            self.state = 502
            self.match(MyGrammarParser.T__15)
            self.state = 503
            self.match(MyGrammarParser.T__27)
            self.state = 504
            self.body()
            self.state = 505
            self.match(MyGrammarParser.T__28)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FuncDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constWord(self):
            return self.getTypedRuleContext(MyGrammarParser.ConstWordContext,0)


        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def argument(self):
            return self.getTypedRuleContext(MyGrammarParser.ArgumentContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_funcDeclaration

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

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




    def funcDeclaration(self):

        localctx = MyGrammarParser.FuncDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_funcDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 507
            self.constWord()
            self.state = 508
            self.match(MyGrammarParser.ID)
            self.state = 509
            self.match(MyGrammarParser.T__14)
            self.state = 510
            self.argument()
            self.state = 511
            self.match(MyGrammarParser.T__15)
            self.state = 512
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def opAnd(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.OpAndContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.OpAndContext,i)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_argumentCall

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

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




    def argumentCall(self):

        localctx = MyGrammarParser.ArgumentCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_argumentCall)
        try:
            self.state = 529
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10, 11, 14, 15, 23, 38, 39, 40, 41, 44, 45, 47, 48]:
                self.enterOuterAlt(localctx, 1)
                self.state = 521
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 516
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                        if la_ == 1:
                            self.state = 514
                            self.match(MyGrammarParser.ID)
                            pass

                        elif la_ == 2:
                            self.state = 515
                            self.opAnd(0)
                            pass


                        self.state = 518
                        self.match(MyGrammarParser.T__25) 
                    self.state = 523
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,38,self._ctx)

                self.state = 526
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
                if la_ == 1:
                    self.state = 524
                    self.match(MyGrammarParser.ID)
                    pass

                elif la_ == 2:
                    self.state = 525
                    self.opAnd(0)
                    pass


                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 2)

                pass
            else:
                raise NoViableAltException(self)

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


    class FunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def argumentCall(self):
            return self.getTypedRuleContext(MyGrammarParser.ArgumentCallContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.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 = MyGrammarParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_functionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531
            self.match(MyGrammarParser.ID)
            self.state = 532
            self.match(MyGrammarParser.T__14)
            self.state = 533
            self.argumentCall()
            self.state = 534
            self.match(MyGrammarParser.T__15)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrDeclContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constWord(self):
            return self.getTypedRuleContext(MyGrammarParser.ConstWordContext,0)


        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_arrDecl

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

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




    def arrDecl(self):

        localctx = MyGrammarParser.ArrDeclContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_arrDecl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 536
            self.constWord()
            self.state = 537
            self.match(MyGrammarParser.ID)
            self.state = 538
            self.match(MyGrammarParser.T__32)

            self.state = 539
            self.opAnd(0)
            self.state = 540
            self.match(MyGrammarParser.T__33)
            self.state = 541
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrDefContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constWord(self):
            return self.getTypedRuleContext(MyGrammarParser.ConstWordContext,0)


        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def arrArg(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrArgContext,0)


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_arrDef

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

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




    def arrDef(self):

        localctx = MyGrammarParser.ArrDefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_arrDef)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            self.constWord()
            self.state = 544
            self.match(MyGrammarParser.ID)
            self.state = 545
            self.match(MyGrammarParser.T__32)

            self.state = 546
            self.opAnd(0)
            self.state = 547
            self.match(MyGrammarParser.T__33)
            self.state = 548
            self.match(MyGrammarParser.T__16)
            self.state = 549
            self.arrArg()
            self.state = 550
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def nameIdentifier(self):
            return self.getTypedRuleContext(MyGrammarParser.NameIdentifierContext,0)


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_arrCall

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

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




    def arrCall(self):

        localctx = MyGrammarParser.ArrCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_arrCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 552
            self.nameIdentifier()
            self.state = 553
            self.match(MyGrammarParser.T__32)

            self.state = 554
            self.opAnd(0)
            self.state = 555
            self.match(MyGrammarParser.T__33)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArrArgContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def dataTypes(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MyGrammarParser.DataTypesContext)
            else:
                return self.getTypedRuleContext(MyGrammarParser.DataTypesContext,i)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_arrArg

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

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




    def arrArg(self):

        localctx = MyGrammarParser.ArrArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_arrArg)
        self._la = 0 # Token type
        try:
            self.state = 572
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 557
                self.match(MyGrammarParser.T__27)
                self.state = 563
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 558
                        self.dataTypes()
                        self.state = 559
                        self.match(MyGrammarParser.T__25) 
                    self.state = 565
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

                self.state = 567
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 479112200224768) != 0):
                    self.state = 566
                    self.dataTypes()


                self.state = 569
                self.match(MyGrammarParser.T__28)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 570
                self.match(MyGrammarParser.T__27)
                self.state = 571
                self.match(MyGrammarParser.T__28)
                pass


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


    class ArrAssignContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ID(self):
            return self.getToken(MyGrammarParser.ID, 0)

        def dataTypes(self):
            return self.getTypedRuleContext(MyGrammarParser.DataTypesContext,0)


        def opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_arrAssign

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

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




    def arrAssign(self):

        localctx = MyGrammarParser.ArrAssignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_arrAssign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 574
            self.match(MyGrammarParser.ID)
            self.state = 575
            self.match(MyGrammarParser.T__32)

            self.state = 576
            self.opAnd(0)
            self.state = 577
            self.match(MyGrammarParser.T__33)
            self.state = 578
            self.match(MyGrammarParser.T__16)
            self.state = 579
            self.dataTypes()
            self.state = 580
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LibContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return MyGrammarParser.RULE_lib

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

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




    def lib(self):

        localctx = MyGrammarParser.LibContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_lib)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 582
            self.match(MyGrammarParser.T__34)
            self.state = 583
            self.match(MyGrammarParser.T__35)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(MyGrammarParser.ExprContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_body

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

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




    def body(self):

        localctx = MyGrammarParser.BodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_body)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 585
            self.expr()
        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 opAnd(self):
            return self.getTypedRuleContext(MyGrammarParser.OpAndContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.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 = MyGrammarParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_returnStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 587
            self.match(MyGrammarParser.T__36)
            self.state = 590
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10, 11, 14, 15, 23, 38, 39, 40, 41, 44, 45, 47, 48]:
                self.state = 588
                self.opAnd(0)
                pass
            elif token in [1]:
                pass
            else:
                raise NoViableAltException(self)

            self.state = 592
            self.match(MyGrammarParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IncrementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def referenceID(self):
            return self.getTypedRuleContext(MyGrammarParser.ReferenceIDContext,0)


        def arrCall(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrCallContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_increment

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

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




    def increment(self):

        localctx = MyGrammarParser.IncrementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_increment)
        try:
            self.state = 621
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 596
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
                if la_ == 1:
                    self.state = 594
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 595
                    self.arrCall()
                    pass


                self.state = 598
                self.match(MyGrammarParser.T__37)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 600
                self.match(MyGrammarParser.T__37)
                self.state = 603
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
                if la_ == 1:
                    self.state = 601
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 602
                    self.arrCall()
                    pass


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 605
                self.match(MyGrammarParser.T__14)
                self.state = 608
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
                if la_ == 1:
                    self.state = 606
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 607
                    self.arrCall()
                    pass


                self.state = 610
                self.match(MyGrammarParser.T__15)
                self.state = 611
                self.match(MyGrammarParser.T__37)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 613
                self.match(MyGrammarParser.T__37)
                self.state = 614
                self.match(MyGrammarParser.T__14)
                self.state = 617
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
                if la_ == 1:
                    self.state = 615
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 616
                    self.arrCall()
                    pass


                self.state = 619
                self.match(MyGrammarParser.T__15)
                pass


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


    class DecrementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def referenceID(self):
            return self.getTypedRuleContext(MyGrammarParser.ReferenceIDContext,0)


        def arrCall(self):
            return self.getTypedRuleContext(MyGrammarParser.ArrCallContext,0)


        def getRuleIndex(self):
            return MyGrammarParser.RULE_decrement

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

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




    def decrement(self):

        localctx = MyGrammarParser.DecrementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_decrement)
        try:
            self.state = 650
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 625
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
                if la_ == 1:
                    self.state = 623
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 624
                    self.arrCall()
                    pass


                self.state = 627
                self.match(MyGrammarParser.T__38)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 629
                self.match(MyGrammarParser.T__38)
                self.state = 632
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                if la_ == 1:
                    self.state = 630
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 631
                    self.arrCall()
                    pass


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 634
                self.match(MyGrammarParser.T__14)
                self.state = 637
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
                if la_ == 1:
                    self.state = 635
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 636
                    self.arrCall()
                    pass


                self.state = 639
                self.match(MyGrammarParser.T__15)
                self.state = 640
                self.match(MyGrammarParser.T__38)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 642
                self.match(MyGrammarParser.T__38)
                self.state = 643
                self.match(MyGrammarParser.T__14)
                self.state = 646
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
                if la_ == 1:
                    self.state = 644
                    self.referenceID()
                    pass

                elif la_ == 2:
                    self.state = 645
                    self.arrCall()
                    pass


                self.state = 648
                self.match(MyGrammarParser.T__15)
                pass


        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[2] = self.opAnd_sempred
        self._predicates[3] = self.opOr_sempred
        self._predicates[4] = self.opCompare_sempred
        self._predicates[5] = self.opAddOrSub_sempred
        self._predicates[6] = self.opMultOrDiv_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 opAnd_sempred(self, localctx:OpAndContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

    def opOr_sempred(self, localctx:OpOrContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 2)
         

    def opCompare_sempred(self, localctx:OpCompareContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 7)
         

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

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

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

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

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

    def opAddOrSub_sempred(self, localctx:OpAddOrSubContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 3)
         

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

    def opMultOrDiv_sempred(self, localctx:OpMultOrDivContext, predIndex:int):
            if predIndex == 10:
                return self.precpred(self._ctx, 4)
         

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

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