PseudocodeParser.py

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

def serializedATN():
    return [
        4,1,46,514,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,1,0,5,0,66,8,0,
        10,0,12,0,69,9,0,1,0,1,0,4,0,73,8,0,11,0,12,0,74,1,0,5,0,78,8,0,
        10,0,12,0,81,9,0,1,0,5,0,84,8,0,10,0,12,0,87,9,0,1,0,1,0,1,1,3,1,
        92,8,1,1,1,1,1,3,1,96,8,1,1,1,1,1,3,1,100,8,1,1,1,1,1,3,1,104,8,
        1,1,1,1,1,1,1,3,1,109,8,1,1,1,1,1,3,1,113,8,1,1,1,1,1,3,1,117,8,
        1,1,1,1,1,3,1,121,8,1,1,1,3,1,124,8,1,1,1,1,1,3,1,128,8,1,1,1,3,
        1,131,8,1,1,1,1,1,3,1,135,8,1,3,1,137,8,1,1,2,1,2,1,2,1,2,1,2,1,
        2,3,2,145,8,2,1,3,1,3,1,3,1,3,3,3,151,8,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,3,4,165,8,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
        4,5,4,174,8,4,10,4,12,4,177,9,4,1,4,1,4,3,4,181,8,4,1,5,1,5,1,5,
        1,5,1,6,1,6,1,6,1,6,3,6,191,8,6,1,6,1,6,1,6,4,6,196,8,6,11,6,12,
        6,197,1,6,1,6,4,6,202,8,6,11,6,12,6,203,1,6,5,6,207,8,6,10,6,12,
        6,210,9,6,3,6,212,8,6,1,6,5,6,215,8,6,10,6,12,6,218,9,6,1,6,1,6,
        1,6,1,7,1,7,1,7,3,7,226,8,7,1,7,1,7,1,8,1,8,1,8,5,8,233,8,8,10,8,
        12,8,236,9,8,1,9,3,9,239,8,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,
        10,1,11,1,11,1,11,5,11,252,8,11,10,11,12,11,255,9,11,1,12,1,12,1,
        13,1,13,3,13,261,8,13,1,13,1,13,1,13,1,13,1,13,4,13,268,8,13,11,
        13,12,13,269,1,13,1,13,4,13,274,8,13,11,13,12,13,275,1,13,5,13,279,
        8,13,10,13,12,13,282,9,13,3,13,284,8,13,1,13,5,13,287,8,13,10,13,
        12,13,290,9,13,1,13,1,13,1,13,1,14,1,14,3,14,297,8,14,1,14,1,14,
        1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,4,14,310,8,14,11,14,
        12,14,311,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16,1,16,
        1,16,1,16,1,16,4,16,328,8,16,11,16,12,16,329,1,16,1,16,1,16,1,16,
        1,16,1,16,1,16,1,16,4,16,340,8,16,11,16,12,16,341,1,16,1,16,5,16,
        346,8,16,10,16,12,16,349,9,16,1,16,1,16,1,16,4,16,354,8,16,11,16,
        12,16,355,1,16,3,16,359,8,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,
        1,17,1,17,4,17,370,8,17,11,17,12,17,371,1,17,1,17,4,17,376,8,17,
        11,17,12,17,377,1,17,5,17,381,8,17,10,17,12,17,384,9,17,3,17,386,
        8,17,1,17,5,17,389,8,17,10,17,12,17,392,9,17,1,17,1,17,1,17,1,18,
        1,18,1,18,1,19,1,19,1,20,1,20,4,20,404,8,20,11,20,12,20,405,1,20,
        5,20,409,8,20,10,20,12,20,412,9,20,3,20,414,8,20,1,20,5,20,417,8,
        20,10,20,12,20,420,9,20,1,21,1,21,1,22,1,22,1,22,4,22,427,8,22,11,
        22,12,22,428,1,22,3,22,432,8,22,1,23,1,23,1,23,4,23,437,8,23,11,
        23,12,23,438,1,23,3,23,442,8,23,1,24,1,24,1,24,1,24,1,24,3,24,449,
        8,24,1,25,1,25,1,25,4,25,454,8,25,11,25,12,25,455,1,25,3,25,459,
        8,25,1,26,1,26,1,26,4,26,464,8,26,11,26,12,26,465,1,26,3,26,469,
        8,26,1,27,1,27,1,27,4,27,474,8,27,11,27,12,27,475,1,27,3,27,479,
        8,27,1,28,1,28,1,28,3,28,484,8,28,1,29,1,29,1,29,1,29,1,29,1,29,
        1,29,3,29,493,8,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,502,8,
        29,1,30,1,30,1,30,5,30,507,8,30,10,30,12,30,510,9,30,1,31,1,31,1,
        31,0,0,32,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,0,7,4,0,29,29,31,31,33,33,35,
        35,2,0,17,17,19,20,1,0,42,43,2,0,22,22,24,27,2,0,32,32,34,34,2,0,
        30,30,36,36,2,0,12,13,16,20,561,0,67,1,0,0,0,2,136,1,0,0,0,4,144,
        1,0,0,0,6,146,1,0,0,0,8,180,1,0,0,0,10,182,1,0,0,0,12,186,1,0,0,
        0,14,222,1,0,0,0,16,229,1,0,0,0,18,238,1,0,0,0,20,242,1,0,0,0,22,
        248,1,0,0,0,24,256,1,0,0,0,26,258,1,0,0,0,28,294,1,0,0,0,30,317,
        1,0,0,0,32,321,1,0,0,0,34,363,1,0,0,0,36,396,1,0,0,0,38,399,1,0,
        0,0,40,413,1,0,0,0,42,421,1,0,0,0,44,431,1,0,0,0,46,441,1,0,0,0,
        48,448,1,0,0,0,50,458,1,0,0,0,52,468,1,0,0,0,54,478,1,0,0,0,56,483,
        1,0,0,0,58,501,1,0,0,0,60,503,1,0,0,0,62,511,1,0,0,0,64,66,5,45,
        0,0,65,64,1,0,0,0,66,69,1,0,0,0,67,65,1,0,0,0,67,68,1,0,0,0,68,70,
        1,0,0,0,69,67,1,0,0,0,70,79,3,2,1,0,71,73,5,45,0,0,72,71,1,0,0,0,
        73,74,1,0,0,0,74,72,1,0,0,0,74,75,1,0,0,0,75,76,1,0,0,0,76,78,3,
        2,1,0,77,72,1,0,0,0,78,81,1,0,0,0,79,77,1,0,0,0,79,80,1,0,0,0,80,
        85,1,0,0,0,81,79,1,0,0,0,82,84,5,45,0,0,83,82,1,0,0,0,84,87,1,0,
        0,0,85,83,1,0,0,0,85,86,1,0,0,0,86,88,1,0,0,0,87,85,1,0,0,0,88,89,
        5,0,0,1,89,1,1,0,0,0,90,92,3,20,10,0,91,90,1,0,0,0,91,92,1,0,0,0,
        92,93,1,0,0,0,93,95,3,6,3,0,94,96,5,43,0,0,95,94,1,0,0,0,95,96,1,
        0,0,0,96,137,1,0,0,0,97,137,3,12,6,0,98,100,3,20,10,0,99,98,1,0,
        0,0,99,100,1,0,0,0,100,101,1,0,0,0,101,103,3,14,7,0,102,104,5,43,
        0,0,103,102,1,0,0,0,103,104,1,0,0,0,104,137,1,0,0,0,105,137,3,26,
        13,0,106,137,3,28,14,0,107,109,3,20,10,0,108,107,1,0,0,0,108,109,
        1,0,0,0,109,110,1,0,0,0,110,137,3,32,16,0,111,113,3,20,10,0,112,
        111,1,0,0,0,112,113,1,0,0,0,113,114,1,0,0,0,114,137,3,34,17,0,115,
        117,3,20,10,0,116,115,1,0,0,0,116,117,1,0,0,0,117,118,1,0,0,0,118,
        120,3,36,18,0,119,121,5,43,0,0,120,119,1,0,0,0,120,121,1,0,0,0,121,
        137,1,0,0,0,122,124,3,20,10,0,123,122,1,0,0,0,123,124,1,0,0,0,124,
        125,1,0,0,0,125,127,3,38,19,0,126,128,5,43,0,0,127,126,1,0,0,0,127,
        128,1,0,0,0,128,137,1,0,0,0,129,131,3,20,10,0,130,129,1,0,0,0,130,
        131,1,0,0,0,131,132,1,0,0,0,132,134,3,10,5,0,133,135,5,43,0,0,134,
        133,1,0,0,0,134,135,1,0,0,0,135,137,1,0,0,0,136,91,1,0,0,0,136,97,
        1,0,0,0,136,99,1,0,0,0,136,105,1,0,0,0,136,106,1,0,0,0,136,108,1,
        0,0,0,136,112,1,0,0,0,136,116,1,0,0,0,136,123,1,0,0,0,136,130,1,
        0,0,0,137,3,1,0,0,0,138,139,5,17,0,0,139,140,5,37,0,0,140,141,3,
        42,21,0,141,142,5,38,0,0,142,145,1,0,0,0,143,145,5,17,0,0,144,138,
        1,0,0,0,144,143,1,0,0,0,145,5,1,0,0,0,146,147,3,4,2,0,147,150,5,
        23,0,0,148,151,3,42,21,0,149,151,3,8,4,0,150,148,1,0,0,0,150,149,
        1,0,0,0,151,7,1,0,0,0,152,153,5,1,0,0,153,154,5,37,0,0,154,155,3,
        42,21,0,155,156,5,2,0,0,156,157,3,42,21,0,157,158,5,38,0,0,158,181,
        1,0,0,0,159,160,5,1,0,0,160,161,5,39,0,0,161,164,3,42,21,0,162,163,
        5,42,0,0,163,165,3,42,21,0,164,162,1,0,0,0,164,165,1,0,0,0,165,166,
        1,0,0,0,166,167,5,40,0,0,167,181,1,0,0,0,168,169,5,1,0,0,169,170,
        5,37,0,0,170,175,3,42,21,0,171,172,5,42,0,0,172,174,3,42,21,0,173,
        171,1,0,0,0,174,177,1,0,0,0,175,173,1,0,0,0,175,176,1,0,0,0,176,
        178,1,0,0,0,177,175,1,0,0,0,178,179,5,38,0,0,179,181,1,0,0,0,180,
        152,1,0,0,0,180,159,1,0,0,0,180,168,1,0,0,0,181,9,1,0,0,0,182,183,
        3,4,2,0,183,184,7,0,0,0,184,185,3,42,21,0,185,11,1,0,0,0,186,187,
        5,3,0,0,187,188,5,17,0,0,188,190,5,39,0,0,189,191,3,16,8,0,190,189,
        1,0,0,0,190,191,1,0,0,0,191,192,1,0,0,0,192,193,5,40,0,0,193,195,
        5,41,0,0,194,196,5,45,0,0,195,194,1,0,0,0,196,197,1,0,0,0,197,195,
        1,0,0,0,197,198,1,0,0,0,198,211,1,0,0,0,199,208,3,2,1,0,200,202,
        5,45,0,0,201,200,1,0,0,0,202,203,1,0,0,0,203,201,1,0,0,0,203,204,
        1,0,0,0,204,205,1,0,0,0,205,207,3,2,1,0,206,201,1,0,0,0,207,210,
        1,0,0,0,208,206,1,0,0,0,208,209,1,0,0,0,209,212,1,0,0,0,210,208,
        1,0,0,0,211,199,1,0,0,0,211,212,1,0,0,0,212,216,1,0,0,0,213,215,
        5,45,0,0,214,213,1,0,0,0,215,218,1,0,0,0,216,214,1,0,0,0,216,217,
        1,0,0,0,217,219,1,0,0,0,218,216,1,0,0,0,219,220,5,9,0,0,220,221,
        5,3,0,0,221,13,1,0,0,0,222,223,5,17,0,0,223,225,5,39,0,0,224,226,
        3,60,30,0,225,224,1,0,0,0,225,226,1,0,0,0,226,227,1,0,0,0,227,228,
        5,40,0,0,228,15,1,0,0,0,229,234,3,18,9,0,230,231,5,42,0,0,231,233,
        3,18,9,0,232,230,1,0,0,0,233,236,1,0,0,0,234,232,1,0,0,0,234,235,
        1,0,0,0,235,17,1,0,0,0,236,234,1,0,0,0,237,239,3,20,10,0,238,237,
        1,0,0,0,238,239,1,0,0,0,239,240,1,0,0,0,240,241,5,17,0,0,241,19,
        1,0,0,0,242,243,5,44,0,0,243,244,5,17,0,0,244,245,5,25,0,0,245,246,
        3,22,11,0,246,247,5,27,0,0,247,21,1,0,0,0,248,253,3,24,12,0,249,
        250,5,42,0,0,250,252,3,24,12,0,251,249,1,0,0,0,252,255,1,0,0,0,253,
        251,1,0,0,0,253,254,1,0,0,0,254,23,1,0,0,0,255,253,1,0,0,0,256,257,
        7,1,0,0,257,25,1,0,0,0,258,260,5,4,0,0,259,261,3,20,10,0,260,259,
        1,0,0,0,260,261,1,0,0,0,261,262,1,0,0,0,262,263,5,17,0,0,263,264,
        5,5,0,0,264,265,5,17,0,0,265,267,5,41,0,0,266,268,5,45,0,0,267,266,
        1,0,0,0,268,269,1,0,0,0,269,267,1,0,0,0,269,270,1,0,0,0,270,283,
        1,0,0,0,271,280,3,2,1,0,272,274,5,45,0,0,273,272,1,0,0,0,274,275,
        1,0,0,0,275,273,1,0,0,0,275,276,1,0,0,0,276,277,1,0,0,0,277,279,
        3,2,1,0,278,273,1,0,0,0,279,282,1,0,0,0,280,278,1,0,0,0,280,281,
        1,0,0,0,281,284,1,0,0,0,282,280,1,0,0,0,283,271,1,0,0,0,283,284,
        1,0,0,0,284,288,1,0,0,0,285,287,5,45,0,0,286,285,1,0,0,0,287,290,
        1,0,0,0,288,286,1,0,0,0,288,289,1,0,0,0,289,291,1,0,0,0,290,288,
        1,0,0,0,291,292,5,9,0,0,292,293,5,4,0,0,293,27,1,0,0,0,294,296,5,
        4,0,0,295,297,3,20,10,0,296,295,1,0,0,0,296,297,1,0,0,0,297,298,
        1,0,0,0,298,299,5,39,0,0,299,300,5,17,0,0,300,301,5,23,0,0,301,302,
        3,42,21,0,302,303,7,2,0,0,303,304,3,42,21,0,304,305,7,2,0,0,305,
        306,3,30,15,0,306,307,5,40,0,0,307,309,5,41,0,0,308,310,5,45,0,0,
        309,308,1,0,0,0,310,311,1,0,0,0,311,309,1,0,0,0,311,312,1,0,0,0,
        312,313,1,0,0,0,313,314,3,40,20,0,314,315,5,9,0,0,315,316,5,4,0,
        0,316,29,1,0,0,0,317,318,5,17,0,0,318,319,7,0,0,0,319,320,3,42,21,
        0,320,31,1,0,0,0,321,322,5,6,0,0,322,323,5,39,0,0,323,324,3,42,21,
        0,324,325,5,40,0,0,325,327,5,41,0,0,326,328,5,45,0,0,327,326,1,0,
        0,0,328,329,1,0,0,0,329,327,1,0,0,0,329,330,1,0,0,0,330,331,1,0,
        0,0,331,347,3,40,20,0,332,333,5,7,0,0,333,334,5,6,0,0,334,335,5,
        39,0,0,335,336,3,42,21,0,336,337,5,40,0,0,337,339,5,41,0,0,338,340,
        5,45,0,0,339,338,1,0,0,0,340,341,1,0,0,0,341,339,1,0,0,0,341,342,
        1,0,0,0,342,343,1,0,0,0,343,344,3,40,20,0,344,346,1,0,0,0,345,332,
        1,0,0,0,346,349,1,0,0,0,347,345,1,0,0,0,347,348,1,0,0,0,348,358,
        1,0,0,0,349,347,1,0,0,0,350,351,5,7,0,0,351,353,5,41,0,0,352,354,
        5,45,0,0,353,352,1,0,0,0,354,355,1,0,0,0,355,353,1,0,0,0,355,356,
        1,0,0,0,356,357,1,0,0,0,357,359,3,40,20,0,358,350,1,0,0,0,358,359,
        1,0,0,0,359,360,1,0,0,0,360,361,5,9,0,0,361,362,5,6,0,0,362,33,1,
        0,0,0,363,364,5,10,0,0,364,365,5,39,0,0,365,366,3,42,21,0,366,367,
        5,40,0,0,367,369,5,41,0,0,368,370,5,45,0,0,369,368,1,0,0,0,370,371,
        1,0,0,0,371,369,1,0,0,0,371,372,1,0,0,0,372,385,1,0,0,0,373,382,
        3,2,1,0,374,376,5,45,0,0,375,374,1,0,0,0,376,377,1,0,0,0,377,375,
        1,0,0,0,377,378,1,0,0,0,378,379,1,0,0,0,379,381,3,2,1,0,380,375,
        1,0,0,0,381,384,1,0,0,0,382,380,1,0,0,0,382,383,1,0,0,0,383,386,
        1,0,0,0,384,382,1,0,0,0,385,373,1,0,0,0,385,386,1,0,0,0,386,390,
        1,0,0,0,387,389,5,45,0,0,388,387,1,0,0,0,389,392,1,0,0,0,390,388,
        1,0,0,0,390,391,1,0,0,0,391,393,1,0,0,0,392,390,1,0,0,0,393,394,
        5,9,0,0,394,395,5,10,0,0,395,35,1,0,0,0,396,397,5,8,0,0,397,398,
        3,42,21,0,398,37,1,0,0,0,399,400,5,11,0,0,400,39,1,0,0,0,401,410,
        3,2,1,0,402,404,5,45,0,0,403,402,1,0,0,0,404,405,1,0,0,0,405,403,
        1,0,0,0,405,406,1,0,0,0,406,407,1,0,0,0,407,409,3,2,1,0,408,403,
        1,0,0,0,409,412,1,0,0,0,410,408,1,0,0,0,410,411,1,0,0,0,411,414,
        1,0,0,0,412,410,1,0,0,0,413,401,1,0,0,0,413,414,1,0,0,0,414,418,
        1,0,0,0,415,417,5,45,0,0,416,415,1,0,0,0,417,420,1,0,0,0,418,416,
        1,0,0,0,418,419,1,0,0,0,419,41,1,0,0,0,420,418,1,0,0,0,421,422,3,
        44,22,0,422,43,1,0,0,0,423,426,3,46,23,0,424,425,5,15,0,0,425,427,
        3,46,23,0,426,424,1,0,0,0,427,428,1,0,0,0,428,426,1,0,0,0,428,429,
        1,0,0,0,429,432,1,0,0,0,430,432,3,46,23,0,431,423,1,0,0,0,431,430,
        1,0,0,0,432,45,1,0,0,0,433,436,3,48,24,0,434,435,5,14,0,0,435,437,
        3,48,24,0,436,434,1,0,0,0,437,438,1,0,0,0,438,436,1,0,0,0,438,439,
        1,0,0,0,439,442,1,0,0,0,440,442,3,48,24,0,441,433,1,0,0,0,441,440,
        1,0,0,0,442,47,1,0,0,0,443,444,3,50,25,0,444,445,7,3,0,0,445,446,
        3,50,25,0,446,449,1,0,0,0,447,449,3,50,25,0,448,443,1,0,0,0,448,
        447,1,0,0,0,449,49,1,0,0,0,450,453,3,52,26,0,451,452,7,4,0,0,452,
        454,3,52,26,0,453,451,1,0,0,0,454,455,1,0,0,0,455,453,1,0,0,0,455,
        456,1,0,0,0,456,459,1,0,0,0,457,459,3,52,26,0,458,450,1,0,0,0,458,
        457,1,0,0,0,459,51,1,0,0,0,460,463,3,54,27,0,461,462,7,5,0,0,462,
        464,3,54,27,0,463,461,1,0,0,0,464,465,1,0,0,0,465,463,1,0,0,0,465,
        466,1,0,0,0,466,469,1,0,0,0,467,469,3,54,27,0,468,460,1,0,0,0,468,
        467,1,0,0,0,469,53,1,0,0,0,470,473,3,56,28,0,471,472,5,28,0,0,472,
        474,3,56,28,0,473,471,1,0,0,0,474,475,1,0,0,0,475,473,1,0,0,0,475,
        476,1,0,0,0,476,479,1,0,0,0,477,479,3,56,28,0,478,470,1,0,0,0,478,
        477,1,0,0,0,479,55,1,0,0,0,480,481,5,34,0,0,481,484,3,56,28,0,482,
        484,3,58,29,0,483,480,1,0,0,0,483,482,1,0,0,0,484,57,1,0,0,0,485,
        486,5,39,0,0,486,487,3,42,21,0,487,488,5,40,0,0,488,502,1,0,0,0,
        489,490,5,17,0,0,490,492,5,39,0,0,491,493,3,60,30,0,492,491,1,0,
        0,0,492,493,1,0,0,0,493,494,1,0,0,0,494,502,5,40,0,0,495,496,5,17,
        0,0,496,497,5,37,0,0,497,498,3,42,21,0,498,499,5,38,0,0,499,502,
        1,0,0,0,500,502,3,62,31,0,501,485,1,0,0,0,501,489,1,0,0,0,501,495,
        1,0,0,0,501,500,1,0,0,0,502,59,1,0,0,0,503,508,3,42,21,0,504,505,
        5,42,0,0,505,507,3,42,21,0,506,504,1,0,0,0,507,510,1,0,0,0,508,506,
        1,0,0,0,508,509,1,0,0,0,509,61,1,0,0,0,510,508,1,0,0,0,511,512,7,
        6,0,0,512,63,1,0,0,0,69,67,74,79,85,91,95,99,103,108,112,116,120,
        123,127,130,134,136,144,150,164,175,180,190,197,203,208,211,216,
        225,234,238,253,260,269,275,280,283,288,296,311,329,341,347,355,
        358,371,377,382,385,390,405,410,413,418,428,431,438,441,448,455,
        458,465,468,475,478,483,492,501,508
    ]

class PseudocodeParser ( Parser ):

    grammarFileName = "Pseudocode.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'arr'", "'to'", "'fun'", "'for'", "'in'", 
                     "'if'", "'else'", "'return'", "'end'", "'while'", "'break'", 
                     "<INVALID>", "'False'", "'and'", "'or'", "'Null'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'=='", "'='", "'<='", "'<'", "'>='", 
                     "'>'", "'**'", "'*='", "'*'", "'+='", "'+'", "'-='", 
                     "'-'", "'/='", "'/'", "'['", "']'", "'('", "')'", "':'", 
                     "','", "';'", "'@'" ]

    symbolicNames = [ "<INVALID>", "ARR", "TO", "FUN", "FOR", "IN", "IF", 
                      "ELSE", "RETURN", "END", "WHILE", "BREAK", "TRUE", 
                      "FALSE", "AND", "OR", "NULL", "ID", "FLOAT", "INT", 
                      "STRING", "COMMENT", "EQEQ", "EQ", "LESS_EQ", "LOW_THAN", 
                      "GREATER_EQ", "GREATER_THAN", "POW", "STAR_EQ", "STAR", 
                      "PLUS_EQ", "PLUS", "MINUS_EQ", "MINUS", "SLASH_EQ", 
                      "SLASH", "LBRACK", "RBRACK", "LPAREN", "RPAREN", "COLON", 
                      "COMMA", "SEMICOLON", "AT", "NL", "WS" ]

    RULE_program = 0
    RULE_statement = 1
    RULE_lvalue = 2
    RULE_assignment = 3
    RULE_arrayInitialization = 4
    RULE_compoundAssignment = 5
    RULE_functionDecl = 6
    RULE_functionCallStatement = 7
    RULE_paramList = 8
    RULE_annotatedParam = 9
    RULE_annotation = 10
    RULE_annotationArgList = 11
    RULE_annotationArg = 12
    RULE_forEachLoop = 13
    RULE_regularForLoop = 14
    RULE_forUpdate = 15
    RULE_ifStatement = 16
    RULE_whileLoop = 17
    RULE_returnStatement = 18
    RULE_breakStatement = 19
    RULE_block = 20
    RULE_expression = 21
    RULE_logicalOrExpression = 22
    RULE_logicalAndExpression = 23
    RULE_comparisonExpression = 24
    RULE_additiveExpression = 25
    RULE_multiplicativeExpression = 26
    RULE_powerExpression = 27
    RULE_unaryExpression = 28
    RULE_primaryExpression = 29
    RULE_expressionList = 30
    RULE_atom = 31

    ruleNames =  [ "program", "statement", "lvalue", "assignment", "arrayInitialization", 
                   "compoundAssignment", "functionDecl", "functionCallStatement", 
                   "paramList", "annotatedParam", "annotation", "annotationArgList", 
                   "annotationArg", "forEachLoop", "regularForLoop", "forUpdate", 
                   "ifStatement", "whileLoop", "returnStatement", "breakStatement", 
                   "block", "expression", "logicalOrExpression", "logicalAndExpression", 
                   "comparisonExpression", "additiveExpression", "multiplicativeExpression", 
                   "powerExpression", "unaryExpression", "primaryExpression", 
                   "expressionList", "atom" ]

    EOF = Token.EOF
    ARR=1
    TO=2
    FUN=3
    FOR=4
    IN=5
    IF=6
    ELSE=7
    RETURN=8
    END=9
    WHILE=10
    BREAK=11
    TRUE=12
    FALSE=13
    AND=14
    OR=15
    NULL=16
    ID=17
    FLOAT=18
    INT=19
    STRING=20
    COMMENT=21
    EQEQ=22
    EQ=23
    LESS_EQ=24
    LOW_THAN=25
    GREATER_EQ=26
    GREATER_THAN=27
    POW=28
    STAR_EQ=29
    STAR=30
    PLUS_EQ=31
    PLUS=32
    MINUS_EQ=33
    MINUS=34
    SLASH_EQ=35
    SLASH=36
    LBRACK=37
    RBRACK=38
    LPAREN=39
    RPAREN=40
    COLON=41
    COMMA=42
    SEMICOLON=43
    AT=44
    NL=45
    WS=46

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




    class ProgramContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def EOF(self):
            return self.getToken(PseudocodeParser.EOF, 0)

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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_program

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

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

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




    def program(self):

        localctx = PseudocodeParser.ProgramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_program)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 67
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==45:
                self.state = 64
                self.match(PseudocodeParser.NL)
                self.state = 69
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 70
            self.statement()
            self.state = 79
            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:
                    self.state = 72 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 71
                        self.match(PseudocodeParser.NL)
                        self.state = 74 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==45):
                            break

                    self.state = 76
                    self.statement() 
                self.state = 81
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

            self.state = 85
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==45:
                self.state = 82
                self.match(PseudocodeParser.NL)
                self.state = 87
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assignment(self):
            return self.getTypedRuleContext(PseudocodeParser.AssignmentContext,0)


        def annotation(self):
            return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0)


        def SEMICOLON(self):
            return self.getToken(PseudocodeParser.SEMICOLON, 0)

        def functionDecl(self):
            return self.getTypedRuleContext(PseudocodeParser.FunctionDeclContext,0)


        def functionCallStatement(self):
            return self.getTypedRuleContext(PseudocodeParser.FunctionCallStatementContext,0)


        def forEachLoop(self):
            return self.getTypedRuleContext(PseudocodeParser.ForEachLoopContext,0)


        def regularForLoop(self):
            return self.getTypedRuleContext(PseudocodeParser.RegularForLoopContext,0)


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


        def whileLoop(self):
            return self.getTypedRuleContext(PseudocodeParser.WhileLoopContext,0)


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


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


        def compoundAssignment(self):
            return self.getTypedRuleContext(PseudocodeParser.CompoundAssignmentContext,0)


        def getRuleIndex(self):
            return PseudocodeParser.RULE_statement

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

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

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




    def statement(self):

        localctx = PseudocodeParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 136
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 91
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 90
                    self.annotation()


                self.state = 93
                self.assignment()
                self.state = 95
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 94
                    self.match(PseudocodeParser.SEMICOLON)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 97
                self.functionDecl()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 99
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 98
                    self.annotation()


                self.state = 101
                self.functionCallStatement()
                self.state = 103
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 102
                    self.match(PseudocodeParser.SEMICOLON)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 105
                self.forEachLoop()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 106
                self.regularForLoop()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 108
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 107
                    self.annotation()


                self.state = 110
                self.ifStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 112
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 111
                    self.annotation()


                self.state = 114
                self.whileLoop()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 116
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 115
                    self.annotation()


                self.state = 118
                self.returnStatement()
                self.state = 120
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 119
                    self.match(PseudocodeParser.SEMICOLON)


                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 123
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 122
                    self.annotation()


                self.state = 125
                self.breakStatement()
                self.state = 127
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 126
                    self.match(PseudocodeParser.SEMICOLON)


                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 130
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==44:
                    self.state = 129
                    self.annotation()


                self.state = 132
                self.compoundAssignment()
                self.state = 134
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==43:
                    self.state = 133
                    self.match(PseudocodeParser.SEMICOLON)


                pass


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


    class LvalueContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_lvalue

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class SimpleLvalueContext(LvalueContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LvalueContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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


    class ArrayLvalueContext(LvalueContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LvalueContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(PseudocodeParser.ID, 0)
        def LBRACK(self):
            return self.getToken(PseudocodeParser.LBRACK, 0)
        def expression(self):
            return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0)

        def RBRACK(self):
            return self.getToken(PseudocodeParser.RBRACK, 0)

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

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

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



    def lvalue(self):

        localctx = PseudocodeParser.LvalueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_lvalue)
        try:
            self.state = 144
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.ArrayLvalueContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 138
                self.match(PseudocodeParser.ID)
                self.state = 139
                self.match(PseudocodeParser.LBRACK)
                self.state = 140
                self.expression()
                self.state = 141
                self.match(PseudocodeParser.RBRACK)
                pass

            elif la_ == 2:
                localctx = PseudocodeParser.SimpleLvalueContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 143
                self.match(PseudocodeParser.ID)
                pass


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


    class AssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lvalue(self):
            return self.getTypedRuleContext(PseudocodeParser.LvalueContext,0)


        def EQ(self):
            return self.getToken(PseudocodeParser.EQ, 0)

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


        def arrayInitialization(self):
            return self.getTypedRuleContext(PseudocodeParser.ArrayInitializationContext,0)


        def getRuleIndex(self):
            return PseudocodeParser.RULE_assignment

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

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

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




    def assignment(self):

        localctx = PseudocodeParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 146
            self.lvalue()
            self.state = 147
            self.match(PseudocodeParser.EQ)
            self.state = 150
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [12, 13, 16, 17, 18, 19, 20, 34, 39]:
                self.state = 148
                self.expression()
                pass
            elif token in [1]:
                self.state = 149
                self.arrayInitialization()
                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 ArrayInitializationContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_arrayInitialization

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class RangeArrayContext(ArrayInitializationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ArrayInitializationContext
            super().__init__(parser)
            self.start = None # ExpressionContext
            self.stop = None # ExpressionContext
            self.copyFrom(ctx)

        def ARR(self):
            return self.getToken(PseudocodeParser.ARR, 0)
        def LBRACK(self):
            return self.getToken(PseudocodeParser.LBRACK, 0)
        def TO(self):
            return self.getToken(PseudocodeParser.TO, 0)
        def RBRACK(self):
            return self.getToken(PseudocodeParser.RBRACK, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i)


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

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

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


    class ValueArrayContext(ArrayInitializationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ArrayInitializationContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ARR(self):
            return self.getToken(PseudocodeParser.ARR, 0)
        def LBRACK(self):
            return self.getToken(PseudocodeParser.LBRACK, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i)

        def RBRACK(self):
            return self.getToken(PseudocodeParser.RBRACK, 0)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PseudocodeParser.COMMA)
            else:
                return self.getToken(PseudocodeParser.COMMA, i)

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

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

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


    class SizeArrayContext(ArrayInitializationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ArrayInitializationContext
            super().__init__(parser)
            self.size = None # ExpressionContext
            self.fill = None # ExpressionContext
            self.copyFrom(ctx)

        def ARR(self):
            return self.getToken(PseudocodeParser.ARR, 0)
        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)
        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,i)

        def COMMA(self):
            return self.getToken(PseudocodeParser.COMMA, 0)

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

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

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



    def arrayInitialization(self):

        localctx = PseudocodeParser.ArrayInitializationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_arrayInitialization)
        self._la = 0 # Token type
        try:
            self.state = 180
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.RangeArrayContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 152
                self.match(PseudocodeParser.ARR)
                self.state = 153
                self.match(PseudocodeParser.LBRACK)
                self.state = 154
                localctx.start = self.expression()
                self.state = 155
                self.match(PseudocodeParser.TO)
                self.state = 156
                localctx.stop = self.expression()
                self.state = 157
                self.match(PseudocodeParser.RBRACK)
                pass

            elif la_ == 2:
                localctx = PseudocodeParser.SizeArrayContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 159
                self.match(PseudocodeParser.ARR)
                self.state = 160
                self.match(PseudocodeParser.LPAREN)
                self.state = 161
                localctx.size = self.expression()
                self.state = 164
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==42:
                    self.state = 162
                    self.match(PseudocodeParser.COMMA)
                    self.state = 163
                    localctx.fill = self.expression()


                self.state = 166
                self.match(PseudocodeParser.RPAREN)
                pass

            elif la_ == 3:
                localctx = PseudocodeParser.ValueArrayContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 168
                self.match(PseudocodeParser.ARR)
                self.state = 169
                self.match(PseudocodeParser.LBRACK)
                self.state = 170
                self.expression()
                self.state = 175
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==42:
                    self.state = 171
                    self.match(PseudocodeParser.COMMA)
                    self.state = 172
                    self.expression()
                    self.state = 177
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 178
                self.match(PseudocodeParser.RBRACK)
                pass


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


    class CompoundAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lvalue(self):
            return self.getTypedRuleContext(PseudocodeParser.LvalueContext,0)


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


        def PLUS_EQ(self):
            return self.getToken(PseudocodeParser.PLUS_EQ, 0)

        def MINUS_EQ(self):
            return self.getToken(PseudocodeParser.MINUS_EQ, 0)

        def STAR_EQ(self):
            return self.getToken(PseudocodeParser.STAR_EQ, 0)

        def SLASH_EQ(self):
            return self.getToken(PseudocodeParser.SLASH_EQ, 0)

        def getRuleIndex(self):
            return PseudocodeParser.RULE_compoundAssignment

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

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

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




    def compoundAssignment(self):

        localctx = PseudocodeParser.CompoundAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_compoundAssignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 182
            self.lvalue()
            self.state = 183
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 45634027520) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 184
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionDeclContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)

        def COLON(self):
            return self.getToken(PseudocodeParser.COLON, 0)

        def END(self):
            return self.getToken(PseudocodeParser.END, 0)

        def paramList(self):
            return self.getTypedRuleContext(PseudocodeParser.ParamListContext,0)


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

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_functionDecl

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

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

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




    def functionDecl(self):

        localctx = PseudocodeParser.FunctionDeclContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_functionDecl)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 186
            self.match(PseudocodeParser.FUN)
            self.state = 187
            self.match(PseudocodeParser.ID)
            self.state = 188
            self.match(PseudocodeParser.LPAREN)
            self.state = 190
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==17 or _la==44:
                self.state = 189
                self.paramList()


            self.state = 192
            self.match(PseudocodeParser.RPAREN)
            self.state = 193
            self.match(PseudocodeParser.COLON)
            self.state = 195 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 194
                    self.match(PseudocodeParser.NL)

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

            self.state = 211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0):
                self.state = 199
                self.statement()
                self.state = 208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,25,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 201 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 200
                            self.match(PseudocodeParser.NL)
                            self.state = 203 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==45):
                                break

                        self.state = 205
                        self.statement() 
                    self.state = 210
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,25,self._ctx)



            self.state = 216
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==45:
                self.state = 213
                self.match(PseudocodeParser.NL)
                self.state = 218
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 219
            self.match(PseudocodeParser.END)
            self.state = 220
            self.match(PseudocodeParser.FUN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionCallStatementContext(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(PseudocodeParser.ID, 0)

        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_functionCallStatement

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

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

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




    def functionCallStatement(self):

        localctx = PseudocodeParser.FunctionCallStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_functionCallStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 222
            self.match(PseudocodeParser.ID)
            self.state = 223
            self.match(PseudocodeParser.LPAREN)
            self.state = 225
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 566937726976) != 0):
                self.state = 224
                self.expressionList()


            self.state = 227
            self.match(PseudocodeParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParamListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def annotatedParam(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.AnnotatedParamContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.AnnotatedParamContext,i)


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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_paramList

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

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

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




    def paramList(self):

        localctx = PseudocodeParser.ParamListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_paramList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            self.annotatedParam()
            self.state = 234
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==42:
                self.state = 230
                self.match(PseudocodeParser.COMMA)
                self.state = 231
                self.annotatedParam()
                self.state = 236
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class AnnotatedParamContext(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(PseudocodeParser.ID, 0)

        def annotation(self):
            return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0)


        def getRuleIndex(self):
            return PseudocodeParser.RULE_annotatedParam

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

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

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




    def annotatedParam(self):

        localctx = PseudocodeParser.AnnotatedParamContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_annotatedParam)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44:
                self.state = 237
                self.annotation()


            self.state = 240
            self.match(PseudocodeParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnnotationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AT(self):
            return self.getToken(PseudocodeParser.AT, 0)

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

        def LOW_THAN(self):
            return self.getToken(PseudocodeParser.LOW_THAN, 0)

        def annotationArgList(self):
            return self.getTypedRuleContext(PseudocodeParser.AnnotationArgListContext,0)


        def GREATER_THAN(self):
            return self.getToken(PseudocodeParser.GREATER_THAN, 0)

        def getRuleIndex(self):
            return PseudocodeParser.RULE_annotation

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

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

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




    def annotation(self):

        localctx = PseudocodeParser.AnnotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_annotation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 242
            self.match(PseudocodeParser.AT)
            self.state = 243
            self.match(PseudocodeParser.ID)
            self.state = 244
            self.match(PseudocodeParser.LOW_THAN)
            self.state = 245
            self.annotationArgList()
            self.state = 246
            self.match(PseudocodeParser.GREATER_THAN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnnotationArgListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def annotationArg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.AnnotationArgContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.AnnotationArgContext,i)


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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_annotationArgList

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

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

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




    def annotationArgList(self):

        localctx = PseudocodeParser.AnnotationArgListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_annotationArgList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.annotationArg()
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==42:
                self.state = 249
                self.match(PseudocodeParser.COMMA)
                self.state = 250
                self.annotationArg()
                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class AnnotationArgContext(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(PseudocodeParser.ID, 0)

        def STRING(self):
            return self.getToken(PseudocodeParser.STRING, 0)

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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_annotationArg

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

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

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




    def annotationArg(self):

        localctx = PseudocodeParser.AnnotationArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_annotationArg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 256
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1703936) != 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 ForEachLoopContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def IN(self):
            return self.getToken(PseudocodeParser.IN, 0)

        def COLON(self):
            return self.getToken(PseudocodeParser.COLON, 0)

        def END(self):
            return self.getToken(PseudocodeParser.END, 0)

        def annotation(self):
            return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0)


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

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_forEachLoop

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

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

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




    def forEachLoop(self):

        localctx = PseudocodeParser.ForEachLoopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_forEachLoop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            self.match(PseudocodeParser.FOR)
            self.state = 260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44:
                self.state = 259
                self.annotation()


            self.state = 262
            self.match(PseudocodeParser.ID)
            self.state = 263
            self.match(PseudocodeParser.IN)
            self.state = 264
            self.match(PseudocodeParser.ID)
            self.state = 265
            self.match(PseudocodeParser.COLON)
            self.state = 267 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 266
                    self.match(PseudocodeParser.NL)

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

            self.state = 283
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0):
                self.state = 271
                self.statement()
                self.state = 280
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 273 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 272
                            self.match(PseudocodeParser.NL)
                            self.state = 275 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==45):
                                break

                        self.state = 277
                        self.statement() 
                    self.state = 282
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,35,self._ctx)



            self.state = 288
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==45:
                self.state = 285
                self.match(PseudocodeParser.NL)
                self.state = 290
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 291
            self.match(PseudocodeParser.END)
            self.state = 292
            self.match(PseudocodeParser.FOR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RegularForLoopContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)

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

        def EQ(self):
            return self.getToken(PseudocodeParser.EQ, 0)

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


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


        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)

        def COLON(self):
            return self.getToken(PseudocodeParser.COLON, 0)

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


        def END(self):
            return self.getToken(PseudocodeParser.END, 0)

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

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

        def annotation(self):
            return self.getTypedRuleContext(PseudocodeParser.AnnotationContext,0)


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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_regularForLoop

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

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

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




    def regularForLoop(self):

        localctx = PseudocodeParser.RegularForLoopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_regularForLoop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self.match(PseudocodeParser.FOR)
            self.state = 296
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==44:
                self.state = 295
                self.annotation()


            self.state = 298
            self.match(PseudocodeParser.LPAREN)
            self.state = 299
            self.match(PseudocodeParser.ID)
            self.state = 300
            self.match(PseudocodeParser.EQ)
            self.state = 301
            self.expression()
            self.state = 302
            _la = self._input.LA(1)
            if not(_la==42 or _la==43):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 303
            self.expression()
            self.state = 304
            _la = self._input.LA(1)
            if not(_la==42 or _la==43):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 305
            self.forUpdate()
            self.state = 306
            self.match(PseudocodeParser.RPAREN)
            self.state = 307
            self.match(PseudocodeParser.COLON)
            self.state = 309 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 308
                    self.match(PseudocodeParser.NL)

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

            self.state = 313
            self.block()
            self.state = 314
            self.match(PseudocodeParser.END)
            self.state = 315
            self.match(PseudocodeParser.FOR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForUpdateContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def PLUS_EQ(self):
            return self.getToken(PseudocodeParser.PLUS_EQ, 0)

        def MINUS_EQ(self):
            return self.getToken(PseudocodeParser.MINUS_EQ, 0)

        def STAR_EQ(self):
            return self.getToken(PseudocodeParser.STAR_EQ, 0)

        def SLASH_EQ(self):
            return self.getToken(PseudocodeParser.SLASH_EQ, 0)

        def getRuleIndex(self):
            return PseudocodeParser.RULE_forUpdate

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

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

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




    def forUpdate(self):

        localctx = PseudocodeParser.ForUpdateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_forUpdate)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.match(PseudocodeParser.ID)
            self.state = 318
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 45634027520) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 319
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.BlockContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.BlockContext,i)


        def END(self):
            return self.getToken(PseudocodeParser.END, 0)

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

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

        def getRuleIndex(self):
            return PseudocodeParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfStatement" ):
                return visitor.visitIfStatement(self)
            else:
                return visitor.visitChildren(self)




    def ifStatement(self):

        localctx = PseudocodeParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_ifStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 321
            self.match(PseudocodeParser.IF)
            self.state = 322
            self.match(PseudocodeParser.LPAREN)
            self.state = 323
            self.expression()
            self.state = 324
            self.match(PseudocodeParser.RPAREN)
            self.state = 325
            self.match(PseudocodeParser.COLON)
            self.state = 327 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 326
                    self.match(PseudocodeParser.NL)

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

            self.state = 331
            self.block()
            self.state = 347
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,42,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 332
                    self.match(PseudocodeParser.ELSE)
                    self.state = 333
                    self.match(PseudocodeParser.IF)
                    self.state = 334
                    self.match(PseudocodeParser.LPAREN)
                    self.state = 335
                    self.expression()
                    self.state = 336
                    self.match(PseudocodeParser.RPAREN)
                    self.state = 337
                    self.match(PseudocodeParser.COLON)
                    self.state = 339 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 338
                            self.match(PseudocodeParser.NL)

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

                    self.state = 343
                    self.block() 
                self.state = 349
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,42,self._ctx)

            self.state = 358
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 350
                self.match(PseudocodeParser.ELSE)
                self.state = 351
                self.match(PseudocodeParser.COLON)
                self.state = 353 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 352
                        self.match(PseudocodeParser.NL)

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

                self.state = 357
                self.block()


            self.state = 360
            self.match(PseudocodeParser.END)
            self.state = 361
            self.match(PseudocodeParser.IF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class WhileLoopContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)

        def COLON(self):
            return self.getToken(PseudocodeParser.COLON, 0)

        def END(self):
            return self.getToken(PseudocodeParser.END, 0)

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

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_whileLoop

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

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

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




    def whileLoop(self):

        localctx = PseudocodeParser.WhileLoopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_whileLoop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 363
            self.match(PseudocodeParser.WHILE)
            self.state = 364
            self.match(PseudocodeParser.LPAREN)
            self.state = 365
            self.expression()
            self.state = 366
            self.match(PseudocodeParser.RPAREN)
            self.state = 367
            self.match(PseudocodeParser.COLON)
            self.state = 369 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 368
                    self.match(PseudocodeParser.NL)

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

            self.state = 385
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0):
                self.state = 373
                self.statement()
                self.state = 382
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 375 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 374
                            self.match(PseudocodeParser.NL)
                            self.state = 377 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==45):
                                break

                        self.state = 379
                        self.statement() 
                    self.state = 384
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,47,self._ctx)



            self.state = 390
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==45:
                self.state = 387
                self.match(PseudocodeParser.NL)
                self.state = 392
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 393
            self.match(PseudocodeParser.END)
            self.state = 394
            self.match(PseudocodeParser.WHILE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RETURN(self):
            return self.getToken(PseudocodeParser.RETURN, 0)

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


        def getRuleIndex(self):
            return PseudocodeParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnStatement" ):
                return visitor.visitReturnStatement(self)
            else:
                return visitor.visitChildren(self)




    def returnStatement(self):

        localctx = PseudocodeParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_returnStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.match(PseudocodeParser.RETURN)
            self.state = 397
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BreakStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_breakStatement

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

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

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




    def breakStatement(self):

        localctx = PseudocodeParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_breakStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.match(PseudocodeParser.BREAK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_block

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

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

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




    def block(self):

        localctx = PseudocodeParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592186178904) != 0):
                self.state = 401
                self.statement()
                self.state = 410
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,51,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 403 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 402
                            self.match(PseudocodeParser.NL)
                            self.state = 405 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==45):
                                break

                        self.state = 407
                        self.statement() 
                    self.state = 412
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,51,self._ctx)



            self.state = 418
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==45:
                self.state = 415
                self.match(PseudocodeParser.NL)
                self.state = 420
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def logicalOrExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.LogicalOrExpressionContext,0)


        def getRuleIndex(self):
            return PseudocodeParser.RULE_expression

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

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

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




    def expression(self):

        localctx = PseudocodeParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 421
            self.logicalOrExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LogicalOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_logicalOrExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class OrExprContext(LogicalOrExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalOrExpressionContext
            super().__init__(parser)
            self.left = None # LogicalAndExpressionContext
            self.right = None # LogicalAndExpressionContext
            self.copyFrom(ctx)

        def logicalAndExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.LogicalAndExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.LogicalAndExpressionContext,i)

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

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

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

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


    class OrPassContext(LogicalOrExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalOrExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def logicalAndExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.LogicalAndExpressionContext,0)


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

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

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



    def logicalOrExpression(self):

        localctx = PseudocodeParser.LogicalOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_logicalOrExpression)
        self._la = 0 # Token type
        try:
            self.state = 431
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.OrExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 423
                localctx.left = self.logicalAndExpression()
                self.state = 426 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 424
                    self.match(PseudocodeParser.OR)
                    self.state = 425
                    localctx.right = self.logicalAndExpression()
                    self.state = 428 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==15):
                        break

                pass

            elif la_ == 2:
                localctx = PseudocodeParser.OrPassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 430
                self.logicalAndExpression()
                pass


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


    class LogicalAndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_logicalAndExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class AndExprContext(LogicalAndExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalAndExpressionContext
            super().__init__(parser)
            self.left = None # ComparisonExpressionContext
            self.right = None # ComparisonExpressionContext
            self.copyFrom(ctx)

        def comparisonExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.ComparisonExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.ComparisonExpressionContext,i)

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

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

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

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


    class AndPassContext(LogicalAndExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.LogicalAndExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def comparisonExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.ComparisonExpressionContext,0)


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

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

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



    def logicalAndExpression(self):

        localctx = PseudocodeParser.LogicalAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_logicalAndExpression)
        self._la = 0 # Token type
        try:
            self.state = 441
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.AndExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 433
                localctx.left = self.comparisonExpression()
                self.state = 436 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 434
                    self.match(PseudocodeParser.AND)
                    self.state = 435
                    localctx.right = self.comparisonExpression()
                    self.state = 438 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==14):
                        break

                pass

            elif la_ == 2:
                localctx = PseudocodeParser.AndPassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 440
                self.comparisonExpression()
                pass


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


    class ComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_comparisonExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class CompareExprContext(ComparisonExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ComparisonExpressionContext
            super().__init__(parser)
            self.left = None # AdditiveExpressionContext
            self.op = None # Token
            self.right = None # AdditiveExpressionContext
            self.copyFrom(ctx)

        def additiveExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.AdditiveExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.AdditiveExpressionContext,i)

        def EQEQ(self):
            return self.getToken(PseudocodeParser.EQEQ, 0)
        def LOW_THAN(self):
            return self.getToken(PseudocodeParser.LOW_THAN, 0)
        def GREATER_THAN(self):
            return self.getToken(PseudocodeParser.GREATER_THAN, 0)
        def LESS_EQ(self):
            return self.getToken(PseudocodeParser.LESS_EQ, 0)
        def GREATER_EQ(self):
            return self.getToken(PseudocodeParser.GREATER_EQ, 0)

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

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

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


    class ComparisonPassContext(ComparisonExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.ComparisonExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def additiveExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.AdditiveExpressionContext,0)


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

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

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



    def comparisonExpression(self):

        localctx = PseudocodeParser.ComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_comparisonExpression)
        self._la = 0 # Token type
        try:
            self.state = 448
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.CompareExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 443
                localctx.left = self.additiveExpression()
                self.state = 444
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 255852544) != 0)):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 445
                localctx.right = self.additiveExpression()
                pass

            elif la_ == 2:
                localctx = PseudocodeParser.ComparisonPassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 447
                self.additiveExpression()
                pass


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


    class AdditiveExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_additiveExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class AdditivePassContext(AdditiveExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.AdditiveExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def multiplicativeExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.MultiplicativeExpressionContext,0)


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

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

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


    class AddExprContext(AdditiveExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.AdditiveExpressionContext
            super().__init__(parser)
            self.left = None # MultiplicativeExpressionContext
            self.op = None # Token
            self.right = None # MultiplicativeExpressionContext
            self.copyFrom(ctx)

        def multiplicativeExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.MultiplicativeExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.MultiplicativeExpressionContext,i)

        def PLUS(self, i:int=None):
            if i is None:
                return self.getTokens(PseudocodeParser.PLUS)
            else:
                return self.getToken(PseudocodeParser.PLUS, i)
        def MINUS(self, i:int=None):
            if i is None:
                return self.getTokens(PseudocodeParser.MINUS)
            else:
                return self.getToken(PseudocodeParser.MINUS, i)

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

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

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



    def additiveExpression(self):

        localctx = PseudocodeParser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.state = 458
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.AddExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 450
                localctx.left = self.multiplicativeExpression()
                self.state = 453 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 451
                    localctx.op = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==32 or _la==34):
                        localctx.op = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 452
                    localctx.right = self.multiplicativeExpression()
                    self.state = 455 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==32 or _la==34):
                        break

                pass

            elif la_ == 2:
                localctx = PseudocodeParser.AdditivePassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 457
                self.multiplicativeExpression()
                pass


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


    class MultiplicativeExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_multiplicativeExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class MulExprContext(MultiplicativeExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.MultiplicativeExpressionContext
            super().__init__(parser)
            self.left = None # PowerExpressionContext
            self.op = None # Token
            self.right = None # PowerExpressionContext
            self.copyFrom(ctx)

        def powerExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.PowerExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.PowerExpressionContext,i)

        def STAR(self, i:int=None):
            if i is None:
                return self.getTokens(PseudocodeParser.STAR)
            else:
                return self.getToken(PseudocodeParser.STAR, i)
        def SLASH(self, i:int=None):
            if i is None:
                return self.getTokens(PseudocodeParser.SLASH)
            else:
                return self.getToken(PseudocodeParser.SLASH, i)

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

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

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


    class MultiplicativePassContext(MultiplicativeExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.MultiplicativeExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def powerExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.PowerExpressionContext,0)


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

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

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



    def multiplicativeExpression(self):

        localctx = PseudocodeParser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.state = 468
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.MulExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 460
                localctx.left = self.powerExpression()
                self.state = 463 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 461
                    localctx.op = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not(_la==30 or _la==36):
                        localctx.op = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 462
                    localctx.right = self.powerExpression()
                    self.state = 465 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==30 or _la==36):
                        break

                pass

            elif la_ == 2:
                localctx = PseudocodeParser.MultiplicativePassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 467
                self.powerExpression()
                pass


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


    class PowerExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_powerExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class PowerPassContext(PowerExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PowerExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

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


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

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

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


    class PowExprContext(PowerExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PowerExpressionContext
            super().__init__(parser)
            self.left = None # UnaryExpressionContext
            self.right = None # UnaryExpressionContext
            self.copyFrom(ctx)

        def unaryExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PseudocodeParser.UnaryExpressionContext)
            else:
                return self.getTypedRuleContext(PseudocodeParser.UnaryExpressionContext,i)

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

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

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

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



    def powerExpression(self):

        localctx = PseudocodeParser.PowerExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_powerExpression)
        self._la = 0 # Token type
        try:
            self.state = 478
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.PowExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 470
                localctx.left = self.unaryExpression()
                self.state = 473 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 471
                    self.match(PseudocodeParser.POW)
                    self.state = 472
                    localctx.right = self.unaryExpression()
                    self.state = 475 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==28):
                        break

                pass

            elif la_ == 2:
                localctx = PseudocodeParser.PowerPassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 477
                self.unaryExpression()
                pass


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


    class UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_unaryExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class UnaryPassContext(UnaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.UnaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

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


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

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

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


    class UnaryMinusExprContext(UnaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.UnaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def MINUS(self):
            return self.getToken(PseudocodeParser.MINUS, 0)
        def unaryExpression(self):
            return self.getTypedRuleContext(PseudocodeParser.UnaryExpressionContext,0)


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

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

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



    def unaryExpression(self):

        localctx = PseudocodeParser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_unaryExpression)
        try:
            self.state = 483
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [34]:
                localctx = PseudocodeParser.UnaryMinusExprContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 480
                self.match(PseudocodeParser.MINUS)
                self.state = 481
                self.unaryExpression()
                pass
            elif token in [12, 13, 16, 17, 18, 19, 20, 39]:
                localctx = PseudocodeParser.UnaryPassContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 482
                self.primaryExpression()
                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 PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PseudocodeParser.RULE_primaryExpression

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ParenExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)
        def expression(self):
            return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0)

        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)

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

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

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


    class AtomExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def atom(self):
            return self.getTypedRuleContext(PseudocodeParser.AtomContext,0)


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

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

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


    class ArrayAccessExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(PseudocodeParser.ID, 0)
        def LBRACK(self):
            return self.getToken(PseudocodeParser.LBRACK, 0)
        def expression(self):
            return self.getTypedRuleContext(PseudocodeParser.ExpressionContext,0)

        def RBRACK(self):
            return self.getToken(PseudocodeParser.RBRACK, 0)

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

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

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


    class FunctionCallExpressionContext(PrimaryExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PseudocodeParser.PrimaryExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(PseudocodeParser.ID, 0)
        def LPAREN(self):
            return self.getToken(PseudocodeParser.LPAREN, 0)
        def RPAREN(self):
            return self.getToken(PseudocodeParser.RPAREN, 0)
        def expressionList(self):
            return self.getTypedRuleContext(PseudocodeParser.ExpressionListContext,0)


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

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

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



    def primaryExpression(self):

        localctx = PseudocodeParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_primaryExpression)
        self._la = 0 # Token type
        try:
            self.state = 501
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                localctx = PseudocodeParser.ParenExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 485
                self.match(PseudocodeParser.LPAREN)
                self.state = 486
                self.expression()
                self.state = 487
                self.match(PseudocodeParser.RPAREN)
                pass

            elif la_ == 2:
                localctx = PseudocodeParser.FunctionCallExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 489
                self.match(PseudocodeParser.ID)
                self.state = 490
                self.match(PseudocodeParser.LPAREN)
                self.state = 492
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 566937726976) != 0):
                    self.state = 491
                    self.expressionList()


                self.state = 494
                self.match(PseudocodeParser.RPAREN)
                pass

            elif la_ == 3:
                localctx = PseudocodeParser.ArrayAccessExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 495
                self.match(PseudocodeParser.ID)
                self.state = 496
                self.match(PseudocodeParser.LBRACK)
                self.state = 497
                self.expression()
                self.state = 498
                self.match(PseudocodeParser.RBRACK)
                pass

            elif la_ == 4:
                localctx = PseudocodeParser.AtomExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 500
                self.atom()
                pass


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


    class ExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PseudocodeParser.RULE_expressionList

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

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

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




    def expressionList(self):

        localctx = PseudocodeParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 503
            self.expression()
            self.state = 508
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==42:
                self.state = 504
                self.match(PseudocodeParser.COMMA)
                self.state = 505
                self.expression()
                self.state = 510
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class AtomContext(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(PseudocodeParser.ID, 0)

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

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

        def TRUE(self):
            return self.getToken(PseudocodeParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(PseudocodeParser.FALSE, 0)

        def NULL(self):
            return self.getToken(PseudocodeParser.NULL, 0)

        def STRING(self):
            return self.getToken(PseudocodeParser.STRING, 0)

        def getRuleIndex(self):
            return PseudocodeParser.RULE_atom

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

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

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




    def atom(self):

        localctx = PseudocodeParser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_atom)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2043904) != 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