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

class McCompParser ( Parser ):

    grammarFileName = "McComp.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'0'", "'>>'", "'<<'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'string'", "'vector'", "'symbol'", "<INVALID>", 
                     "'%include'", "'NULL'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'asm'", "'auto'", "'_Bool'", "'break'", 
                     "'case'", "'char'", "'_Complex'", "'const'", "'continue'", 
                     "'default'", "'do'", "'double'", "'else'", "'enum'", 
                     "'extern'", "'false'", "'float'", "'for'", "'goto'", 
                     "'if'", "'_Imaginary'", "'inline'", "'int'", "'long'", 
                     "'register'", "'return'", "'short'", "'signed'", "'sizeof'", 
                     "'static'", "'struct'", "'switch'", "'true'", "'typedef'", 
                     "'union'", "'unsigned'", "'void'", "'volatile'", "'while'", 
                     "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", "'-'", 
                     "'*'", "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", "<INVALID>", 
                     "'='", "'<'", "'>'", "'+='", "'-='", "'*='", "'/='", 
                     "'%='", "'^='", "'&='", "'|='", "'<<='", "'>>='", "'=='", 
                     "'!='", "'<='", "'>='", "<INVALID>", "<INVALID>", "'++'", 
                     "'--'", "','", "'->*'", "'->'", "'?'", "':'", "'::'", 
                     "';'", "'.'", "'.*'", "'...'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "Absolute", "At", "Category", "Component", "UserVars", 
                      "Define", "Declare", "Definition", "End", "McDisplay", 
                      "Finally", "Initialize", "Instrument", "Output", "Private", 
                      "Parameters", "Relative", "Rotated", "Previous", "Setting", 
                      "Trace", "Share", "Extend", "Group", "Save", "Jump", 
                      "When", "Next", "Iterate", "Myself", "Copy", "Split", 
                      "Removable", "Cpu", "NoAcc", "Dependency", "Shell", 
                      "Search", "MetaData", "String", "Vector", "Symbol", 
                      "UnparsedBlock", "Include", "Null", "IntegerLiteral", 
                      "CharacterLiteral", "FloatingLiteral", "StringLiteral", 
                      "BooleanLitteral", "UserDefinedLiteral", "MultiLineMacro", 
                      "Directive", "Asm", "Auto", "Bool", "Break", "Case", 
                      "Char", "Complex", "Const", "Continue", "Default", 
                      "Do", "Double", "Else", "Enum", "Extern", "False_", 
                      "Float", "For", "Goto", "If", "Imaginary", "Inline", 
                      "Int", "Long", "Register", "Return", "Short", "Signed", 
                      "Sizeof", "Static", "Struct", "Switch", "True_", "Typedef", 
                      "Union", "Unsigned", "Void", "Volatile", "While", 
                      "LeftParen", "RightParen", "LeftBracket", "RightBracket", 
                      "LeftBrace", "RightBrace", "Plus", "Minus", "Star", 
                      "Div", "Mod", "Caret", "And", "Or", "Tilde", "Not", 
                      "Assign", "Less", "Greater", "PlusAssign", "MinusAssign", 
                      "StarAssign", "DivAssign", "ModAssign", "XorAssign", 
                      "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", 
                      "Equal", "NotEqual", "LessEqual", "GreaterEqual", 
                      "AndAnd", "OrOr", "PlusPlus", "MinusMinus", "Comma", 
                      "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", 
                      "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", 
                      "DecimalLiteral", "OctalLiteral", "HexadecimalLiteral", 
                      "BinaryLiteral", "IntegerSuffix", "UserDefinedIntegerLiteral", 
                      "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", 
                      "UserDefinedCharacterLiteral", "Whitespace", "Newline", 
                      "BlockComment", "LineComment" ]

    RULE_prog = 0
    RULE_component_definition = 1
    RULE_component_trace = 2
    RULE_component_parameter_set = 3
    RULE_component_define_parameters = 4
    RULE_component_set_parameters = 5
    RULE_component_out_parameters = 6
    RULE_component_parameters = 7
    RULE_component_parameter = 8
    RULE_share = 9
    RULE_display = 10
    RULE_component_ref = 11
    RULE_coords = 12
    RULE_reference = 13
    RULE_dependency = 14
    RULE_declare = 15
    RULE_uservars = 16
    RULE_initialise = 17
    RULE_save = 18
    RULE_finally_ = 19
    RULE_metadata = 20
    RULE_category = 21
    RULE_initializerlist = 22
    RULE_assignment = 23
    RULE_expr = 24
    RULE_shell = 25
    RULE_search = 26
    RULE_unparsed_block = 27

    ruleNames =  [ "prog", "component_definition", "component_trace", "component_parameter_set", 
                   "component_define_parameters", "component_set_parameters", 
                   "component_out_parameters", "component_parameters", "component_parameter", 
                   "share", "display", "component_ref", "coords", "reference", 
                   "dependency", "declare", "uservars", "initialise", "save", 
                   "finally_", "metadata", "category", "initializerlist", 
                   "assignment", "expr", "shell", "search", "unparsed_block" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    Absolute=4
    At=5
    Category=6
    Component=7
    UserVars=8
    Define=9
    Declare=10
    Definition=11
    End=12
    McDisplay=13
    Finally=14
    Initialize=15
    Instrument=16
    Output=17
    Private=18
    Parameters=19
    Relative=20
    Rotated=21
    Previous=22
    Setting=23
    Trace=24
    Share=25
    Extend=26
    Group=27
    Save=28
    Jump=29
    When=30
    Next=31
    Iterate=32
    Myself=33
    Copy=34
    Split=35
    Removable=36
    Cpu=37
    NoAcc=38
    Dependency=39
    Shell=40
    Search=41
    MetaData=42
    String=43
    Vector=44
    Symbol=45
    UnparsedBlock=46
    Include=47
    Null=48
    IntegerLiteral=49
    CharacterLiteral=50
    FloatingLiteral=51
    StringLiteral=52
    BooleanLitteral=53
    UserDefinedLiteral=54
    MultiLineMacro=55
    Directive=56
    Asm=57
    Auto=58
    Bool=59
    Break=60
    Case=61
    Char=62
    Complex=63
    Const=64
    Continue=65
    Default=66
    Do=67
    Double=68
    Else=69
    Enum=70
    Extern=71
    False_=72
    Float=73
    For=74
    Goto=75
    If=76
    Imaginary=77
    Inline=78
    Int=79
    Long=80
    Register=81
    Return=82
    Short=83
    Signed=84
    Sizeof=85
    Static=86
    Struct=87
    Switch=88
    True_=89
    Typedef=90
    Union=91
    Unsigned=92
    Void=93
    Volatile=94
    While=95
    LeftParen=96
    RightParen=97
    LeftBracket=98
    RightBracket=99
    LeftBrace=100
    RightBrace=101
    Plus=102
    Minus=103
    Star=104
    Div=105
    Mod=106
    Caret=107
    And=108
    Or=109
    Tilde=110
    Not=111
    Assign=112
    Less=113
    Greater=114
    PlusAssign=115
    MinusAssign=116
    StarAssign=117
    DivAssign=118
    ModAssign=119
    XorAssign=120
    AndAssign=121
    OrAssign=122
    LeftShiftAssign=123
    RightShiftAssign=124
    Equal=125
    NotEqual=126
    LessEqual=127
    GreaterEqual=128
    AndAnd=129
    OrOr=130
    PlusPlus=131
    MinusMinus=132
    Comma=133
    ArrowStar=134
    Arrow=135
    Question=136
    Colon=137
    Doublecolon=138
    Semi=139
    Dot=140
    DotStar=141
    Ellipsis=142
    Identifier=143
    DecimalLiteral=144
    OctalLiteral=145
    HexadecimalLiteral=146
    BinaryLiteral=147
    IntegerSuffix=148
    UserDefinedIntegerLiteral=149
    UserDefinedFloatingLiteral=150
    UserDefinedStringLiteral=151
    UserDefinedCharacterLiteral=152
    Whitespace=153
    Newline=154
    BlockComment=155
    LineComment=156

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

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

        def component_definition(self):
            return self.getTypedRuleContext(McCompParser.Component_definitionContext,0)


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

        def getRuleIndex(self):
            return McCompParser.RULE_prog

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




    def prog(self):

        localctx = McCompParser.ProgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_prog)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 56
            self.component_definition()
            self.state = 57
            self.match(McCompParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_component_definition

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



    class ComponentDefineNewContext(Component_definitionContext):

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

        def Define(self):
            return self.getToken(McCompParser.Define, 0)
        def Component(self):
            return self.getToken(McCompParser.Component, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def component_parameter_set(self):
            return self.getTypedRuleContext(McCompParser.Component_parameter_setContext,0)

        def End(self):
            return self.getToken(McCompParser.End, 0)
        def category(self):
            return self.getTypedRuleContext(McCompParser.CategoryContext,0)

        def metadata(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.MetadataContext)
            else:
                return self.getTypedRuleContext(McCompParser.MetadataContext,i)

        def shell(self):
            return self.getTypedRuleContext(McCompParser.ShellContext,0)

        def dependency(self):
            return self.getTypedRuleContext(McCompParser.DependencyContext,0)

        def NoAcc(self):
            return self.getToken(McCompParser.NoAcc, 0)
        def share(self):
            return self.getTypedRuleContext(McCompParser.ShareContext,0)

        def uservars(self):
            return self.getTypedRuleContext(McCompParser.UservarsContext,0)

        def declare(self):
            return self.getTypedRuleContext(McCompParser.DeclareContext,0)

        def initialise(self):
            return self.getTypedRuleContext(McCompParser.InitialiseContext,0)

        def component_trace(self):
            return self.getTypedRuleContext(McCompParser.Component_traceContext,0)

        def save(self):
            return self.getTypedRuleContext(McCompParser.SaveContext,0)

        def finally_(self):
            return self.getTypedRuleContext(McCompParser.Finally_Context,0)

        def display(self):
            return self.getTypedRuleContext(McCompParser.DisplayContext,0)


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


    class ComponentDefineCopyContext(Component_definitionContext):

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

        def Define(self):
            return self.getToken(McCompParser.Define, 0)
        def Component(self):
            return self.getToken(McCompParser.Component, 0)
        def Identifier(self, i:int=None):
            if i is None:
                return self.getTokens(McCompParser.Identifier)
            else:
                return self.getToken(McCompParser.Identifier, i)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def component_parameter_set(self):
            return self.getTypedRuleContext(McCompParser.Component_parameter_setContext,0)

        def End(self):
            return self.getToken(McCompParser.End, 0)
        def category(self):
            return self.getTypedRuleContext(McCompParser.CategoryContext,0)

        def metadata(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.MetadataContext)
            else:
                return self.getTypedRuleContext(McCompParser.MetadataContext,i)

        def shell(self):
            return self.getTypedRuleContext(McCompParser.ShellContext,0)

        def dependency(self):
            return self.getTypedRuleContext(McCompParser.DependencyContext,0)

        def NoAcc(self):
            return self.getToken(McCompParser.NoAcc, 0)
        def share(self):
            return self.getTypedRuleContext(McCompParser.ShareContext,0)

        def uservars(self):
            return self.getTypedRuleContext(McCompParser.UservarsContext,0)

        def declare(self):
            return self.getTypedRuleContext(McCompParser.DeclareContext,0)

        def initialise(self):
            return self.getTypedRuleContext(McCompParser.InitialiseContext,0)

        def component_trace(self):
            return self.getTypedRuleContext(McCompParser.Component_traceContext,0)

        def save(self):
            return self.getTypedRuleContext(McCompParser.SaveContext,0)

        def finally_(self):
            return self.getTypedRuleContext(McCompParser.Finally_Context,0)

        def display(self):
            return self.getTypedRuleContext(McCompParser.DisplayContext,0)


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



    def component_definition(self):

        localctx = McCompParser.Component_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_component_definition)
        self._la = 0 # Token type
        try:
            self.state = 157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                localctx = McCompParser.ComponentDefineNewContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 59
                self.match(McCompParser.Define)
                self.state = 60
                self.match(McCompParser.Component)
                self.state = 61
                self.match(McCompParser.Identifier)
                self.state = 62
                self.component_parameter_set()
                self.state = 64
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==6:
                    self.state = 63
                    self.category()


                self.state = 69
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==42:
                    self.state = 66
                    self.metadata()
                    self.state = 71
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 73
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==40:
                    self.state = 72
                    self.shell()


                self.state = 76
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==39:
                    self.state = 75
                    self.dependency()


                self.state = 79
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==38:
                    self.state = 78
                    self.match(McCompParser.NoAcc)


                self.state = 82
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==25:
                    self.state = 81
                    self.share()


                self.state = 85
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 84
                    self.uservars()


                self.state = 88
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10:
                    self.state = 87
                    self.declare()


                self.state = 91
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==15:
                    self.state = 90
                    self.initialise()


                self.state = 94
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==24:
                    self.state = 93
                    self.component_trace()


                self.state = 97
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==28:
                    self.state = 96
                    self.save()


                self.state = 100
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==14:
                    self.state = 99
                    self.finally_()


                self.state = 103
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==13:
                    self.state = 102
                    self.display()


                self.state = 105
                self.match(McCompParser.End)
                pass

            elif la_ == 2:
                localctx = McCompParser.ComponentDefineCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 107
                self.match(McCompParser.Define)
                self.state = 108
                self.match(McCompParser.Component)
                self.state = 109
                self.match(McCompParser.Identifier)
                self.state = 110
                self.match(McCompParser.Copy)
                self.state = 111
                self.match(McCompParser.Identifier)
                self.state = 112
                self.component_parameter_set()
                self.state = 114
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==6:
                    self.state = 113
                    self.category()


                self.state = 119
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==42:
                    self.state = 116
                    self.metadata()
                    self.state = 121
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 123
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==40:
                    self.state = 122
                    self.shell()


                self.state = 126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==39:
                    self.state = 125
                    self.dependency()


                self.state = 129
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==38:
                    self.state = 128
                    self.match(McCompParser.NoAcc)


                self.state = 132
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==25:
                    self.state = 131
                    self.share()


                self.state = 135
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 134
                    self.uservars()


                self.state = 138
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==10:
                    self.state = 137
                    self.declare()


                self.state = 141
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==15:
                    self.state = 140
                    self.initialise()


                self.state = 144
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==24:
                    self.state = 143
                    self.component_trace()


                self.state = 147
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==28:
                    self.state = 146
                    self.save()


                self.state = 150
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==14:
                    self.state = 149
                    self.finally_()


                self.state = 153
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==13:
                    self.state = 152
                    self.display()


                self.state = 155
                self.match(McCompParser.End)
                pass


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


    class Component_traceContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_component_trace

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



    class TraceBlockContext(Component_traceContext):

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

        def Trace(self):
            return self.getToken(McCompParser.Trace, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class TraceBlockCopyContext(Component_traceContext):

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

        def Trace(self):
            return self.getToken(McCompParser.Trace, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def component_trace(self):

        localctx = McCompParser.Component_traceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_component_trace)
        self._la = 0 # Token type
        try:
            self.state = 168
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                localctx = McCompParser.TraceBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 159
                self.match(McCompParser.Trace)
                self.state = 160
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.TraceBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 161
                self.match(McCompParser.Trace)
                self.state = 162
                self.match(McCompParser.Copy)
                self.state = 163
                self.match(McCompParser.Identifier)
                self.state = 166
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 164
                    self.match(McCompParser.Extend)
                    self.state = 165
                    self.unparsed_block()


                pass


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


    class Component_parameter_setContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def component_define_parameters(self):
            return self.getTypedRuleContext(McCompParser.Component_define_parametersContext,0)


        def component_set_parameters(self):
            return self.getTypedRuleContext(McCompParser.Component_set_parametersContext,0)


        def component_out_parameters(self):
            return self.getTypedRuleContext(McCompParser.Component_out_parametersContext,0)


        def getRuleIndex(self):
            return McCompParser.RULE_component_parameter_set

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




    def component_parameter_set(self):

        localctx = McCompParser.Component_parameter_setContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_component_parameter_set)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 171
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11:
                self.state = 170
                self.component_define_parameters()


            self.state = 174
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==23:
                self.state = 173
                self.component_set_parameters()


            self.state = 177
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==17 or _la==18:
                self.state = 176
                self.component_out_parameters()


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


    class Component_define_parametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Definition(self):
            return self.getToken(McCompParser.Definition, 0)

        def Parameters(self):
            return self.getToken(McCompParser.Parameters, 0)

        def component_parameters(self):
            return self.getTypedRuleContext(McCompParser.Component_parametersContext,0)


        def getRuleIndex(self):
            return McCompParser.RULE_component_define_parameters

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




    def component_define_parameters(self):

        localctx = McCompParser.Component_define_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_component_define_parameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179
            self.match(McCompParser.Definition)
            self.state = 180
            self.match(McCompParser.Parameters)
            self.state = 181
            self.component_parameters()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_set_parametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Setting(self):
            return self.getToken(McCompParser.Setting, 0)

        def Parameters(self):
            return self.getToken(McCompParser.Parameters, 0)

        def component_parameters(self):
            return self.getTypedRuleContext(McCompParser.Component_parametersContext,0)


        def getRuleIndex(self):
            return McCompParser.RULE_component_set_parameters

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




    def component_set_parameters(self):

        localctx = McCompParser.Component_set_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_component_set_parameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 183
            self.match(McCompParser.Setting)
            self.state = 184
            self.match(McCompParser.Parameters)
            self.state = 185
            self.component_parameters()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_out_parametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Parameters(self):
            return self.getToken(McCompParser.Parameters, 0)

        def component_parameters(self):
            return self.getTypedRuleContext(McCompParser.Component_parametersContext,0)


        def Output(self):
            return self.getToken(McCompParser.Output, 0)

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

        def getRuleIndex(self):
            return McCompParser.RULE_component_out_parameters

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




    def component_out_parameters(self):

        localctx = McCompParser.Component_out_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_component_out_parameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 187
            _la = self._input.LA(1)
            if not(_la==17 or _la==18):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 188
            self.match(McCompParser.Parameters)
            self.state = 189
            self.component_parameters()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_parametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LeftParen(self):
            return self.getToken(McCompParser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(McCompParser.RightParen, 0)

        def component_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.Component_parameterContext)
            else:
                return self.getTypedRuleContext(McCompParser.Component_parameterContext,i)


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

        def getRuleIndex(self):
            return McCompParser.RULE_component_parameters

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




    def component_parameters(self):

        localctx = McCompParser.Component_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_component_parameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 191
            self.match(McCompParser.LeftParen)
            self.state = 200
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 43)) & ~0x3f) == 0 and ((1 << (_la - 43)) & 68753555463) != 0) or _la==143:
                self.state = 192
                self.component_parameter()
                self.state = 197
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==133:
                    self.state = 193
                    self.match(McCompParser.Comma)
                    self.state = 194
                    self.component_parameter()
                    self.state = 199
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 202
            self.match(McCompParser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Component_parameterContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_component_parameter

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



    class ComponentParameterSymbolContext(Component_parameterContext):

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

        def Symbol(self):
            return self.getToken(McCompParser.Symbol, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)


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


    class ComponentParameterDoubleArrayContext(Component_parameterContext):

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

        def Double(self):
            return self.getToken(McCompParser.Double, 0)
        def Star(self):
            return self.getToken(McCompParser.Star, 0)
        def Identifier(self, i:int=None):
            if i is None:
                return self.getTokens(McCompParser.Identifier)
            else:
                return self.getToken(McCompParser.Identifier, i)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def initializerlist(self):
            return self.getTypedRuleContext(McCompParser.InitializerlistContext,0)

        def Null(self):
            return self.getToken(McCompParser.Null, 0)

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


    class ComponentParameterDoubleContext(Component_parameterContext):

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

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Double(self):
            return self.getToken(McCompParser.Double, 0)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)


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


    class ComponentParameterVectorContext(Component_parameterContext):

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

        def Vector(self):
            return self.getToken(McCompParser.Vector, 0)
        def Identifier(self, i:int=None):
            if i is None:
                return self.getTokens(McCompParser.Identifier)
            else:
                return self.getToken(McCompParser.Identifier, i)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def initializerlist(self):
            return self.getTypedRuleContext(McCompParser.InitializerlistContext,0)

        def Null(self):
            return self.getToken(McCompParser.Null, 0)

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


    class ComponentParameterIntegerContext(Component_parameterContext):

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

        def Int(self):
            return self.getToken(McCompParser.Int, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)


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


    class ComponentParameterIntegerArrayContext(Component_parameterContext):

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

        def Int(self):
            return self.getToken(McCompParser.Int, 0)
        def Star(self):
            return self.getToken(McCompParser.Star, 0)
        def Identifier(self, i:int=None):
            if i is None:
                return self.getTokens(McCompParser.Identifier)
            else:
                return self.getToken(McCompParser.Identifier, i)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def initializerlist(self):
            return self.getTypedRuleContext(McCompParser.InitializerlistContext,0)

        def Null(self):
            return self.getToken(McCompParser.Null, 0)

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


    class ComponentParameterStringContext(Component_parameterContext):

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

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def String(self):
            return self.getToken(McCompParser.String, 0)
        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)
        def Char(self):
            return self.getToken(McCompParser.Char, 0)
        def Star(self):
            return self.getToken(McCompParser.Star, 0)
        def StringLiteral(self):
            return self.getToken(McCompParser.StringLiteral, 0)
        def Null(self):
            return self.getToken(McCompParser.Null, 0)

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



    def component_parameter(self):

        localctx = McCompParser.Component_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_component_parameter)
        self._la = 0 # Token type
        try:
            self.state = 273
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                localctx = McCompParser.ComponentParameterDoubleContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 205
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 204
                    self.match(McCompParser.Double)


                self.state = 207
                self.match(McCompParser.Identifier)
                self.state = 213
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==112:
                    self.state = 208
                    self.match(McCompParser.Assign)
                    self.state = 211
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                    if la_ == 1:
                        self.state = 209
                        self.expr(0)
                        pass

                    elif la_ == 2:
                        self.state = 210
                        self.match(McCompParser.T__0)
                        pass




                pass

            elif la_ == 2:
                localctx = McCompParser.ComponentParameterIntegerContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 215
                self.match(McCompParser.Int)
                self.state = 216
                self.match(McCompParser.Identifier)
                self.state = 222
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==112:
                    self.state = 217
                    self.match(McCompParser.Assign)
                    self.state = 220
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                    if la_ == 1:
                        self.state = 218
                        self.expr(0)
                        pass

                    elif la_ == 2:
                        self.state = 219
                        self.match(McCompParser.T__0)
                        pass




                pass

            elif la_ == 3:
                localctx = McCompParser.ComponentParameterStringContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 227
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [43]:
                    self.state = 224
                    self.match(McCompParser.String)
                    pass
                elif token in [62]:
                    self.state = 225
                    self.match(McCompParser.Char)
                    self.state = 226
                    self.match(McCompParser.Star)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 229
                self.match(McCompParser.Identifier)
                self.state = 232
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==112:
                    self.state = 230
                    self.match(McCompParser.Assign)
                    self.state = 231
                    _la = self._input.LA(1)
                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 4785074604081154) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass

            elif la_ == 4:
                localctx = McCompParser.ComponentParameterVectorContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 234
                self.match(McCompParser.Vector)
                self.state = 235
                self.match(McCompParser.Identifier)
                self.state = 243
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==112:
                    self.state = 236
                    self.match(McCompParser.Assign)
                    self.state = 241
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [143]:
                        self.state = 237
                        self.match(McCompParser.Identifier)
                        pass
                    elif token in [100]:
                        self.state = 238
                        self.initializerlist()
                        pass
                    elif token in [48]:
                        self.state = 239
                        self.match(McCompParser.Null)
                        pass
                    elif token in [1]:
                        self.state = 240
                        self.match(McCompParser.T__0)
                        pass
                    else:
                        raise NoViableAltException(self)



                pass

            elif la_ == 5:
                localctx = McCompParser.ComponentParameterSymbolContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 245
                self.match(McCompParser.Symbol)
                self.state = 246
                self.match(McCompParser.Identifier)

                self.state = 247
                self.match(McCompParser.Assign)
                self.state = 248
                self.expr(0)
                pass

            elif la_ == 6:
                localctx = McCompParser.ComponentParameterDoubleArrayContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 249
                self.match(McCompParser.Double)
                self.state = 250
                self.match(McCompParser.Star)
                self.state = 251
                self.match(McCompParser.Identifier)
                self.state = 259
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==112:
                    self.state = 252
                    self.match(McCompParser.Assign)
                    self.state = 257
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [143]:
                        self.state = 253
                        self.match(McCompParser.Identifier)
                        pass
                    elif token in [100]:
                        self.state = 254
                        self.initializerlist()
                        pass
                    elif token in [48]:
                        self.state = 255
                        self.match(McCompParser.Null)
                        pass
                    elif token in [1]:
                        self.state = 256
                        self.match(McCompParser.T__0)
                        pass
                    else:
                        raise NoViableAltException(self)



                pass

            elif la_ == 7:
                localctx = McCompParser.ComponentParameterIntegerArrayContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 261
                self.match(McCompParser.Int)
                self.state = 262
                self.match(McCompParser.Star)
                self.state = 263
                self.match(McCompParser.Identifier)
                self.state = 271
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==112:
                    self.state = 264
                    self.match(McCompParser.Assign)
                    self.state = 269
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [143]:
                        self.state = 265
                        self.match(McCompParser.Identifier)
                        pass
                    elif token in [100]:
                        self.state = 266
                        self.initializerlist()
                        pass
                    elif token in [48]:
                        self.state = 267
                        self.match(McCompParser.Null)
                        pass
                    elif token in [1]:
                        self.state = 268
                        self.match(McCompParser.T__0)
                        pass
                    else:
                        raise NoViableAltException(self)



                pass


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


    class ShareContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_share

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



    class ShareBlockContext(ShareContext):

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

        def Share(self):
            return self.getToken(McCompParser.Share, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class ShareBlockCopyContext(ShareContext):

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

        def Share(self):
            return self.getToken(McCompParser.Share, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def share(self):

        localctx = McCompParser.ShareContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_share)
        self._la = 0 # Token type
        try:
            self.state = 284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                localctx = McCompParser.ShareBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 275
                self.match(McCompParser.Share)
                self.state = 276
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.ShareBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 277
                self.match(McCompParser.Share)
                self.state = 278
                self.match(McCompParser.Copy)
                self.state = 279
                self.match(McCompParser.Identifier)
                self.state = 282
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 280
                    self.match(McCompParser.Extend)
                    self.state = 281
                    self.unparsed_block()


                pass


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


    class DisplayContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_display

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



    class DisplayBlockCopyContext(DisplayContext):

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

        def McDisplay(self):
            return self.getToken(McCompParser.McDisplay, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class DisplayBlockContext(DisplayContext):

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

        def McDisplay(self):
            return self.getToken(McCompParser.McDisplay, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def display(self):

        localctx = McCompParser.DisplayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_display)
        self._la = 0 # Token type
        try:
            self.state = 295
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
            if la_ == 1:
                localctx = McCompParser.DisplayBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 286
                self.match(McCompParser.McDisplay)
                self.state = 287
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.DisplayBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 288
                self.match(McCompParser.McDisplay)
                self.state = 289
                self.match(McCompParser.Copy)
                self.state = 290
                self.match(McCompParser.Identifier)
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 291
                    self.match(McCompParser.Extend)
                    self.state = 292
                    self.unparsed_block()


                pass


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


    class Component_refContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Previous(self):
            return self.getToken(McCompParser.Previous, 0)

        def LeftParen(self):
            return self.getToken(McCompParser.LeftParen, 0)

        def IntegerLiteral(self):
            return self.getToken(McCompParser.IntegerLiteral, 0)

        def RightParen(self):
            return self.getToken(McCompParser.RightParen, 0)

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)

        def getRuleIndex(self):
            return McCompParser.RULE_component_ref

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




    def component_ref(self):

        localctx = McCompParser.Component_refContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_component_ref)
        self._la = 0 # Token type
        try:
            self.state = 304
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 297
                self.match(McCompParser.Previous)
                self.state = 301
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==96:
                    self.state = 298
                    self.match(McCompParser.LeftParen)
                    self.state = 299
                    self.match(McCompParser.IntegerLiteral)
                    self.state = 300
                    self.match(McCompParser.RightParen)


                pass
            elif token in [143]:
                self.enterOuterAlt(localctx, 2)
                self.state = 303
                self.match(McCompParser.Identifier)
                pass
            else:
                raise NoViableAltException(self)

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


    class CoordsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LeftParen(self):
            return self.getToken(McCompParser.LeftParen, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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

        def RightParen(self):
            return self.getToken(McCompParser.RightParen, 0)

        def getRuleIndex(self):
            return McCompParser.RULE_coords

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




    def coords(self):

        localctx = McCompParser.CoordsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_coords)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 306
            self.match(McCompParser.LeftParen)
            self.state = 307
            self.expr(0)
            self.state = 308
            self.match(McCompParser.Comma)
            self.state = 309
            self.expr(0)
            self.state = 310
            self.match(McCompParser.Comma)
            self.state = 311
            self.expr(0)
            self.state = 312
            self.match(McCompParser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReferenceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Absolute(self):
            return self.getToken(McCompParser.Absolute, 0)

        def Relative(self):
            return self.getToken(McCompParser.Relative, 0)

        def component_ref(self):
            return self.getTypedRuleContext(McCompParser.Component_refContext,0)


        def getRuleIndex(self):
            return McCompParser.RULE_reference

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




    def reference(self):

        localctx = McCompParser.ReferenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_reference)
        try:
            self.state = 320
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 314
                self.match(McCompParser.Absolute)
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 2)
                self.state = 315
                self.match(McCompParser.Relative)
                self.state = 318
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [4]:
                    self.state = 316
                    self.match(McCompParser.Absolute)
                    pass
                elif token in [22, 143]:
                    self.state = 317
                    self.component_ref()
                    pass
                else:
                    raise NoViableAltException(self)

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

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

        def Dependency(self):
            return self.getToken(McCompParser.Dependency, 0)

        def StringLiteral(self):
            return self.getToken(McCompParser.StringLiteral, 0)

        def getRuleIndex(self):
            return McCompParser.RULE_dependency

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




    def dependency(self):

        localctx = McCompParser.DependencyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_dependency)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 322
            self.match(McCompParser.Dependency)
            self.state = 323
            self.match(McCompParser.StringLiteral)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclareContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_declare

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



    class DeclareBlockContext(DeclareContext):

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

        def Declare(self):
            return self.getToken(McCompParser.Declare, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class DeclareBlockCopyContext(DeclareContext):

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

        def Declare(self):
            return self.getToken(McCompParser.Declare, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def declare(self):

        localctx = McCompParser.DeclareContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_declare)
        self._la = 0 # Token type
        try:
            self.state = 334
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                localctx = McCompParser.DeclareBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 325
                self.match(McCompParser.Declare)
                self.state = 326
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.DeclareBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 327
                self.match(McCompParser.Declare)
                self.state = 328
                self.match(McCompParser.Copy)
                self.state = 329
                self.match(McCompParser.Identifier)
                self.state = 332
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 330
                    self.match(McCompParser.Extend)
                    self.state = 331
                    self.unparsed_block()


                pass


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


    class UservarsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UserVars(self):
            return self.getToken(McCompParser.UserVars, 0)

        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


        def getRuleIndex(self):
            return McCompParser.RULE_uservars

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




    def uservars(self):

        localctx = McCompParser.UservarsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_uservars)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self.match(McCompParser.UserVars)
            self.state = 337
            self.unparsed_block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitialiseContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_initialise

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



    class InitializeBlockContext(InitialiseContext):

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

        def Initialize(self):
            return self.getToken(McCompParser.Initialize, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class InitializeBlockCopyContext(InitialiseContext):

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

        def Initialize(self):
            return self.getToken(McCompParser.Initialize, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def initialise(self):

        localctx = McCompParser.InitialiseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_initialise)
        self._la = 0 # Token type
        try:
            self.state = 348
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                localctx = McCompParser.InitializeBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 339
                self.match(McCompParser.Initialize)
                self.state = 340
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.InitializeBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 341
                self.match(McCompParser.Initialize)
                self.state = 342
                self.match(McCompParser.Copy)
                self.state = 343
                self.match(McCompParser.Identifier)
                self.state = 346
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 344
                    self.match(McCompParser.Extend)
                    self.state = 345
                    self.unparsed_block()


                pass


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


    class SaveContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_save

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



    class SaveBlockCopyContext(SaveContext):

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

        def Save(self):
            return self.getToken(McCompParser.Save, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class SaveBlockContext(SaveContext):

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

        def Save(self):
            return self.getToken(McCompParser.Save, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def save(self):

        localctx = McCompParser.SaveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_save)
        self._la = 0 # Token type
        try:
            self.state = 359
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
            if la_ == 1:
                localctx = McCompParser.SaveBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 350
                self.match(McCompParser.Save)
                self.state = 351
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.SaveBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 352
                self.match(McCompParser.Save)
                self.state = 353
                self.match(McCompParser.Copy)
                self.state = 354
                self.match(McCompParser.Identifier)
                self.state = 357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 355
                    self.match(McCompParser.Extend)
                    self.state = 356
                    self.unparsed_block()


                pass


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


    class Finally_Context(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_finally_

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



    class FinallyBlockContext(Finally_Context):

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

        def Finally(self):
            return self.getToken(McCompParser.Finally, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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


    class FinallyBlockCopyContext(Finally_Context):

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

        def Finally(self):
            return self.getToken(McCompParser.Finally, 0)
        def Copy(self):
            return self.getToken(McCompParser.Copy, 0)
        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Extend(self):
            return self.getToken(McCompParser.Extend, 0)
        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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



    def finally_(self):

        localctx = McCompParser.Finally_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_finally_)
        self._la = 0 # Token type
        try:
            self.state = 370
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                localctx = McCompParser.FinallyBlockContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 361
                self.match(McCompParser.Finally)
                self.state = 362
                self.unparsed_block()
                pass

            elif la_ == 2:
                localctx = McCompParser.FinallyBlockCopyContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 363
                self.match(McCompParser.Finally)
                self.state = 364
                self.match(McCompParser.Copy)
                self.state = 365
                self.match(McCompParser.Identifier)
                self.state = 368
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 366
                    self.match(McCompParser.Extend)
                    self.state = 367
                    self.unparsed_block()


                pass


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


    class MetadataContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MetaData(self):
            return self.getToken(McCompParser.MetaData, 0)

        def unparsed_block(self):
            return self.getTypedRuleContext(McCompParser.Unparsed_blockContext,0)


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

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

        def getRuleIndex(self):
            return McCompParser.RULE_metadata

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




    def metadata(self):

        localctx = McCompParser.MetadataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_metadata)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 372
            self.match(McCompParser.MetaData)
            self.state = 373
            localctx.mime = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==52 or _la==143):
                localctx.mime = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 374
            localctx.name = self._input.LT(1)
            _la = self._input.LA(1)
            if not(_la==52 or _la==143):
                localctx.name = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 375
            self.unparsed_block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CategoryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Category(self):
            return self.getToken(McCompParser.Category, 0)

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)

        def StringLiteral(self):
            return self.getToken(McCompParser.StringLiteral, 0)

        def getRuleIndex(self):
            return McCompParser.RULE_category

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




    def category(self):

        localctx = McCompParser.CategoryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_category)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 377
            self.match(McCompParser.Category)
            self.state = 378
            _la = self._input.LA(1)
            if not(_la==52 or _la==143):
                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 InitializerlistContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._expr = None # ExprContext
            self.values = list() # of ExprContexts

        def LeftBrace(self):
            return self.getToken(McCompParser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(McCompParser.RightBrace, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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

        def getRuleIndex(self):
            return McCompParser.RULE_initializerlist

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




    def initializerlist(self):

        localctx = McCompParser.InitializerlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_initializerlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 380
            self.match(McCompParser.LeftBrace)
            self.state = 381
            localctx._expr = self.expr(0)
            localctx.values.append(localctx._expr)
            self.state = 386
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==133:
                self.state = 382
                self.match(McCompParser.Comma)
                self.state = 383
                localctx._expr = self.expr(0)
                localctx.values.append(localctx._expr)
                self.state = 388
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 389
            self.match(McCompParser.RightBrace)
        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 Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)

        def Assign(self):
            return self.getToken(McCompParser.Assign, 0)

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


        def getRuleIndex(self):
            return McCompParser.RULE_assignment

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




    def assignment(self):

        localctx = McCompParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 391
            self.match(McCompParser.Identifier)
            self.state = 392
            self.match(McCompParser.Assign)
            self.state = 393
            self.expr(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExprContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_expr

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


    class ExpressionBinaryModContext(ExprContext):

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

        def Mod(self):
            return self.getToken(McCompParser.Mod, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionBinaryLessContext(ExprContext):

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

        def Less(self):
            return self.getToken(McCompParser.Less, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionBinaryGreaterContext(ExprContext):

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

        def Greater(self):
            return self.getToken(McCompParser.Greater, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionBinaryLessEqualContext(ExprContext):

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

        def LessEqual(self):
            return self.getToken(McCompParser.LessEqual, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionArrayAccessContext(ExprContext):

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

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def LeftBracket(self):
            return self.getToken(McCompParser.LeftBracket, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)

        def RightBracket(self):
            return self.getToken(McCompParser.RightBracket, 0)

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


    class ExpressionBinaryLogicContext(ExprContext):

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)

        def AndAnd(self):
            return self.getToken(McCompParser.AndAnd, 0)
        def OrOr(self):
            return self.getToken(McCompParser.OrOr, 0)

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


    class ExpressionIntegerContext(ExprContext):

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

        def IntegerLiteral(self):
            return self.getToken(McCompParser.IntegerLiteral, 0)

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


    class ExpressionBinaryRightShiftContext(ExprContext):

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionMyselfContext(ExprContext):

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

        def Myself(self):
            return self.getToken(McCompParser.Myself, 0)

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


    class ExpressionPreviousContext(ExprContext):

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

        def Previous(self):
            return self.getToken(McCompParser.Previous, 0)

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


    class ExpressionIdentifierContext(ExprContext):

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

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)

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


    class ExpressionStructAccessContext(ExprContext):

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

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Dot(self):
            return self.getToken(McCompParser.Dot, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)


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


    class ExpressionFunctionCallContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a McCompParser.ExprContext
            super().__init__(parser)
            self._expr = None # ExprContext
            self.args = list() # of ExprContexts
            self.copyFrom(ctx)

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def LeftParen(self):
            return self.getToken(McCompParser.LeftParen, 0)
        def RightParen(self):
            return self.getToken(McCompParser.RightParen, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)

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

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


    class ExpressionBinaryMDContext(ExprContext):

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)

        def Star(self):
            return self.getToken(McCompParser.Star, 0)
        def Div(self):
            return self.getToken(McCompParser.Div, 0)

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


    class ExpressionStringContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a McCompParser.ExprContext
            super().__init__(parser)
            self._StringLiteral = None # Token
            self.args = list() # of Tokens
            self.copyFrom(ctx)

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

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


    class ExpressionGroupingContext(ExprContext):

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

        def LeftParen(self):
            return self.getToken(McCompParser.LeftParen, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)

        def RightParen(self):
            return self.getToken(McCompParser.RightParen, 0)

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


    class ExpressionExponentiationContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a McCompParser.ExprContext
            super().__init__(parser)
            self.base = None # ExprContext
            self.exponent = None # ExprContext
            self.copyFrom(ctx)

        def Caret(self):
            return self.getToken(McCompParser.Caret, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionBinaryLeftShiftContext(ExprContext):

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionBinaryGreaterEqualContext(ExprContext):

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

        def GreaterEqual(self):
            return self.getToken(McCompParser.GreaterEqual, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionZeroContext(ExprContext):

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


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


    class ExpressionUnaryPMContext(ExprContext):

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

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

        def Plus(self):
            return self.getToken(McCompParser.Plus, 0)
        def Minus(self):
            return self.getToken(McCompParser.Minus, 0)

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


    class ExpressionTrinaryLogicContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a McCompParser.ExprContext
            super().__init__(parser)
            self.test = None # ExprContext
            self.true_ = None # ExprContext
            self.false_ = None # ExprContext
            self.copyFrom(ctx)

        def Question(self):
            return self.getToken(McCompParser.Question, 0)
        def Colon(self):
            return self.getToken(McCompParser.Colon, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionFloatContext(ExprContext):

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

        def FloatingLiteral(self):
            return self.getToken(McCompParser.FloatingLiteral, 0)

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


    class ExpressionPointerAccessContext(ExprContext):

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

        def Identifier(self):
            return self.getToken(McCompParser.Identifier, 0)
        def Arrow(self):
            return self.getToken(McCompParser.Arrow, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)


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


    class ExpressionBinaryEqualContext(ExprContext):

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

        def Equal(self):
            return self.getToken(McCompParser.Equal, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)


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


    class ExpressionBinaryPMContext(ExprContext):

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(McCompParser.ExprContext)
            else:
                return self.getTypedRuleContext(McCompParser.ExprContext,i)

        def Plus(self):
            return self.getToken(McCompParser.Plus, 0)
        def Minus(self):
            return self.getToken(McCompParser.Minus, 0)

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


    class ExpressionUnaryLogicContext(ExprContext):

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

        def Not(self):
            return self.getToken(McCompParser.Not, 0)
        def expr(self):
            return self.getTypedRuleContext(McCompParser.ExprContext,0)


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



    def expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = McCompParser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 48
        self.enterRecursionRule(localctx, 48, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 439
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                localctx = McCompParser.ExpressionZeroContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 396
                self.match(McCompParser.T__0)
                pass

            elif la_ == 2:
                localctx = McCompParser.ExpressionIntegerContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 397
                self.match(McCompParser.IntegerLiteral)
                pass

            elif la_ == 3:
                localctx = McCompParser.ExpressionFloatContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 398
                self.match(McCompParser.FloatingLiteral)
                pass

            elif la_ == 4:
                localctx = McCompParser.ExpressionStringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 402
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 399
                        localctx._StringLiteral = self.match(McCompParser.StringLiteral)
                        localctx.args.append(localctx._StringLiteral) 
                    self.state = 404
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,65,self._ctx)

                pass

            elif la_ == 5:
                localctx = McCompParser.ExpressionPointerAccessContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 405
                self.match(McCompParser.Identifier)
                self.state = 406
                self.match(McCompParser.Arrow)
                self.state = 407
                self.expr(23)
                pass

            elif la_ == 6:
                localctx = McCompParser.ExpressionStructAccessContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 408
                self.match(McCompParser.Identifier)
                self.state = 409
                self.match(McCompParser.Dot)
                self.state = 410
                self.expr(22)
                pass

            elif la_ == 7:
                localctx = McCompParser.ExpressionArrayAccessContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 411
                self.match(McCompParser.Identifier)
                self.state = 412
                self.match(McCompParser.LeftBracket)
                self.state = 413
                self.expr(0)
                self.state = 414
                self.match(McCompParser.RightBracket)
                pass

            elif la_ == 8:
                localctx = McCompParser.ExpressionFunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 416
                self.match(McCompParser.Identifier)
                self.state = 417
                self.match(McCompParser.LeftParen)
                self.state = 418
                localctx._expr = self.expr(0)
                localctx.args.append(localctx._expr)
                self.state = 423
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==133:
                    self.state = 419
                    self.match(McCompParser.Comma)
                    self.state = 420
                    localctx._expr = self.expr(0)
                    localctx.args.append(localctx._expr)
                    self.state = 425
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 426
                self.match(McCompParser.RightParen)
                pass

            elif la_ == 9:
                localctx = McCompParser.ExpressionGroupingContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 428
                self.match(McCompParser.LeftParen)
                self.state = 429
                self.expr(0)
                self.state = 430
                self.match(McCompParser.RightParen)
                pass

            elif la_ == 10:
                localctx = McCompParser.ExpressionUnaryPMContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 432
                _la = self._input.LA(1)
                if not(_la==102 or _la==103):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 433
                self.expr(18)
                pass

            elif la_ == 11:
                localctx = McCompParser.ExpressionIdentifierContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 434
                self.match(McCompParser.Identifier)
                pass

            elif la_ == 12:
                localctx = McCompParser.ExpressionUnaryLogicContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 435
                self.match(McCompParser.Not)
                self.state = 436
                self.expr(5)
                pass

            elif la_ == 13:
                localctx = McCompParser.ExpressionPreviousContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 437
                self.match(McCompParser.Previous)
                pass

            elif la_ == 14:
                localctx = McCompParser.ExpressionMyselfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 438
                self.match(McCompParser.Myself)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 485
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,69,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 483
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                    if la_ == 1:
                        localctx = McCompParser.ExpressionExponentiationContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.base = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 441
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 442
                        self.match(McCompParser.Caret)
                        self.state = 443
                        localctx.exponent = self.expr(17)
                        pass

                    elif la_ == 2:
                        localctx = McCompParser.ExpressionBinaryMDContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 444
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 445
                        _la = self._input.LA(1)
                        if not(_la==104 or _la==105):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 446
                        localctx.right = self.expr(17)
                        pass

                    elif la_ == 3:
                        localctx = McCompParser.ExpressionBinaryPMContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 447
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 448
                        _la = self._input.LA(1)
                        if not(_la==102 or _la==103):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 449
                        localctx.right = self.expr(16)
                        pass

                    elif la_ == 4:
                        localctx = McCompParser.ExpressionBinaryModContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 450
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 451
                        self.match(McCompParser.Mod)
                        self.state = 452
                        localctx.right = self.expr(15)
                        pass

                    elif la_ == 5:
                        localctx = McCompParser.ExpressionBinaryRightShiftContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 453
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 454
                        self.match(McCompParser.T__1)
                        self.state = 455
                        localctx.right = self.expr(14)
                        pass

                    elif la_ == 6:
                        localctx = McCompParser.ExpressionBinaryLeftShiftContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 456
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 457
                        self.match(McCompParser.T__2)
                        self.state = 458
                        localctx.right = self.expr(13)
                        pass

                    elif la_ == 7:
                        localctx = McCompParser.ExpressionBinaryEqualContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 459
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 460
                        self.match(McCompParser.Equal)
                        self.state = 461
                        localctx.right = self.expr(11)
                        pass

                    elif la_ == 8:
                        localctx = McCompParser.ExpressionBinaryLessEqualContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 462
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 463
                        self.match(McCompParser.LessEqual)
                        self.state = 464
                        localctx.right = self.expr(10)
                        pass

                    elif la_ == 9:
                        localctx = McCompParser.ExpressionBinaryGreaterEqualContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 465
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 466
                        self.match(McCompParser.GreaterEqual)
                        self.state = 467
                        localctx.right = self.expr(9)
                        pass

                    elif la_ == 10:
                        localctx = McCompParser.ExpressionBinaryLessContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 468
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 469
                        self.match(McCompParser.Less)
                        self.state = 470
                        localctx.right = self.expr(8)
                        pass

                    elif la_ == 11:
                        localctx = McCompParser.ExpressionBinaryGreaterContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 471
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 472
                        self.match(McCompParser.Greater)
                        self.state = 473
                        localctx.right = self.expr(7)
                        pass

                    elif la_ == 12:
                        localctx = McCompParser.ExpressionBinaryLogicContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.left = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 474
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 475
                        _la = self._input.LA(1)
                        if not(_la==129 or _la==130):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 476
                        localctx.right = self.expr(5)
                        pass

                    elif la_ == 13:
                        localctx = McCompParser.ExpressionTrinaryLogicContext(self, McCompParser.ExprContext(self, _parentctx, _parentState))
                        localctx.test = _prevctx
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 477
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 478
                        self.match(McCompParser.Question)
                        self.state = 479
                        localctx.true_ = self.expr(0)
                        self.state = 480
                        self.match(McCompParser.Colon)
                        self.state = 481
                        localctx.false_ = self.expr(4)
                        pass

             
                self.state = 487
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,69,self._ctx)

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


    class ShellContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Shell(self):
            return self.getToken(McCompParser.Shell, 0)

        def StringLiteral(self):
            return self.getToken(McCompParser.StringLiteral, 0)

        def getRuleIndex(self):
            return McCompParser.RULE_shell

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




    def shell(self):

        localctx = McCompParser.ShellContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_shell)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 488
            self.match(McCompParser.Shell)
            self.state = 489
            self.match(McCompParser.StringLiteral)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SearchContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return McCompParser.RULE_search

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



    class SearchPathContext(SearchContext):

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

        def Search(self):
            return self.getToken(McCompParser.Search, 0)
        def StringLiteral(self):
            return self.getToken(McCompParser.StringLiteral, 0)

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


    class SearchShellContext(SearchContext):

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

        def Search(self):
            return self.getToken(McCompParser.Search, 0)
        def Shell(self):
            return self.getToken(McCompParser.Shell, 0)
        def StringLiteral(self):
            return self.getToken(McCompParser.StringLiteral, 0)

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



    def search(self):

        localctx = McCompParser.SearchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_search)
        try:
            self.state = 496
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                localctx = McCompParser.SearchPathContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 491
                self.match(McCompParser.Search)
                self.state = 492
                self.match(McCompParser.StringLiteral)
                pass

            elif la_ == 2:
                localctx = McCompParser.SearchShellContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 493
                self.match(McCompParser.Search)
                self.state = 494
                self.match(McCompParser.Shell)
                self.state = 495
                self.match(McCompParser.StringLiteral)
                pass


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


    class Unparsed_blockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UnparsedBlock(self):
            return self.getToken(McCompParser.UnparsedBlock, 0)

        def getRuleIndex(self):
            return McCompParser.RULE_unparsed_block

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




    def unparsed_block(self):

        localctx = McCompParser.Unparsed_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_unparsed_block)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 498
            self.match(McCompParser.UnparsedBlock)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[24] = self.expr_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def expr_sempred(self, localctx:ExprContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 17)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 16)
         

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

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

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

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

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

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

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

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

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

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

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




