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

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

class PS_origParser ( Parser ):

    grammarFileName = "PS_orig.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'\\acute'", "'\\bar'", "'\\overline'", 
                     "'\\breve'", "'\\check'", "'\\widecheck'", "'\\dot'", 
                     "'\\ddot'", "'\\grave'", "'\\hat'", "'\\tilde'", "'\\widetilde'", 
                     "'\\vec'", "'\\overrightarrow'", "'\\bm'", "'\\boldsymbol'", 
                     "'\\text'", "'\\textit'", "'\\mathbb'", "'\\mathbin'", 
                     "'\\mathbf'", "'\\mathcal'", "'\\mathclap'", "'\\mathclose'", 
                     "'\\mathellipsis'", "'\\mathfrak'", "'\\mathinner'", 
                     "'\\mathnormal'", "'\\mathop'", "'\\mathopen'", "'\\mathord'", 
                     "'\\mathpunct'", "'\\mathrel'", "'\\mathring'", "'\\mathrlap'", 
                     "'\\mathrm'", "'\\mathscr'", "'\\mathsf'", "'\\mathsterling'", 
                     "'\\mathtt'", "'^T'", "'^{T}'", "'^\\top'", "'^{\\top}'", 
                     "'''", "<INVALID>", "'\\$'", "'+'", "'-'", "'*'", "<INVALID>", 
                     "'('", "')'", "'\\lgroup'", "'\\rgroup'", "'{'", "'}'", 
                     "'\\{'", "'\\}'", "'\\lbrace'", "'\\rbrace'", "'['", 
                     "']'", "'\\lbrack'", "'\\rbrack'", "'|'", "'\\lvert'", 
                     "'\\rvert'", "'\\vert'", "'\\|'", "'\\lfloor'", "'\\rfloor'", 
                     "'\\llcorner'", "'\\lrcorner'", "'\\lceil'", "'\\rceil'", 
                     "'\\ulcorner'", "'\\urcorner'", "'\\left'", "'\\right'", 
                     "'\\mleft'", "'\\mright'", "'\\lim'", "<INVALID>", 
                     "'\\int'", "'\\sum'", "'\\prod'", "'\\log'", "'\\ln'", 
                     "'\\exp'", "'\\sin'", "'\\cos'", "'\\tan'", "'\\csc'", 
                     "'\\sec'", "'\\cot'", "'\\arcsin'", "'\\arccos'", "'\\arctan'", 
                     "'\\arccsc'", "'\\arcsec'", "'\\arccot'", "'\\sinh'", 
                     "'\\cosh'", "'\\tanh'", "'\\arsinh'", "'\\arcosh'", 
                     "'\\artanh'", "'\\arcsinh'", "'\\arccosh'", "'\\arctanh'", 
                     "'arsinh'", "'arcsinh'", "'arcosh'", "'arccosh'", "'artanh'", 
                     "'arctanh'", "'gcd'", "'lcm'", "'floor'", "'ceil'", 
                     "'\\sqrt'", "'\\gcd'", "'\\lcm'", "'\\floor'", "'\\ceil'", 
                     "'\\max'", "'\\min'", "'\\det'", "'eye'", "'zeros'", 
                     "'ones'", "'cols'", "'rows'", "'diag'", "'norm'", "'rank'", 
                     "<INVALID>", "'rref'", "'hstack'", "'vstack'", "<INVALID>", 
                     "'nullspace'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'\\times'", "'\\cdot'", "'\\div'", "'\\frac'", 
                     "<INVALID>", "'\\choose'", "'\\mod'", "'\\mathit'", 
                     "'\\operatorname'", "'matrix'", "'pmatrix'", "'bmatrix'", 
                     "'vmatrix'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'&'", "'\\\\'", "'_'", "'^'", 
                     "':'", "';'", "','", "'.'", "<INVALID>", "<INVALID>", 
                     "'E'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'\\in'", "'='", "<INVALID>", "'<'", "<INVALID>", 
                     "'>'", "<INVALID>", "<INVALID>", "'!'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "WS", "DOLLAR_SIGN", "ADD", 
                      "SUB", "MUL", "DIV", "L_PAREN", "R_PAREN", "L_GROUP", 
                      "R_GROUP", "L_BRACE", "R_BRACE", "L_BRACE_VISUAL", 
                      "R_BRACE_VISUAL", "L_BRACE_CMD", "R_BRACE_CMD", "L_BRACKET", 
                      "R_BRACKET", "L_BRACK", "R_BRACK", "BAR", "L_VERT", 
                      "R_VERT", "VERT", "NORM", "L_FLOOR", "R_FLOOR", "LL_CORNER", 
                      "LR_CORNER", "L_CEIL", "R_CEIL", "UL_CORNER", "UR_CORNER", 
                      "L_LEFT", "R_RIGHT", "ML_LEFT", "MR_RIGHT", "FUNC_LIM", 
                      "LIM_APPROACH_SYM", "FUNC_INT", "FUNC_SUM", "FUNC_PROD", 
                      "FUNC_LOG", "FUNC_LN", "FUNC_EXP", "FUNC_SIN", "FUNC_COS", 
                      "FUNC_TAN", "FUNC_CSC", "FUNC_SEC", "FUNC_COT", "FUNC_ARCSIN", 
                      "FUNC_ARCCOS", "FUNC_ARCTAN", "FUNC_ARCCSC", "FUNC_ARCSEC", 
                      "FUNC_ARCCOT", "FUNC_SINH", "FUNC_COSH", "FUNC_TANH", 
                      "FUNC_ARSINH", "FUNC_ARCOSH", "FUNC_ARTANH", "FUNC_ARCSINH", 
                      "FUNC_ARCCOSH", "FUNC_ARCTANH", "FUNC_ARSINH_NAME", 
                      "FUNC_ARCSINH_NAME", "FUNC_ARCOSH_NAME", "FUNC_ARCCOSH_NAME", 
                      "FUNC_ARTANH_NAME", "FUNC_ARCTANH_NAME", "FUNC_GCD_NAME", 
                      "FUNC_LCM_NAME", "FUNC_FLOOR_NAME", "FUNC_CEIL_NAME", 
                      "FUNC_SQRT", "FUNC_GCD", "FUNC_LCM", "FUNC_FLOOR", 
                      "FUNC_CEIL", "FUNC_MAX", "FUNC_MIN", "FUNC_DET", "FUNC_EYE_NAME", 
                      "FUNC_ZEROS_NAME", "FUNC_ONES_NAME", "FUNC_COLS_NAME", 
                      "FUNC_ROWS_NAME", "FUNC_DIAG_NAME", "FUNC_NORM_NAME", 
                      "FUNC_RANK_NAME", "FUNC_TRACE_NAME", "FUNC_RREF_NAME", 
                      "FUNC_HSTACK_NAME", "FUNC_VSTACK_NAME", "FUNC_ORTHOGONALIZE_NAME", 
                      "FUNC_NULLSPACE_NAME", "FUNC_DIAGONALIZE_NAME", "FUNC_EIGENVALS_NAME", 
                      "FUNC_EIGENVECTORS_NAME", "FUNC_SVD_NAME", "CMD_TIMES", 
                      "CMD_CDOT", "CMD_DIV", "CMD_FRAC", "CMD_BINOM", "CMD_CHOOSE", 
                      "CMD_MOD", "CMD_MATHIT", "CMD_OPERATORNAME", "MATRIX_TYPE_MATRIX", 
                      "MATRIX_TYPE_PMATRIX", "MATRIX_TYPE_BMATRIX", "MATRIX_TYPE_DET", 
                      "MATRIX_TYPES", "CMD_MATRIX_START", "CMD_MATRIX_END", 
                      "CMD_DET_START", "CMD_DET_END", "MATRIX_DEL_COL", 
                      "MATRIX_DEL_ROW", "UNDERSCORE", "CARET", "COLON", 
                      "SEMICOLON", "COMMA", "PERIOD", "DIFFERENTIAL", "EXP_E", 
                      "E_NOTATION_E", "LETTER_NO_E", "MATRIX_XRIGHTARROW", 
                      "TRANSFORM_EXCHANGE", "NUMBER", "E_NOTATION", "IN", 
                      "ASSIGNMENT", "EQUAL", "LT", "LTE", "GT", "GTE", "UNEQUAL", 
                      "BANG", "PERCENT_NUMBER", "GREEK_CMD", "OTHER_SYMBOL_CMD", 
                      "SYMBOL", "VARIABLE" ]

    RULE_accent_symbol = 0
    RULE_math = 1
    RULE_transpose = 2
    RULE_transform_atom = 3
    RULE_transform_scale = 4
    RULE_transform_swap = 5
    RULE_transform_assignment = 6
    RULE_elementary_transform = 7
    RULE_elementary_transforms = 8
    RULE_matrix = 9
    RULE_det = 10
    RULE_matrix_row = 11
    RULE_relation = 12
    RULE_relation_list = 13
    RULE_relation_list_content = 14
    RULE_equality = 15
    RULE_expr = 16
    RULE_additive = 17
    RULE_mp = 18
    RULE_mp_nofunc = 19
    RULE_unary = 20
    RULE_unary_nofunc = 21
    RULE_postfix = 22
    RULE_postfix_nofunc = 23
    RULE_postfix_op = 24
    RULE_eval_at = 25
    RULE_eval_at_sub = 26
    RULE_eval_at_sup = 27
    RULE_exp = 28
    RULE_exp_nofunc = 29
    RULE_comp = 30
    RULE_comp_nofunc = 31
    RULE_group = 32
    RULE_norm_group = 33
    RULE_abs_group = 34
    RULE_floor_group = 35
    RULE_ceil_group = 36
    RULE_accent = 37
    RULE_atom_expr_no_supexpr = 38
    RULE_atom_expr = 39
    RULE_atom = 40
    RULE_mathit = 41
    RULE_mathit_text = 42
    RULE_frac = 43
    RULE_binom = 44
    RULE_func_normal_functions_single_arg = 45
    RULE_func_normal_functions_multi_arg = 46
    RULE_func_operator_names_single_arg = 47
    RULE_func_operator_names_multi_arg = 48
    RULE_func_normal_single_arg = 49
    RULE_func_normal_multi_arg = 50
    RULE_func = 51
    RULE_args = 52
    RULE_func_common_args = 53
    RULE_limit_sub = 54
    RULE_func_single_arg = 55
    RULE_func_single_arg_noparens = 56
    RULE_func_multi_arg = 57
    RULE_func_multi_arg_noparens = 58
    RULE_subexpr = 59
    RULE_supexpr = 60
    RULE_subeq = 61
    RULE_supeq = 62

    ruleNames =  [ "accent_symbol", "math", "transpose", "transform_atom", 
                   "transform_scale", "transform_swap", "transform_assignment", 
                   "elementary_transform", "elementary_transforms", "matrix", 
                   "det", "matrix_row", "relation", "relation_list", "relation_list_content", 
                   "equality", "expr", "additive", "mp", "mp_nofunc", "unary", 
                   "unary_nofunc", "postfix", "postfix_nofunc", "postfix_op", 
                   "eval_at", "eval_at_sub", "eval_at_sup", "exp", "exp_nofunc", 
                   "comp", "comp_nofunc", "group", "norm_group", "abs_group", 
                   "floor_group", "ceil_group", "accent", "atom_expr_no_supexpr", 
                   "atom_expr", "atom", "mathit", "mathit_text", "frac", 
                   "binom", "func_normal_functions_single_arg", "func_normal_functions_multi_arg", 
                   "func_operator_names_single_arg", "func_operator_names_multi_arg", 
                   "func_normal_single_arg", "func_normal_multi_arg", "func", 
                   "args", "func_common_args", "limit_sub", "func_single_arg", 
                   "func_single_arg_noparens", "func_multi_arg", "func_multi_arg_noparens", 
                   "subexpr", "supexpr", "subeq", "supeq" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    WS=46
    DOLLAR_SIGN=47
    ADD=48
    SUB=49
    MUL=50
    DIV=51
    L_PAREN=52
    R_PAREN=53
    L_GROUP=54
    R_GROUP=55
    L_BRACE=56
    R_BRACE=57
    L_BRACE_VISUAL=58
    R_BRACE_VISUAL=59
    L_BRACE_CMD=60
    R_BRACE_CMD=61
    L_BRACKET=62
    R_BRACKET=63
    L_BRACK=64
    R_BRACK=65
    BAR=66
    L_VERT=67
    R_VERT=68
    VERT=69
    NORM=70
    L_FLOOR=71
    R_FLOOR=72
    LL_CORNER=73
    LR_CORNER=74
    L_CEIL=75
    R_CEIL=76
    UL_CORNER=77
    UR_CORNER=78
    L_LEFT=79
    R_RIGHT=80
    ML_LEFT=81
    MR_RIGHT=82
    FUNC_LIM=83
    LIM_APPROACH_SYM=84
    FUNC_INT=85
    FUNC_SUM=86
    FUNC_PROD=87
    FUNC_LOG=88
    FUNC_LN=89
    FUNC_EXP=90
    FUNC_SIN=91
    FUNC_COS=92
    FUNC_TAN=93
    FUNC_CSC=94
    FUNC_SEC=95
    FUNC_COT=96
    FUNC_ARCSIN=97
    FUNC_ARCCOS=98
    FUNC_ARCTAN=99
    FUNC_ARCCSC=100
    FUNC_ARCSEC=101
    FUNC_ARCCOT=102
    FUNC_SINH=103
    FUNC_COSH=104
    FUNC_TANH=105
    FUNC_ARSINH=106
    FUNC_ARCOSH=107
    FUNC_ARTANH=108
    FUNC_ARCSINH=109
    FUNC_ARCCOSH=110
    FUNC_ARCTANH=111
    FUNC_ARSINH_NAME=112
    FUNC_ARCSINH_NAME=113
    FUNC_ARCOSH_NAME=114
    FUNC_ARCCOSH_NAME=115
    FUNC_ARTANH_NAME=116
    FUNC_ARCTANH_NAME=117
    FUNC_GCD_NAME=118
    FUNC_LCM_NAME=119
    FUNC_FLOOR_NAME=120
    FUNC_CEIL_NAME=121
    FUNC_SQRT=122
    FUNC_GCD=123
    FUNC_LCM=124
    FUNC_FLOOR=125
    FUNC_CEIL=126
    FUNC_MAX=127
    FUNC_MIN=128
    FUNC_DET=129
    FUNC_EYE_NAME=130
    FUNC_ZEROS_NAME=131
    FUNC_ONES_NAME=132
    FUNC_COLS_NAME=133
    FUNC_ROWS_NAME=134
    FUNC_DIAG_NAME=135
    FUNC_NORM_NAME=136
    FUNC_RANK_NAME=137
    FUNC_TRACE_NAME=138
    FUNC_RREF_NAME=139
    FUNC_HSTACK_NAME=140
    FUNC_VSTACK_NAME=141
    FUNC_ORTHOGONALIZE_NAME=142
    FUNC_NULLSPACE_NAME=143
    FUNC_DIAGONALIZE_NAME=144
    FUNC_EIGENVALS_NAME=145
    FUNC_EIGENVECTORS_NAME=146
    FUNC_SVD_NAME=147
    CMD_TIMES=148
    CMD_CDOT=149
    CMD_DIV=150
    CMD_FRAC=151
    CMD_BINOM=152
    CMD_CHOOSE=153
    CMD_MOD=154
    CMD_MATHIT=155
    CMD_OPERATORNAME=156
    MATRIX_TYPE_MATRIX=157
    MATRIX_TYPE_PMATRIX=158
    MATRIX_TYPE_BMATRIX=159
    MATRIX_TYPE_DET=160
    MATRIX_TYPES=161
    CMD_MATRIX_START=162
    CMD_MATRIX_END=163
    CMD_DET_START=164
    CMD_DET_END=165
    MATRIX_DEL_COL=166
    MATRIX_DEL_ROW=167
    UNDERSCORE=168
    CARET=169
    COLON=170
    SEMICOLON=171
    COMMA=172
    PERIOD=173
    DIFFERENTIAL=174
    EXP_E=175
    E_NOTATION_E=176
    LETTER_NO_E=177
    MATRIX_XRIGHTARROW=178
    TRANSFORM_EXCHANGE=179
    NUMBER=180
    E_NOTATION=181
    IN=182
    ASSIGNMENT=183
    EQUAL=184
    LT=185
    LTE=186
    GT=187
    GTE=188
    UNEQUAL=189
    BANG=190
    PERCENT_NUMBER=191
    GREEK_CMD=192
    OTHER_SYMBOL_CMD=193
    SYMBOL=194
    VARIABLE=195

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




    class Accent_symbolContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CMD_MATHIT(self):
            return self.getToken(PS_origParser.CMD_MATHIT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_accent_symbol

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

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




    def accent_symbol(self):

        localctx = PS_origParser.Accent_symbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_accent_symbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 126
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 2199023255550) != 0 or _la==155):
                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 MathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relation(self):
            return self.getTypedRuleContext(PS_origParser.RelationContext,0)


        def relation_list(self):
            return self.getTypedRuleContext(PS_origParser.Relation_listContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_math

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

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




    def math(self):

        localctx = PS_origParser.MathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_math)
        try:
            self.state = 130
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 128
                self.relation(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 129
                self.relation_list()
                pass


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


    class TransposeContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return PS_origParser.RULE_transpose

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

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




    def transpose(self):

        localctx = PS_origParser.TransposeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_transpose)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 132
            _la = self._input.LA(1)
            if not(((_la) & ~0x3f) == 0 and ((1 << _la) & 68169720922112) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Transform_atomContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LETTER_NO_E(self):
            return self.getToken(PS_origParser.LETTER_NO_E, 0)

        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

        def NUMBER(self):
            return self.getToken(PS_origParser.NUMBER, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_transform_atom

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

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




    def transform_atom(self):

        localctx = PS_origParser.Transform_atomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_transform_atom)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 134
            self.match(PS_origParser.LETTER_NO_E)
            self.state = 135
            self.match(PS_origParser.UNDERSCORE)
            self.state = 140
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [180]:
                self.state = 136
                self.match(PS_origParser.NUMBER)
                pass
            elif token in [56]:
                self.state = 137
                self.match(PS_origParser.L_BRACE)
                self.state = 138
                self.match(PS_origParser.NUMBER)
                self.state = 139
                self.match(PS_origParser.R_BRACE)
                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 Transform_scaleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def transform_atom(self):
            return self.getTypedRuleContext(PS_origParser.Transform_atomContext,0)


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


        def group(self):
            return self.getTypedRuleContext(PS_origParser.GroupContext,0)


        def ADD(self):
            return self.getToken(PS_origParser.ADD, 0)

        def SUB(self):
            return self.getToken(PS_origParser.SUB, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_transform_scale

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

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




    def transform_scale(self):

        localctx = PS_origParser.Transform_scaleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_transform_scale)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 146
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 142
                self.expr()
                pass

            elif la_ == 2:
                self.state = 143
                self.group()
                pass

            elif la_ == 3:
                self.state = 144
                self.match(PS_origParser.ADD)
                pass

            elif la_ == 4:
                self.state = 145
                self.match(PS_origParser.SUB)
                pass


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


    class Transform_swapContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def transform_atom(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Transform_atomContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Transform_atomContext,i)


        def TRANSFORM_EXCHANGE(self):
            return self.getToken(PS_origParser.TRANSFORM_EXCHANGE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_transform_swap

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

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




    def transform_swap(self):

        localctx = PS_origParser.Transform_swapContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_transform_swap)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 150
            self.transform_atom()
            self.state = 151
            self.match(PS_origParser.TRANSFORM_EXCHANGE)
            self.state = 152
            self.transform_atom()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Transform_assignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def transform_atom(self):
            return self.getTypedRuleContext(PS_origParser.Transform_atomContext,0)


        def transform_scale(self):
            return self.getTypedRuleContext(PS_origParser.Transform_scaleContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_transform_assignment

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

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




    def transform_assignment(self):

        localctx = PS_origParser.Transform_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_transform_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 154
            self.transform_atom()
            self.state = 155
            self.transform_scale()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Elementary_transformContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def transform_assignment(self):
            return self.getTypedRuleContext(PS_origParser.Transform_assignmentContext,0)


        def transform_scale(self):
            return self.getTypedRuleContext(PS_origParser.Transform_scaleContext,0)


        def transform_swap(self):
            return self.getTypedRuleContext(PS_origParser.Transform_swapContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_elementary_transform

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

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




    def elementary_transform(self):

        localctx = PS_origParser.Elementary_transformContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_elementary_transform)
        try:
            self.state = 160
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 157
                self.transform_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 158
                self.transform_scale()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 159
                self.transform_swap()
                pass


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


    class Elementary_transformsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def elementary_transform(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Elementary_transformContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Elementary_transformContext,i)


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

        def getRuleIndex(self):
            return PS_origParser.RULE_elementary_transforms

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

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




    def elementary_transforms(self):

        localctx = PS_origParser.Elementary_transformsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_elementary_transforms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 162
            self.elementary_transform()
            self.state = 167
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==172:
                self.state = 163
                self.match(PS_origParser.COMMA)
                self.state = 164
                self.elementary_transform()
                self.state = 169
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class MatrixContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CMD_MATRIX_START(self):
            return self.getToken(PS_origParser.CMD_MATRIX_START, 0)

        def matrix_row(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Matrix_rowContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Matrix_rowContext,i)


        def CMD_MATRIX_END(self):
            return self.getToken(PS_origParser.CMD_MATRIX_END, 0)

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

        def MATRIX_XRIGHTARROW(self):
            return self.getToken(PS_origParser.MATRIX_XRIGHTARROW, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def elementary_transforms(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Elementary_transformsContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Elementary_transformsContext,i)


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def L_BRACKET(self):
            return self.getToken(PS_origParser.L_BRACKET, 0)

        def R_BRACKET(self):
            return self.getToken(PS_origParser.R_BRACKET, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_matrix

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

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




    def matrix(self):

        localctx = PS_origParser.MatrixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_matrix)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 170
            self.match(PS_origParser.CMD_MATRIX_START)
            self.state = 171
            self.matrix_row()
            self.state = 176
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 172
                    self.match(PS_origParser.MATRIX_DEL_ROW)
                    self.state = 173
                    self.matrix_row() 
                self.state = 178
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)

            self.state = 180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==167:
                self.state = 179
                self.match(PS_origParser.MATRIX_DEL_ROW)


            self.state = 182
            self.match(PS_origParser.CMD_MATRIX_END)
            self.state = 194
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 183
                self.match(PS_origParser.MATRIX_XRIGHTARROW)
                self.state = 188
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==62:
                    self.state = 184
                    self.match(PS_origParser.L_BRACKET)
                    self.state = 185
                    self.elementary_transforms()
                    self.state = 186
                    self.match(PS_origParser.R_BRACKET)


                self.state = 190
                self.match(PS_origParser.L_BRACE)
                self.state = 191
                self.elementary_transforms()
                self.state = 192
                self.match(PS_origParser.R_BRACE)


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


    class DetContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CMD_DET_START(self):
            return self.getToken(PS_origParser.CMD_DET_START, 0)

        def matrix_row(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Matrix_rowContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Matrix_rowContext,i)


        def CMD_DET_END(self):
            return self.getToken(PS_origParser.CMD_DET_END, 0)

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

        def getRuleIndex(self):
            return PS_origParser.RULE_det

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

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




    def det(self):

        localctx = PS_origParser.DetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_det)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 196
            self.match(PS_origParser.CMD_DET_START)
            self.state = 197
            self.matrix_row()
            self.state = 202
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 198
                    self.match(PS_origParser.MATRIX_DEL_ROW)
                    self.state = 199
                    self.matrix_row() 
                self.state = 204
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

            self.state = 206
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==167:
                self.state = 205
                self.match(PS_origParser.MATRIX_DEL_ROW)


            self.state = 208
            self.match(PS_origParser.CMD_DET_END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Matrix_rowContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PS_origParser.RULE_matrix_row

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

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




    def matrix_row(self):

        localctx = PS_origParser.Matrix_rowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_matrix_row)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 210
            self.expr()
            self.state = 215
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==166:
                self.state = 211
                self.match(PS_origParser.MATRIX_DEL_COL)
                self.state = 212
                self.expr()
                self.state = 217
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class RelationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.RelationContext)
            else:
                return self.getTypedRuleContext(PS_origParser.RelationContext,i)


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

        def ASSIGNMENT(self):
            return self.getToken(PS_origParser.ASSIGNMENT, 0)

        def EQUAL(self):
            return self.getToken(PS_origParser.EQUAL, 0)

        def LT(self):
            return self.getToken(PS_origParser.LT, 0)

        def LTE(self):
            return self.getToken(PS_origParser.LTE, 0)

        def GT(self):
            return self.getToken(PS_origParser.GT, 0)

        def GTE(self):
            return self.getToken(PS_origParser.GTE, 0)

        def UNEQUAL(self):
            return self.getToken(PS_origParser.UNEQUAL, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_relation

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

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



    def relation(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PS_origParser.RelationContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 24
        self.enterRecursionRule(localctx, 24, self.RULE_relation, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 219
            self.expr()
            self._ctx.stop = self._input.LT(-1)
            self.state = 226
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PS_origParser.RelationContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_relation)
                    self.state = 221
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 222
                    _la = self._input.LA(1)
                    if not((((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & 255) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 223
                    self.relation(3) 
                self.state = 228
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,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 Relation_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relation_list_content(self):
            return self.getTypedRuleContext(PS_origParser.Relation_list_contentContext,0)


        def L_BRACKET(self):
            return self.getToken(PS_origParser.L_BRACKET, 0)

        def R_BRACKET(self):
            return self.getToken(PS_origParser.R_BRACKET, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def L_BRACE_VISUAL(self):
            return self.getToken(PS_origParser.L_BRACE_VISUAL, 0)

        def R_BRACE_VISUAL(self):
            return self.getToken(PS_origParser.R_BRACE_VISUAL, 0)

        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_relation_list

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

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




    def relation_list(self):

        localctx = PS_origParser.Relation_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_relation_list)
        try:
            self.state = 266
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 229
                self.relation_list_content()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 230
                self.match(PS_origParser.L_BRACKET)
                self.state = 231
                self.relation_list_content()
                self.state = 232
                self.match(PS_origParser.R_BRACKET)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 234
                self.match(PS_origParser.L_BRACE)
                self.state = 235
                self.relation_list_content()
                self.state = 236
                self.match(PS_origParser.R_BRACE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 238
                self.match(PS_origParser.L_BRACE_VISUAL)
                self.state = 239
                self.relation_list_content()
                self.state = 240
                self.match(PS_origParser.R_BRACE_VISUAL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 242
                self.match(PS_origParser.L_LEFT)
                self.state = 243
                self.match(PS_origParser.L_BRACKET)
                self.state = 244
                self.relation_list_content()
                self.state = 245
                self.match(PS_origParser.R_RIGHT)
                self.state = 246
                self.match(PS_origParser.R_BRACKET)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 248
                self.match(PS_origParser.L_LEFT)
                self.state = 249
                self.match(PS_origParser.L_BRACE_VISUAL)
                self.state = 250
                self.relation_list_content()
                self.state = 251
                self.match(PS_origParser.R_RIGHT)
                self.state = 252
                self.match(PS_origParser.R_BRACE_VISUAL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 254
                self.match(PS_origParser.ML_LEFT)
                self.state = 255
                self.match(PS_origParser.L_BRACKET)
                self.state = 256
                self.relation_list_content()
                self.state = 257
                self.match(PS_origParser.MR_RIGHT)
                self.state = 258
                self.match(PS_origParser.R_BRACKET)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 260
                self.match(PS_origParser.ML_LEFT)
                self.state = 261
                self.match(PS_origParser.L_BRACE_VISUAL)
                self.state = 262
                self.relation_list_content()
                self.state = 263
                self.match(PS_origParser.MR_RIGHT)
                self.state = 264
                self.match(PS_origParser.R_BRACE_VISUAL)
                pass


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


    class Relation_list_contentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.RelationContext)
            else:
                return self.getTypedRuleContext(PS_origParser.RelationContext,i)


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

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

        def getRuleIndex(self):
            return PS_origParser.RULE_relation_list_content

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

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




    def relation_list_content(self):

        localctx = PS_origParser.Relation_list_contentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_relation_list_content)
        self._la = 0 # Token type
        try:
            self.state = 288
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 268
                self.relation(0)
                self.state = 269
                self.match(PS_origParser.COMMA)
                self.state = 270
                self.relation(0)
                self.state = 275
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==172:
                    self.state = 271
                    self.match(PS_origParser.COMMA)
                    self.state = 272
                    self.relation(0)
                    self.state = 277
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 278
                self.relation(0)
                self.state = 279
                self.match(PS_origParser.SEMICOLON)
                self.state = 280
                self.relation(0)
                self.state = 285
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==171:
                    self.state = 281
                    self.match(PS_origParser.SEMICOLON)
                    self.state = 282
                    self.relation(0)
                    self.state = 287
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


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


    class EqualityContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def EQUAL(self):
            return self.getToken(PS_origParser.EQUAL, 0)

        def ASSIGNMENT(self):
            return self.getToken(PS_origParser.ASSIGNMENT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_equality

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

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




    def equality(self):

        localctx = PS_origParser.EqualityContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_equality)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 290
            self.expr()
            self.state = 291
            _la = self._input.LA(1)
            if not(_la==183 or _la==184):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 292
            self.expr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def additive(self):
            return self.getTypedRuleContext(PS_origParser.AdditiveContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_expr

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

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




    def expr(self):

        localctx = PS_origParser.ExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_expr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self.additive(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AdditiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def mp(self):
            return self.getTypedRuleContext(PS_origParser.MpContext,0)


        def additive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.AdditiveContext)
            else:
                return self.getTypedRuleContext(PS_origParser.AdditiveContext,i)


        def ADD(self):
            return self.getToken(PS_origParser.ADD, 0)

        def SUB(self):
            return self.getToken(PS_origParser.SUB, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_additive

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

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



    def additive(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PS_origParser.AdditiveContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 34
        self.enterRecursionRule(localctx, 34, self.RULE_additive, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 297
            self.mp(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 304
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,17,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PS_origParser.AdditiveContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_additive)
                    self.state = 299
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 300
                    _la = self._input.LA(1)
                    if not(_la==48 or _la==49):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 301
                    self.additive(3) 
                self.state = 306
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,17,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 MpContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unary(self):
            return self.getTypedRuleContext(PS_origParser.UnaryContext,0)


        def mp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.MpContext)
            else:
                return self.getTypedRuleContext(PS_origParser.MpContext,i)


        def MUL(self):
            return self.getToken(PS_origParser.MUL, 0)

        def CMD_TIMES(self):
            return self.getToken(PS_origParser.CMD_TIMES, 0)

        def CMD_CDOT(self):
            return self.getToken(PS_origParser.CMD_CDOT, 0)

        def DIV(self):
            return self.getToken(PS_origParser.DIV, 0)

        def CMD_DIV(self):
            return self.getToken(PS_origParser.CMD_DIV, 0)

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

        def CMD_MOD(self):
            return self.getToken(PS_origParser.CMD_MOD, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_mp

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

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



    def mp(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PS_origParser.MpContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 36
        self.enterRecursionRule(localctx, 36, self.RULE_mp, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.unary()
            self._ctx.stop = self._input.LT(-1)
            self.state = 315
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,18,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PS_origParser.MpContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_mp)
                    self.state = 310
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 311
                    _la = self._input.LA(1)
                    if not(_la==50 or _la==51 or (((_la - 148)) & ~0x3f) == 0 and ((1 << (_la - 148)) & 4194375) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 312
                    self.mp(3) 
                self.state = 317
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,18,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 Mp_nofuncContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unary_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Unary_nofuncContext,0)


        def mp_nofunc(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Mp_nofuncContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Mp_nofuncContext,i)


        def MUL(self):
            return self.getToken(PS_origParser.MUL, 0)

        def CMD_TIMES(self):
            return self.getToken(PS_origParser.CMD_TIMES, 0)

        def CMD_CDOT(self):
            return self.getToken(PS_origParser.CMD_CDOT, 0)

        def DIV(self):
            return self.getToken(PS_origParser.DIV, 0)

        def CMD_DIV(self):
            return self.getToken(PS_origParser.CMD_DIV, 0)

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

        def CMD_MOD(self):
            return self.getToken(PS_origParser.CMD_MOD, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_mp_nofunc

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

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



    def mp_nofunc(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PS_origParser.Mp_nofuncContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 38
        self.enterRecursionRule(localctx, 38, self.RULE_mp_nofunc, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.unary_nofunc()
            self._ctx.stop = self._input.LT(-1)
            self.state = 326
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PS_origParser.Mp_nofuncContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_mp_nofunc)
                    self.state = 321
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 322
                    _la = self._input.LA(1)
                    if not(_la==50 or _la==51 or (((_la - 148)) & ~0x3f) == 0 and ((1 << (_la - 148)) & 4194375) != 0):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 323
                    self.mp_nofunc(3) 
                self.state = 328
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,19,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 UnaryContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unary(self):
            return self.getTypedRuleContext(PS_origParser.UnaryContext,0)


        def ADD(self):
            return self.getToken(PS_origParser.ADD, 0)

        def SUB(self):
            return self.getToken(PS_origParser.SUB, 0)

        def postfix(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.PostfixContext)
            else:
                return self.getTypedRuleContext(PS_origParser.PostfixContext,i)


        def getRuleIndex(self):
            return PS_origParser.RULE_unary

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

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




    def unary(self):

        localctx = PS_origParser.UnaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_unary)
        self._la = 0 # Token type
        try:
            self.state = 336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48, 49]:
                self.enterOuterAlt(localctx, 1)
                self.state = 329
                _la = self._input.LA(1)
                if not(_la==48 or _la==49):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 330
                self.unary()
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 52, 54, 56, 58, 60, 62, 64, 66, 67, 69, 70, 71, 73, 75, 77, 79, 81, 83, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 122, 123, 124, 125, 126, 127, 128, 129, 151, 152, 155, 156, 162, 164, 174, 175, 177, 180, 181, 191, 192, 193, 194, 195]:
                self.enterOuterAlt(localctx, 2)
                self.state = 332 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 331
                        self.postfix()

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

                pass
            else:
                raise NoViableAltException(self)

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


    class Unary_nofuncContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unary_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Unary_nofuncContext,0)


        def ADD(self):
            return self.getToken(PS_origParser.ADD, 0)

        def SUB(self):
            return self.getToken(PS_origParser.SUB, 0)

        def postfix(self):
            return self.getTypedRuleContext(PS_origParser.PostfixContext,0)


        def postfix_nofunc(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Postfix_nofuncContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Postfix_nofuncContext,i)


        def getRuleIndex(self):
            return PS_origParser.RULE_unary_nofunc

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

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




    def unary_nofunc(self):

        localctx = PS_origParser.Unary_nofuncContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_unary_nofunc)
        self._la = 0 # Token type
        try:
            self.state = 347
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48, 49]:
                self.enterOuterAlt(localctx, 1)
                self.state = 338
                _la = self._input.LA(1)
                if not(_la==48 or _la==49):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 339
                self.unary_nofunc()
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 52, 54, 56, 58, 60, 62, 64, 66, 67, 69, 70, 71, 73, 75, 77, 79, 81, 83, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 122, 123, 124, 125, 126, 127, 128, 129, 151, 152, 155, 156, 162, 164, 174, 175, 177, 180, 181, 191, 192, 193, 194, 195]:
                self.enterOuterAlt(localctx, 2)
                self.state = 340
                self.postfix()
                self.state = 344
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 341
                        self.postfix_nofunc() 
                    self.state = 346
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

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


    class PostfixContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def exp(self):
            return self.getTypedRuleContext(PS_origParser.ExpContext,0)


        def postfix_op(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Postfix_opContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Postfix_opContext,i)


        def getRuleIndex(self):
            return PS_origParser.RULE_postfix

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

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




    def postfix(self):

        localctx = PS_origParser.PostfixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_postfix)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 349
            self.exp(0)
            self.state = 353
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 350
                    self.postfix_op() 
                self.state = 355
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,24,self._ctx)

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


    class Postfix_nofuncContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def exp_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Exp_nofuncContext,0)


        def postfix_op(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PS_origParser.Postfix_opContext)
            else:
                return self.getTypedRuleContext(PS_origParser.Postfix_opContext,i)


        def getRuleIndex(self):
            return PS_origParser.RULE_postfix_nofunc

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

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




    def postfix_nofunc(self):

        localctx = PS_origParser.Postfix_nofuncContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_postfix_nofunc)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self.exp_nofunc(0)
            self.state = 360
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,25,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 357
                    self.postfix_op() 
                self.state = 362
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,25,self._ctx)

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


    class Postfix_opContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BANG(self):
            return self.getToken(PS_origParser.BANG, 0)

        def eval_at(self):
            return self.getTypedRuleContext(PS_origParser.Eval_atContext,0)


        def transpose(self):
            return self.getTypedRuleContext(PS_origParser.TransposeContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_postfix_op

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

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




    def postfix_op(self):

        localctx = PS_origParser.Postfix_opContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_postfix_op)
        try:
            self.state = 366
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [190]:
                self.enterOuterAlt(localctx, 1)
                self.state = 363
                self.match(PS_origParser.BANG)
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 2)
                self.state = 364
                self.eval_at()
                pass
            elif token in [41, 42, 43, 44, 45]:
                self.enterOuterAlt(localctx, 3)
                self.state = 365
                self.transpose()
                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 Eval_atContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BAR(self):
            return self.getToken(PS_origParser.BAR, 0)

        def eval_at_sup(self):
            return self.getTypedRuleContext(PS_origParser.Eval_at_supContext,0)


        def eval_at_sub(self):
            return self.getTypedRuleContext(PS_origParser.Eval_at_subContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_eval_at

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

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




    def eval_at(self):

        localctx = PS_origParser.Eval_atContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_eval_at)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 368
            self.match(PS_origParser.BAR)
            self.state = 374
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 369
                self.eval_at_sup()
                pass

            elif la_ == 2:
                self.state = 370
                self.eval_at_sub()
                pass

            elif la_ == 3:
                self.state = 371
                self.eval_at_sup()
                self.state = 372
                self.eval_at_sub()
                pass


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


    class Eval_at_subContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

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


        def equality(self):
            return self.getTypedRuleContext(PS_origParser.EqualityContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_eval_at_sub

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

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




    def eval_at_sub(self):

        localctx = PS_origParser.Eval_at_subContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_eval_at_sub)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 376
            self.match(PS_origParser.UNDERSCORE)
            self.state = 377
            self.match(PS_origParser.L_BRACE)
            self.state = 380
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.state = 378
                self.expr()
                pass

            elif la_ == 2:
                self.state = 379
                self.equality()
                pass


            self.state = 382
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Eval_at_supContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CARET(self):
            return self.getToken(PS_origParser.CARET, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

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


        def equality(self):
            return self.getTypedRuleContext(PS_origParser.EqualityContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_eval_at_sup

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

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




    def eval_at_sup(self):

        localctx = PS_origParser.Eval_at_supContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_eval_at_sup)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 384
            self.match(PS_origParser.CARET)
            self.state = 385
            self.match(PS_origParser.L_BRACE)
            self.state = 388
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.state = 386
                self.expr()
                pass

            elif la_ == 2:
                self.state = 387
                self.equality()
                pass


            self.state = 390
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def comp(self):
            return self.getTypedRuleContext(PS_origParser.CompContext,0)


        def exp(self):
            return self.getTypedRuleContext(PS_origParser.ExpContext,0)


        def CARET(self):
            return self.getToken(PS_origParser.CARET, 0)

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


        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

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


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def subexpr(self):
            return self.getTypedRuleContext(PS_origParser.SubexprContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_exp

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

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



    def exp(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PS_origParser.ExpContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 56
        self.enterRecursionRule(localctx, 56, self.RULE_exp, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 393
            self.comp()
            self._ctx.stop = self._input.LT(-1)
            self.state = 409
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PS_origParser.ExpContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                    self.state = 395
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 396
                    self.match(PS_origParser.CARET)
                    self.state = 402
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 155, 174, 177, 180, 181, 191, 192, 193, 194, 195]:
                        self.state = 397
                        self.atom()
                        pass
                    elif token in [56]:
                        self.state = 398
                        self.match(PS_origParser.L_BRACE)
                        self.state = 399
                        self.expr()
                        self.state = 400
                        self.match(PS_origParser.R_BRACE)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 405
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                    if la_ == 1:
                        self.state = 404
                        self.subexpr()

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

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

        def comp_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Comp_nofuncContext,0)


        def exp_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Exp_nofuncContext,0)


        def CARET(self):
            return self.getToken(PS_origParser.CARET, 0)

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


        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

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


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def subexpr(self):
            return self.getTypedRuleContext(PS_origParser.SubexprContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_exp_nofunc

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

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



    def exp_nofunc(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PS_origParser.Exp_nofuncContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 58
        self.enterRecursionRule(localctx, 58, self.RULE_exp_nofunc, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 413
            self.comp_nofunc()
            self._ctx.stop = self._input.LT(-1)
            self.state = 429
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PS_origParser.Exp_nofuncContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_exp_nofunc)
                    self.state = 415
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 416
                    self.match(PS_origParser.CARET)
                    self.state = 422
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 155, 174, 177, 180, 181, 191, 192, 193, 194, 195]:
                        self.state = 417
                        self.atom()
                        pass
                    elif token in [56]:
                        self.state = 418
                        self.match(PS_origParser.L_BRACE)
                        self.state = 419
                        self.expr()
                        self.state = 420
                        self.match(PS_origParser.R_BRACE)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 425
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                    if la_ == 1:
                        self.state = 424
                        self.subexpr()

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

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

        def group(self):
            return self.getTypedRuleContext(PS_origParser.GroupContext,0)


        def norm_group(self):
            return self.getTypedRuleContext(PS_origParser.Norm_groupContext,0)


        def abs_group(self):
            return self.getTypedRuleContext(PS_origParser.Abs_groupContext,0)


        def floor_group(self):
            return self.getTypedRuleContext(PS_origParser.Floor_groupContext,0)


        def ceil_group(self):
            return self.getTypedRuleContext(PS_origParser.Ceil_groupContext,0)


        def func(self):
            return self.getTypedRuleContext(PS_origParser.FuncContext,0)


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


        def frac(self):
            return self.getTypedRuleContext(PS_origParser.FracContext,0)


        def binom(self):
            return self.getTypedRuleContext(PS_origParser.BinomContext,0)


        def matrix(self):
            return self.getTypedRuleContext(PS_origParser.MatrixContext,0)


        def det(self):
            return self.getTypedRuleContext(PS_origParser.DetContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_comp

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

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




    def comp(self):

        localctx = PS_origParser.CompContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_comp)
        try:
            self.state = 443
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 432
                self.group()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 433
                self.norm_group()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 434
                self.abs_group()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 435
                self.floor_group()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 436
                self.ceil_group()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 437
                self.func()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 438
                self.atom()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 439
                self.frac()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 440
                self.binom()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 441
                self.matrix()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 442
                self.det()
                pass


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


    class Comp_nofuncContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def group(self):
            return self.getTypedRuleContext(PS_origParser.GroupContext,0)


        def norm_group(self):
            return self.getTypedRuleContext(PS_origParser.Norm_groupContext,0)


        def abs_group(self):
            return self.getTypedRuleContext(PS_origParser.Abs_groupContext,0)


        def floor_group(self):
            return self.getTypedRuleContext(PS_origParser.Floor_groupContext,0)


        def ceil_group(self):
            return self.getTypedRuleContext(PS_origParser.Ceil_groupContext,0)


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


        def frac(self):
            return self.getTypedRuleContext(PS_origParser.FracContext,0)


        def binom(self):
            return self.getTypedRuleContext(PS_origParser.BinomContext,0)


        def matrix(self):
            return self.getTypedRuleContext(PS_origParser.MatrixContext,0)


        def det(self):
            return self.getTypedRuleContext(PS_origParser.DetContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_comp_nofunc

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

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




    def comp_nofunc(self):

        localctx = PS_origParser.Comp_nofuncContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_comp_nofunc)
        try:
            self.state = 455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 445
                self.group()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 446
                self.norm_group()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 447
                self.abs_group()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 448
                self.floor_group()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 449
                self.ceil_group()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 450
                self.atom()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 451
                self.frac()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 452
                self.binom()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 453
                self.matrix()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 454
                self.det()
                pass


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


    class GroupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_PAREN(self):
            return self.getToken(PS_origParser.L_PAREN, 0)

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


        def R_PAREN(self):
            return self.getToken(PS_origParser.R_PAREN, 0)

        def L_GROUP(self):
            return self.getToken(PS_origParser.L_GROUP, 0)

        def R_GROUP(self):
            return self.getToken(PS_origParser.R_GROUP, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def L_BRACE_VISUAL(self):
            return self.getToken(PS_origParser.L_BRACE_VISUAL, 0)

        def R_BRACE_VISUAL(self):
            return self.getToken(PS_origParser.R_BRACE_VISUAL, 0)

        def L_BRACE_CMD(self):
            return self.getToken(PS_origParser.L_BRACE_CMD, 0)

        def R_BRACE_CMD(self):
            return self.getToken(PS_origParser.R_BRACE_CMD, 0)

        def L_BRACKET(self):
            return self.getToken(PS_origParser.L_BRACKET, 0)

        def R_BRACKET(self):
            return self.getToken(PS_origParser.R_BRACKET, 0)

        def L_BRACK(self):
            return self.getToken(PS_origParser.L_BRACK, 0)

        def R_BRACK(self):
            return self.getToken(PS_origParser.R_BRACK, 0)

        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_group

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

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




    def group(self):

        localctx = PS_origParser.GroupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_group)
        try:
            self.state = 569
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 457
                self.match(PS_origParser.L_PAREN)
                self.state = 458
                self.expr()
                self.state = 459
                self.match(PS_origParser.R_PAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 461
                self.match(PS_origParser.L_GROUP)
                self.state = 462
                self.expr()
                self.state = 463
                self.match(PS_origParser.R_GROUP)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 465
                self.match(PS_origParser.L_BRACE)
                self.state = 466
                self.expr()
                self.state = 467
                self.match(PS_origParser.R_BRACE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 469
                self.match(PS_origParser.L_BRACE_VISUAL)
                self.state = 470
                self.expr()
                self.state = 471
                self.match(PS_origParser.R_BRACE_VISUAL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 473
                self.match(PS_origParser.L_BRACE_CMD)
                self.state = 474
                self.expr()
                self.state = 475
                self.match(PS_origParser.R_BRACE_CMD)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 477
                self.match(PS_origParser.L_BRACKET)
                self.state = 478
                self.expr()
                self.state = 479
                self.match(PS_origParser.R_BRACKET)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 481
                self.match(PS_origParser.L_BRACK)
                self.state = 482
                self.expr()
                self.state = 483
                self.match(PS_origParser.R_BRACK)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 485
                self.match(PS_origParser.L_LEFT)
                self.state = 486
                self.match(PS_origParser.L_PAREN)
                self.state = 487
                self.expr()
                self.state = 488
                self.match(PS_origParser.R_RIGHT)
                self.state = 489
                self.match(PS_origParser.R_PAREN)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 491
                self.match(PS_origParser.L_LEFT)
                self.state = 492
                self.match(PS_origParser.L_GROUP)
                self.state = 493
                self.expr()
                self.state = 494
                self.match(PS_origParser.R_RIGHT)
                self.state = 495
                self.match(PS_origParser.R_GROUP)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 497
                self.match(PS_origParser.L_LEFT)
                self.state = 498
                self.match(PS_origParser.L_BRACE)
                self.state = 499
                self.expr()
                self.state = 500
                self.match(PS_origParser.R_RIGHT)
                self.state = 501
                self.match(PS_origParser.R_BRACE)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 503
                self.match(PS_origParser.L_LEFT)
                self.state = 504
                self.match(PS_origParser.L_BRACE_VISUAL)
                self.state = 505
                self.expr()
                self.state = 506
                self.match(PS_origParser.R_RIGHT)
                self.state = 507
                self.match(PS_origParser.R_BRACE_VISUAL)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 509
                self.match(PS_origParser.L_LEFT)
                self.state = 510
                self.match(PS_origParser.L_BRACE_CMD)
                self.state = 511
                self.expr()
                self.state = 512
                self.match(PS_origParser.R_RIGHT)
                self.state = 513
                self.match(PS_origParser.R_BRACE_CMD)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 515
                self.match(PS_origParser.L_LEFT)
                self.state = 516
                self.match(PS_origParser.L_BRACKET)
                self.state = 517
                self.expr()
                self.state = 518
                self.match(PS_origParser.R_RIGHT)
                self.state = 519
                self.match(PS_origParser.R_BRACKET)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 521
                self.match(PS_origParser.L_LEFT)
                self.state = 522
                self.match(PS_origParser.L_BRACK)
                self.state = 523
                self.expr()
                self.state = 524
                self.match(PS_origParser.R_RIGHT)
                self.state = 525
                self.match(PS_origParser.R_BRACK)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 527
                self.match(PS_origParser.ML_LEFT)
                self.state = 528
                self.match(PS_origParser.L_PAREN)
                self.state = 529
                self.expr()
                self.state = 530
                self.match(PS_origParser.MR_RIGHT)
                self.state = 531
                self.match(PS_origParser.R_PAREN)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 533
                self.match(PS_origParser.ML_LEFT)
                self.state = 534
                self.match(PS_origParser.L_GROUP)
                self.state = 535
                self.expr()
                self.state = 536
                self.match(PS_origParser.MR_RIGHT)
                self.state = 537
                self.match(PS_origParser.R_GROUP)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 539
                self.match(PS_origParser.ML_LEFT)
                self.state = 540
                self.match(PS_origParser.L_BRACE)
                self.state = 541
                self.expr()
                self.state = 542
                self.match(PS_origParser.MR_RIGHT)
                self.state = 543
                self.match(PS_origParser.R_BRACE)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 545
                self.match(PS_origParser.ML_LEFT)
                self.state = 546
                self.match(PS_origParser.L_BRACE_VISUAL)
                self.state = 547
                self.expr()
                self.state = 548
                self.match(PS_origParser.MR_RIGHT)
                self.state = 549
                self.match(PS_origParser.R_BRACE_VISUAL)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 551
                self.match(PS_origParser.ML_LEFT)
                self.state = 552
                self.match(PS_origParser.L_BRACE_CMD)
                self.state = 553
                self.expr()
                self.state = 554
                self.match(PS_origParser.MR_RIGHT)
                self.state = 555
                self.match(PS_origParser.R_BRACE_CMD)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 557
                self.match(PS_origParser.ML_LEFT)
                self.state = 558
                self.match(PS_origParser.L_BRACKET)
                self.state = 559
                self.expr()
                self.state = 560
                self.match(PS_origParser.MR_RIGHT)
                self.state = 561
                self.match(PS_origParser.R_BRACKET)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 563
                self.match(PS_origParser.ML_LEFT)
                self.state = 564
                self.match(PS_origParser.L_BRACK)
                self.state = 565
                self.expr()
                self.state = 566
                self.match(PS_origParser.MR_RIGHT)
                self.state = 567
                self.match(PS_origParser.R_BRACK)
                pass


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


    class Norm_groupContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_norm_group

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

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




    def norm_group(self):

        localctx = PS_origParser.Norm_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_norm_group)
        try:
            self.state = 587
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [70]:
                self.enterOuterAlt(localctx, 1)
                self.state = 571
                self.match(PS_origParser.NORM)
                self.state = 572
                self.expr()
                self.state = 573
                self.match(PS_origParser.NORM)
                pass
            elif token in [79]:
                self.enterOuterAlt(localctx, 2)
                self.state = 575
                self.match(PS_origParser.L_LEFT)
                self.state = 576
                self.match(PS_origParser.NORM)
                self.state = 577
                self.expr()
                self.state = 578
                self.match(PS_origParser.R_RIGHT)
                self.state = 579
                self.match(PS_origParser.NORM)
                pass
            elif token in [81]:
                self.enterOuterAlt(localctx, 3)
                self.state = 581
                self.match(PS_origParser.ML_LEFT)
                self.state = 582
                self.match(PS_origParser.NORM)
                self.state = 583
                self.expr()
                self.state = 584
                self.match(PS_origParser.MR_RIGHT)
                self.state = 585
                self.match(PS_origParser.NORM)
                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 Abs_groupContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def L_VERT(self):
            return self.getToken(PS_origParser.L_VERT, 0)

        def R_VERT(self):
            return self.getToken(PS_origParser.R_VERT, 0)

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

        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_abs_group

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

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




    def abs_group(self):

        localctx = PS_origParser.Abs_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_abs_group)
        try:
            self.state = 637
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 589
                self.match(PS_origParser.BAR)
                self.state = 590
                self.expr()
                self.state = 591
                self.match(PS_origParser.BAR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 593
                self.match(PS_origParser.L_VERT)
                self.state = 594
                self.expr()
                self.state = 595
                self.match(PS_origParser.R_VERT)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 597
                self.match(PS_origParser.VERT)
                self.state = 598
                self.expr()
                self.state = 599
                self.match(PS_origParser.VERT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 601
                self.match(PS_origParser.L_LEFT)
                self.state = 602
                self.match(PS_origParser.BAR)
                self.state = 603
                self.expr()
                self.state = 604
                self.match(PS_origParser.R_RIGHT)
                self.state = 605
                self.match(PS_origParser.BAR)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 607
                self.match(PS_origParser.L_LEFT)
                self.state = 608
                self.match(PS_origParser.L_VERT)
                self.state = 609
                self.expr()
                self.state = 610
                self.match(PS_origParser.R_RIGHT)
                self.state = 611
                self.match(PS_origParser.R_VERT)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 613
                self.match(PS_origParser.L_LEFT)
                self.state = 614
                self.match(PS_origParser.VERT)
                self.state = 615
                self.expr()
                self.state = 616
                self.match(PS_origParser.R_RIGHT)
                self.state = 617
                self.match(PS_origParser.VERT)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 619
                self.match(PS_origParser.ML_LEFT)
                self.state = 620
                self.match(PS_origParser.BAR)
                self.state = 621
                self.expr()
                self.state = 622
                self.match(PS_origParser.MR_RIGHT)
                self.state = 623
                self.match(PS_origParser.BAR)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 625
                self.match(PS_origParser.ML_LEFT)
                self.state = 626
                self.match(PS_origParser.L_VERT)
                self.state = 627
                self.expr()
                self.state = 628
                self.match(PS_origParser.MR_RIGHT)
                self.state = 629
                self.match(PS_origParser.R_VERT)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 631
                self.match(PS_origParser.ML_LEFT)
                self.state = 632
                self.match(PS_origParser.VERT)
                self.state = 633
                self.expr()
                self.state = 634
                self.match(PS_origParser.MR_RIGHT)
                self.state = 635
                self.match(PS_origParser.VERT)
                pass


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


    class Floor_groupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_FLOOR(self):
            return self.getToken(PS_origParser.L_FLOOR, 0)

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


        def R_FLOOR(self):
            return self.getToken(PS_origParser.R_FLOOR, 0)

        def LL_CORNER(self):
            return self.getToken(PS_origParser.LL_CORNER, 0)

        def LR_CORNER(self):
            return self.getToken(PS_origParser.LR_CORNER, 0)

        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_floor_group

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

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




    def floor_group(self):

        localctx = PS_origParser.Floor_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_floor_group)
        try:
            self.state = 671
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 639
                self.match(PS_origParser.L_FLOOR)
                self.state = 640
                self.expr()
                self.state = 641
                self.match(PS_origParser.R_FLOOR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 643
                self.match(PS_origParser.LL_CORNER)
                self.state = 644
                self.expr()
                self.state = 645
                self.match(PS_origParser.LR_CORNER)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 647
                self.match(PS_origParser.L_LEFT)
                self.state = 648
                self.match(PS_origParser.L_FLOOR)
                self.state = 649
                self.expr()
                self.state = 650
                self.match(PS_origParser.R_RIGHT)
                self.state = 651
                self.match(PS_origParser.R_FLOOR)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 653
                self.match(PS_origParser.L_LEFT)
                self.state = 654
                self.match(PS_origParser.LL_CORNER)
                self.state = 655
                self.expr()
                self.state = 656
                self.match(PS_origParser.R_RIGHT)
                self.state = 657
                self.match(PS_origParser.LR_CORNER)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 659
                self.match(PS_origParser.ML_LEFT)
                self.state = 660
                self.match(PS_origParser.L_FLOOR)
                self.state = 661
                self.expr()
                self.state = 662
                self.match(PS_origParser.MR_RIGHT)
                self.state = 663
                self.match(PS_origParser.R_FLOOR)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 665
                self.match(PS_origParser.ML_LEFT)
                self.state = 666
                self.match(PS_origParser.LL_CORNER)
                self.state = 667
                self.expr()
                self.state = 668
                self.match(PS_origParser.MR_RIGHT)
                self.state = 669
                self.match(PS_origParser.LR_CORNER)
                pass


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


    class Ceil_groupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_CEIL(self):
            return self.getToken(PS_origParser.L_CEIL, 0)

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


        def R_CEIL(self):
            return self.getToken(PS_origParser.R_CEIL, 0)

        def UL_CORNER(self):
            return self.getToken(PS_origParser.UL_CORNER, 0)

        def UR_CORNER(self):
            return self.getToken(PS_origParser.UR_CORNER, 0)

        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_ceil_group

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

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




    def ceil_group(self):

        localctx = PS_origParser.Ceil_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_ceil_group)
        try:
            self.state = 705
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 673
                self.match(PS_origParser.L_CEIL)
                self.state = 674
                self.expr()
                self.state = 675
                self.match(PS_origParser.R_CEIL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 677
                self.match(PS_origParser.UL_CORNER)
                self.state = 678
                self.expr()
                self.state = 679
                self.match(PS_origParser.UR_CORNER)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 681
                self.match(PS_origParser.L_LEFT)
                self.state = 682
                self.match(PS_origParser.L_CEIL)
                self.state = 683
                self.expr()
                self.state = 684
                self.match(PS_origParser.R_RIGHT)
                self.state = 685
                self.match(PS_origParser.R_CEIL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 687
                self.match(PS_origParser.L_LEFT)
                self.state = 688
                self.match(PS_origParser.UL_CORNER)
                self.state = 689
                self.expr()
                self.state = 690
                self.match(PS_origParser.R_RIGHT)
                self.state = 691
                self.match(PS_origParser.UR_CORNER)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 693
                self.match(PS_origParser.ML_LEFT)
                self.state = 694
                self.match(PS_origParser.L_CEIL)
                self.state = 695
                self.expr()
                self.state = 696
                self.match(PS_origParser.MR_RIGHT)
                self.state = 697
                self.match(PS_origParser.R_CEIL)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 699
                self.match(PS_origParser.ML_LEFT)
                self.state = 700
                self.match(PS_origParser.UL_CORNER)
                self.state = 701
                self.expr()
                self.state = 702
                self.match(PS_origParser.MR_RIGHT)
                self.state = 703
                self.match(PS_origParser.UR_CORNER)
                pass


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


    class AccentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def accent_symbol(self):
            return self.getTypedRuleContext(PS_origParser.Accent_symbolContext,0)


        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

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


        def getRuleIndex(self):
            return PS_origParser.RULE_accent

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

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




    def accent(self):

        localctx = PS_origParser.AccentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_accent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 707
            self.accent_symbol()
            self.state = 708
            self.match(PS_origParser.L_BRACE)
            self.state = 709
            localctx.base = self.expr()
            self.state = 710
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Atom_expr_no_supexprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LETTER_NO_E(self):
            return self.getToken(PS_origParser.LETTER_NO_E, 0)

        def GREEK_CMD(self):
            return self.getToken(PS_origParser.GREEK_CMD, 0)

        def OTHER_SYMBOL_CMD(self):
            return self.getToken(PS_origParser.OTHER_SYMBOL_CMD, 0)

        def accent(self):
            return self.getTypedRuleContext(PS_origParser.AccentContext,0)


        def subexpr(self):
            return self.getTypedRuleContext(PS_origParser.SubexprContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_atom_expr_no_supexpr

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

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




    def atom_expr_no_supexpr(self):

        localctx = PS_origParser.Atom_expr_no_supexprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_atom_expr_no_supexpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 716
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [177]:
                self.state = 712
                self.match(PS_origParser.LETTER_NO_E)
                pass
            elif token in [192]:
                self.state = 713
                self.match(PS_origParser.GREEK_CMD)
                pass
            elif token in [193]:
                self.state = 714
                self.match(PS_origParser.OTHER_SYMBOL_CMD)
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 155]:
                self.state = 715
                self.accent()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 719
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==168:
                self.state = 718
                self.subexpr()


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


    class Atom_exprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LETTER_NO_E(self):
            return self.getToken(PS_origParser.LETTER_NO_E, 0)

        def GREEK_CMD(self):
            return self.getToken(PS_origParser.GREEK_CMD, 0)

        def OTHER_SYMBOL_CMD(self):
            return self.getToken(PS_origParser.OTHER_SYMBOL_CMD, 0)

        def accent(self):
            return self.getTypedRuleContext(PS_origParser.AccentContext,0)


        def supexpr(self):
            return self.getTypedRuleContext(PS_origParser.SupexprContext,0)


        def subexpr(self):
            return self.getTypedRuleContext(PS_origParser.SubexprContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_atom_expr

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

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




    def atom_expr(self):

        localctx = PS_origParser.Atom_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_atom_expr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 725
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [177]:
                self.state = 721
                self.match(PS_origParser.LETTER_NO_E)
                pass
            elif token in [192]:
                self.state = 722
                self.match(PS_origParser.GREEK_CMD)
                pass
            elif token in [193]:
                self.state = 723
                self.match(PS_origParser.OTHER_SYMBOL_CMD)
                pass
            elif token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 155]:
                self.state = 724
                self.accent()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 735
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                self.state = 727
                self.supexpr()
                self.state = 728
                self.subexpr()

            elif la_ == 2:
                self.state = 730
                self.subexpr()
                self.state = 731
                self.supexpr()

            elif la_ == 3:
                self.state = 733
                self.subexpr()

            elif la_ == 4:
                self.state = 734
                self.supexpr()


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


    class AtomContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atom_expr(self):
            return self.getTypedRuleContext(PS_origParser.Atom_exprContext,0)


        def SYMBOL(self):
            return self.getToken(PS_origParser.SYMBOL, 0)

        def NUMBER(self):
            return self.getToken(PS_origParser.NUMBER, 0)

        def PERCENT_NUMBER(self):
            return self.getToken(PS_origParser.PERCENT_NUMBER, 0)

        def E_NOTATION(self):
            return self.getToken(PS_origParser.E_NOTATION, 0)

        def DIFFERENTIAL(self):
            return self.getToken(PS_origParser.DIFFERENTIAL, 0)

        def mathit(self):
            return self.getTypedRuleContext(PS_origParser.MathitContext,0)


        def VARIABLE(self):
            return self.getToken(PS_origParser.VARIABLE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_atom

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

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




    def atom(self):

        localctx = PS_origParser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_atom)
        try:
            self.state = 745
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 737
                self.atom_expr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 738
                self.match(PS_origParser.SYMBOL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 739
                self.match(PS_origParser.NUMBER)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 740
                self.match(PS_origParser.PERCENT_NUMBER)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 741
                self.match(PS_origParser.E_NOTATION)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 742
                self.match(PS_origParser.DIFFERENTIAL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 743
                self.mathit()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 744
                self.match(PS_origParser.VARIABLE)
                pass


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


    class MathitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CMD_MATHIT(self):
            return self.getToken(PS_origParser.CMD_MATHIT, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def mathit_text(self):
            return self.getTypedRuleContext(PS_origParser.Mathit_textContext,0)


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_mathit

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

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




    def mathit(self):

        localctx = PS_origParser.MathitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_mathit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 747
            self.match(PS_origParser.CMD_MATHIT)
            self.state = 748
            self.match(PS_origParser.L_BRACE)
            self.state = 749
            self.mathit_text()
            self.state = 750
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Mathit_textContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return PS_origParser.RULE_mathit_text

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

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




    def mathit_text(self):

        localctx = PS_origParser.Mathit_textContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_mathit_text)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 753 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 752
                _la = self._input.LA(1)
                if not((((_la - 175)) & ~0x3f) == 0 and ((1 << (_la - 175)) & 7) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 755 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la - 175)) & ~0x3f) == 0 and ((1 << (_la - 175)) & 7) != 0):
                    break

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


    class FracContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CMD_FRAC(self):
            return self.getToken(PS_origParser.CMD_FRAC, 0)

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

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

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


        def getRuleIndex(self):
            return PS_origParser.RULE_frac

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

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




    def frac(self):

        localctx = PS_origParser.FracContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_frac)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 757
            self.match(PS_origParser.CMD_FRAC)
            self.state = 758
            self.match(PS_origParser.L_BRACE)
            self.state = 759
            localctx.upper = self.expr()
            self.state = 760
            self.match(PS_origParser.R_BRACE)
            self.state = 761
            self.match(PS_origParser.L_BRACE)
            self.state = 762
            localctx.lower = self.expr()
            self.state = 763
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BinomContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def CMD_CHOOSE(self):
            return self.getToken(PS_origParser.CMD_CHOOSE, 0)

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

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


        def CMD_BINOM(self):
            return self.getToken(PS_origParser.CMD_BINOM, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_binom

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

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




    def binom(self):

        localctx = PS_origParser.BinomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_binom)
        try:
            self.state = 779
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 765
                self.match(PS_origParser.L_BRACE)
                self.state = 766
                localctx.upper = self.expr()
                self.state = 767
                self.match(PS_origParser.CMD_CHOOSE)
                self.state = 768
                localctx.lower = self.expr()
                self.state = 769
                self.match(PS_origParser.R_BRACE)
                pass
            elif token in [152]:
                self.enterOuterAlt(localctx, 2)
                self.state = 771
                self.match(PS_origParser.CMD_BINOM)
                self.state = 772
                self.match(PS_origParser.L_BRACE)
                self.state = 773
                localctx.upper = self.expr()
                self.state = 774
                self.match(PS_origParser.R_BRACE)
                self.state = 775
                self.match(PS_origParser.L_BRACE)
                self.state = 776
                localctx.lower = self.expr()
                self.state = 777
                self.match(PS_origParser.R_BRACE)
                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 Func_normal_functions_single_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FUNC_LOG(self):
            return self.getToken(PS_origParser.FUNC_LOG, 0)

        def FUNC_LN(self):
            return self.getToken(PS_origParser.FUNC_LN, 0)

        def FUNC_EXP(self):
            return self.getToken(PS_origParser.FUNC_EXP, 0)

        def FUNC_SIN(self):
            return self.getToken(PS_origParser.FUNC_SIN, 0)

        def FUNC_COS(self):
            return self.getToken(PS_origParser.FUNC_COS, 0)

        def FUNC_TAN(self):
            return self.getToken(PS_origParser.FUNC_TAN, 0)

        def FUNC_CSC(self):
            return self.getToken(PS_origParser.FUNC_CSC, 0)

        def FUNC_SEC(self):
            return self.getToken(PS_origParser.FUNC_SEC, 0)

        def FUNC_COT(self):
            return self.getToken(PS_origParser.FUNC_COT, 0)

        def FUNC_ARCSIN(self):
            return self.getToken(PS_origParser.FUNC_ARCSIN, 0)

        def FUNC_ARCCOS(self):
            return self.getToken(PS_origParser.FUNC_ARCCOS, 0)

        def FUNC_ARCTAN(self):
            return self.getToken(PS_origParser.FUNC_ARCTAN, 0)

        def FUNC_ARCCSC(self):
            return self.getToken(PS_origParser.FUNC_ARCCSC, 0)

        def FUNC_ARCSEC(self):
            return self.getToken(PS_origParser.FUNC_ARCSEC, 0)

        def FUNC_ARCCOT(self):
            return self.getToken(PS_origParser.FUNC_ARCCOT, 0)

        def FUNC_SINH(self):
            return self.getToken(PS_origParser.FUNC_SINH, 0)

        def FUNC_COSH(self):
            return self.getToken(PS_origParser.FUNC_COSH, 0)

        def FUNC_TANH(self):
            return self.getToken(PS_origParser.FUNC_TANH, 0)

        def FUNC_ARSINH(self):
            return self.getToken(PS_origParser.FUNC_ARSINH, 0)

        def FUNC_ARCOSH(self):
            return self.getToken(PS_origParser.FUNC_ARCOSH, 0)

        def FUNC_ARTANH(self):
            return self.getToken(PS_origParser.FUNC_ARTANH, 0)

        def FUNC_ARCSINH(self):
            return self.getToken(PS_origParser.FUNC_ARCSINH, 0)

        def FUNC_ARCCOSH(self):
            return self.getToken(PS_origParser.FUNC_ARCCOSH, 0)

        def FUNC_ARCTANH(self):
            return self.getToken(PS_origParser.FUNC_ARCTANH, 0)

        def FUNC_FLOOR(self):
            return self.getToken(PS_origParser.FUNC_FLOOR, 0)

        def FUNC_CEIL(self):
            return self.getToken(PS_origParser.FUNC_CEIL, 0)

        def FUNC_DET(self):
            return self.getToken(PS_origParser.FUNC_DET, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_func_normal_functions_single_arg

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

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




    def func_normal_functions_single_arg(self):

        localctx = PS_origParser.Func_normal_functions_single_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_func_normal_functions_single_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 781
            _la = self._input.LA(1)
            if not((((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & 2611356893183) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_normal_functions_multi_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FUNC_GCD(self):
            return self.getToken(PS_origParser.FUNC_GCD, 0)

        def FUNC_LCM(self):
            return self.getToken(PS_origParser.FUNC_LCM, 0)

        def FUNC_MAX(self):
            return self.getToken(PS_origParser.FUNC_MAX, 0)

        def FUNC_MIN(self):
            return self.getToken(PS_origParser.FUNC_MIN, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_func_normal_functions_multi_arg

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

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




    def func_normal_functions_multi_arg(self):

        localctx = PS_origParser.Func_normal_functions_multi_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_func_normal_functions_multi_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            _la = self._input.LA(1)
            if not((((_la - 123)) & ~0x3f) == 0 and ((1 << (_la - 123)) & 51) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_operator_names_single_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FUNC_ARSINH_NAME(self):
            return self.getToken(PS_origParser.FUNC_ARSINH_NAME, 0)

        def FUNC_ARCOSH_NAME(self):
            return self.getToken(PS_origParser.FUNC_ARCOSH_NAME, 0)

        def FUNC_ARTANH_NAME(self):
            return self.getToken(PS_origParser.FUNC_ARTANH_NAME, 0)

        def FUNC_ARCSINH_NAME(self):
            return self.getToken(PS_origParser.FUNC_ARCSINH_NAME, 0)

        def FUNC_ARCCOSH_NAME(self):
            return self.getToken(PS_origParser.FUNC_ARCCOSH_NAME, 0)

        def FUNC_ARCTANH_NAME(self):
            return self.getToken(PS_origParser.FUNC_ARCTANH_NAME, 0)

        def FUNC_FLOOR_NAME(self):
            return self.getToken(PS_origParser.FUNC_FLOOR_NAME, 0)

        def FUNC_CEIL_NAME(self):
            return self.getToken(PS_origParser.FUNC_CEIL_NAME, 0)

        def FUNC_EYE_NAME(self):
            return self.getToken(PS_origParser.FUNC_EYE_NAME, 0)

        def FUNC_RANK_NAME(self):
            return self.getToken(PS_origParser.FUNC_RANK_NAME, 0)

        def FUNC_TRACE_NAME(self):
            return self.getToken(PS_origParser.FUNC_TRACE_NAME, 0)

        def FUNC_RREF_NAME(self):
            return self.getToken(PS_origParser.FUNC_RREF_NAME, 0)

        def FUNC_NULLSPACE_NAME(self):
            return self.getToken(PS_origParser.FUNC_NULLSPACE_NAME, 0)

        def FUNC_DIAGONALIZE_NAME(self):
            return self.getToken(PS_origParser.FUNC_DIAGONALIZE_NAME, 0)

        def FUNC_NORM_NAME(self):
            return self.getToken(PS_origParser.FUNC_NORM_NAME, 0)

        def FUNC_EIGENVALS_NAME(self):
            return self.getToken(PS_origParser.FUNC_EIGENVALS_NAME, 0)

        def FUNC_EIGENVECTORS_NAME(self):
            return self.getToken(PS_origParser.FUNC_EIGENVECTORS_NAME, 0)

        def FUNC_SVD_NAME(self):
            return self.getToken(PS_origParser.FUNC_SVD_NAME, 0)

        def FUNC_COLS_NAME(self):
            return self.getToken(PS_origParser.FUNC_COLS_NAME, 0)

        def FUNC_ROWS_NAME(self):
            return self.getToken(PS_origParser.FUNC_ROWS_NAME, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_func_operator_names_single_arg

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

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




    def func_operator_names_single_arg(self):

        localctx = PS_origParser.Func_operator_names_single_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_func_operator_names_single_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 785
            _la = self._input.LA(1)
            if not((((_la - 112)) & ~0x3f) == 0 and ((1 << (_la - 112)) & 66830205759) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_operator_names_multi_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FUNC_GCD_NAME(self):
            return self.getToken(PS_origParser.FUNC_GCD_NAME, 0)

        def FUNC_LCM_NAME(self):
            return self.getToken(PS_origParser.FUNC_LCM_NAME, 0)

        def FUNC_ZEROS_NAME(self):
            return self.getToken(PS_origParser.FUNC_ZEROS_NAME, 0)

        def FUNC_ORTHOGONALIZE_NAME(self):
            return self.getToken(PS_origParser.FUNC_ORTHOGONALIZE_NAME, 0)

        def FUNC_ONES_NAME(self):
            return self.getToken(PS_origParser.FUNC_ONES_NAME, 0)

        def FUNC_DIAG_NAME(self):
            return self.getToken(PS_origParser.FUNC_DIAG_NAME, 0)

        def FUNC_HSTACK_NAME(self):
            return self.getToken(PS_origParser.FUNC_HSTACK_NAME, 0)

        def FUNC_VSTACK_NAME(self):
            return self.getToken(PS_origParser.FUNC_VSTACK_NAME, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_func_operator_names_multi_arg

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

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




    def func_operator_names_multi_arg(self):

        localctx = PS_origParser.Func_operator_names_multi_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_func_operator_names_multi_arg)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 787
            _la = self._input.LA(1)
            if not((((_la - 118)) & ~0x3f) == 0 and ((1 << (_la - 118)) & 29515779) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_normal_single_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def func_normal_functions_single_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_normal_functions_single_argContext,0)


        def CMD_OPERATORNAME(self):
            return self.getToken(PS_origParser.CMD_OPERATORNAME, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def func_operator_names_single_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_operator_names_single_argContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_func_normal_single_arg

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

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




    def func_normal_single_arg(self):

        localctx = PS_origParser.Func_normal_single_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_func_normal_single_arg)
        try:
            self.state = 795
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 125, 126, 129]:
                self.enterOuterAlt(localctx, 1)
                self.state = 789
                self.func_normal_functions_single_arg()
                pass
            elif token in [156]:
                self.enterOuterAlt(localctx, 2)
                self.state = 790
                self.match(PS_origParser.CMD_OPERATORNAME)
                self.state = 791
                self.match(PS_origParser.L_BRACE)
                self.state = 792
                localctx.func_operator_name = self.func_operator_names_single_arg()
                self.state = 793
                self.match(PS_origParser.R_BRACE)
                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 Func_normal_multi_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def func_normal_functions_multi_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_normal_functions_multi_argContext,0)


        def CMD_OPERATORNAME(self):
            return self.getToken(PS_origParser.CMD_OPERATORNAME, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def func_operator_names_multi_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_operator_names_multi_argContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_func_normal_multi_arg

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

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




    def func_normal_multi_arg(self):

        localctx = PS_origParser.Func_normal_multi_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_func_normal_multi_arg)
        try:
            self.state = 803
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [123, 124, 127, 128]:
                self.enterOuterAlt(localctx, 1)
                self.state = 797
                self.func_normal_functions_multi_arg()
                pass
            elif token in [156]:
                self.enterOuterAlt(localctx, 2)
                self.state = 798
                self.match(PS_origParser.CMD_OPERATORNAME)
                self.state = 799
                self.match(PS_origParser.L_BRACE)
                self.state = 800
                localctx.func_operator_name = self.func_operator_names_multi_arg()
                self.state = 801
                self.match(PS_origParser.R_BRACE)
                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 FuncContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def func_normal_single_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_normal_single_argContext,0)


        def L_PAREN(self):
            return self.getToken(PS_origParser.L_PAREN, 0)

        def func_single_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_single_argContext,0)


        def R_PAREN(self):
            return self.getToken(PS_origParser.R_PAREN, 0)

        def func_single_arg_noparens(self):
            return self.getTypedRuleContext(PS_origParser.Func_single_arg_noparensContext,0)


        def subexpr(self):
            return self.getTypedRuleContext(PS_origParser.SubexprContext,0)


        def supexpr(self):
            return self.getTypedRuleContext(PS_origParser.SupexprContext,0)


        def L_LEFT(self):
            return self.getToken(PS_origParser.L_LEFT, 0)

        def R_RIGHT(self):
            return self.getToken(PS_origParser.R_RIGHT, 0)

        def ML_LEFT(self):
            return self.getToken(PS_origParser.ML_LEFT, 0)

        def MR_RIGHT(self):
            return self.getToken(PS_origParser.MR_RIGHT, 0)

        def func_normal_multi_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_normal_multi_argContext,0)


        def func_multi_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_multi_argContext,0)


        def func_multi_arg_noparens(self):
            return self.getTypedRuleContext(PS_origParser.Func_multi_arg_noparensContext,0)


        def atom_expr_no_supexpr(self):
            return self.getTypedRuleContext(PS_origParser.Atom_expr_no_supexprContext,0)


        def func_common_args(self):
            return self.getTypedRuleContext(PS_origParser.Func_common_argsContext,0)


        def L_BRACKET(self):
            return self.getToken(PS_origParser.L_BRACKET, 0)

        def R_BRACKET(self):
            return self.getToken(PS_origParser.R_BRACKET, 0)

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

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

        def FUNC_INT(self):
            return self.getToken(PS_origParser.FUNC_INT, 0)

        def DIFFERENTIAL(self):
            return self.getToken(PS_origParser.DIFFERENTIAL, 0)

        def frac(self):
            return self.getTypedRuleContext(PS_origParser.FracContext,0)


        def additive(self):
            return self.getTypedRuleContext(PS_origParser.AdditiveContext,0)


        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

        def CARET(self):
            return self.getToken(PS_origParser.CARET, 0)

        def FUNC_SQRT(self):
            return self.getToken(PS_origParser.FUNC_SQRT, 0)

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


        def mp(self):
            return self.getTypedRuleContext(PS_origParser.MpContext,0)


        def FUNC_SUM(self):
            return self.getToken(PS_origParser.FUNC_SUM, 0)

        def FUNC_PROD(self):
            return self.getToken(PS_origParser.FUNC_PROD, 0)

        def subeq(self):
            return self.getTypedRuleContext(PS_origParser.SubeqContext,0)


        def FUNC_LIM(self):
            return self.getToken(PS_origParser.FUNC_LIM, 0)

        def limit_sub(self):
            return self.getTypedRuleContext(PS_origParser.Limit_subContext,0)


        def EXP_E(self):
            return self.getToken(PS_origParser.EXP_E, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_func

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

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




    def func(self):

        localctx = PS_origParser.FuncContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_func)
        self._la = 0 # Token type
        try:
            self.state = 971
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 805
                self.func_normal_single_arg()
                self.state = 818
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
                if la_ == 1:
                    self.state = 807
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==168:
                        self.state = 806
                        self.subexpr()


                    self.state = 810
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==169:
                        self.state = 809
                        self.supexpr()


                    pass

                elif la_ == 2:
                    self.state = 813
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==169:
                        self.state = 812
                        self.supexpr()


                    self.state = 816
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==168:
                        self.state = 815
                        self.subexpr()


                    pass


                self.state = 841
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                if la_ == 1:
                    self.state = 821
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==79:
                        self.state = 820
                        self.match(PS_origParser.L_LEFT)


                    self.state = 823
                    self.match(PS_origParser.L_PAREN)
                    self.state = 824
                    self.func_single_arg()
                    self.state = 826
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==80:
                        self.state = 825
                        self.match(PS_origParser.R_RIGHT)


                    self.state = 828
                    self.match(PS_origParser.R_PAREN)
                    pass

                elif la_ == 2:
                    self.state = 831
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==81:
                        self.state = 830
                        self.match(PS_origParser.ML_LEFT)


                    self.state = 833
                    self.match(PS_origParser.L_PAREN)
                    self.state = 834
                    self.func_single_arg()
                    self.state = 836
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==82:
                        self.state = 835
                        self.match(PS_origParser.MR_RIGHT)


                    self.state = 838
                    self.match(PS_origParser.R_PAREN)
                    pass

                elif la_ == 3:
                    self.state = 840
                    self.func_single_arg_noparens()
                    pass


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 843
                self.func_normal_multi_arg()
                self.state = 856
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
                if la_ == 1:
                    self.state = 845
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==168:
                        self.state = 844
                        self.subexpr()


                    self.state = 848
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==169:
                        self.state = 847
                        self.supexpr()


                    pass

                elif la_ == 2:
                    self.state = 851
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==169:
                        self.state = 850
                        self.supexpr()


                    self.state = 854
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==168:
                        self.state = 853
                        self.subexpr()


                    pass


                self.state = 879
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
                if la_ == 1:
                    self.state = 859
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==79:
                        self.state = 858
                        self.match(PS_origParser.L_LEFT)


                    self.state = 861
                    self.match(PS_origParser.L_PAREN)
                    self.state = 862
                    self.func_multi_arg()
                    self.state = 864
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==80:
                        self.state = 863
                        self.match(PS_origParser.R_RIGHT)


                    self.state = 866
                    self.match(PS_origParser.R_PAREN)
                    pass

                elif la_ == 2:
                    self.state = 869
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==81:
                        self.state = 868
                        self.match(PS_origParser.ML_LEFT)


                    self.state = 871
                    self.match(PS_origParser.L_PAREN)
                    self.state = 872
                    self.func_multi_arg()
                    self.state = 874
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==82:
                        self.state = 873
                        self.match(PS_origParser.MR_RIGHT)


                    self.state = 876
                    self.match(PS_origParser.R_PAREN)
                    pass

                elif la_ == 3:
                    self.state = 878
                    self.func_multi_arg_noparens()
                    pass


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 881
                self.atom_expr_no_supexpr()
                self.state = 883
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==169:
                    self.state = 882
                    self.supexpr()


                self.state = 886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==79:
                    self.state = 885
                    self.match(PS_origParser.L_LEFT)


                self.state = 888
                _la = self._input.LA(1)
                if not(_la==52 or _la==62):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 889
                self.func_common_args()
                self.state = 890
                _la = self._input.LA(1)
                if not(_la==53 or _la==63):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 892
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                if la_ == 1:
                    self.state = 891
                    self.match(PS_origParser.R_RIGHT)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 894
                self.atom_expr_no_supexpr()
                self.state = 896
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==169:
                    self.state = 895
                    self.supexpr()


                self.state = 898
                self.match(PS_origParser.L_BRACE)
                self.state = 900
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==79:
                    self.state = 899
                    self.match(PS_origParser.L_LEFT)


                self.state = 902
                _la = self._input.LA(1)
                if not(_la==52 or _la==62):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 903
                self.func_common_args()
                self.state = 904
                _la = self._input.LA(1)
                if not(_la==53 or _la==63):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 906
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==80:
                    self.state = 905
                    self.match(PS_origParser.R_RIGHT)


                self.state = 908
                self.match(PS_origParser.R_BRACE)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 910
                self.match(PS_origParser.FUNC_INT)
                self.state = 931
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                if la_ == 1:
                    self.state = 911
                    self.subexpr()
                    self.state = 912
                    self.supexpr()

                elif la_ == 2:
                    self.state = 914
                    self.supexpr()
                    self.state = 915
                    self.subexpr()

                elif la_ == 3:
                    self.state = 917
                    self.match(PS_origParser.UNDERSCORE)
                    self.state = 918
                    self.match(PS_origParser.L_BRACE)
                    self.state = 919
                    self.match(PS_origParser.R_BRACE)

                    self.state = 921
                    self.match(PS_origParser.CARET)
                    self.state = 922
                    self.match(PS_origParser.L_BRACE)
                    self.state = 923
                    self.match(PS_origParser.R_BRACE)

                elif la_ == 4:
                    self.state = 924
                    self.match(PS_origParser.CARET)
                    self.state = 925
                    self.match(PS_origParser.L_BRACE)
                    self.state = 926
                    self.match(PS_origParser.R_BRACE)

                    self.state = 928
                    self.match(PS_origParser.UNDERSCORE)
                    self.state = 929
                    self.match(PS_origParser.L_BRACE)
                    self.state = 930
                    self.match(PS_origParser.R_BRACE)


                self.state = 939
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
                if la_ == 1:
                    self.state = 934
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
                    if la_ == 1:
                        self.state = 933
                        self.additive(0)


                    self.state = 936
                    self.match(PS_origParser.DIFFERENTIAL)
                    pass

                elif la_ == 2:
                    self.state = 937
                    self.frac()
                    pass

                elif la_ == 3:
                    self.state = 938
                    self.additive(0)
                    pass


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 941
                self.match(PS_origParser.FUNC_SQRT)
                self.state = 946
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==62:
                    self.state = 942
                    self.match(PS_origParser.L_BRACKET)
                    self.state = 943
                    localctx.root = self.expr()
                    self.state = 944
                    self.match(PS_origParser.R_BRACKET)


                self.state = 948
                self.match(PS_origParser.L_BRACE)
                self.state = 949
                localctx.base = self.expr()
                self.state = 950
                self.match(PS_origParser.R_BRACE)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 952
                _la = self._input.LA(1)
                if not(_la==86 or _la==87):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 959
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [168]:
                    self.state = 953
                    self.subeq()
                    self.state = 954
                    self.supexpr()
                    pass
                elif token in [169]:
                    self.state = 956
                    self.supexpr()
                    self.state = 957
                    self.subeq()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 961
                self.mp(0)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 963
                self.match(PS_origParser.FUNC_LIM)
                self.state = 964
                self.limit_sub()
                self.state = 965
                self.mp(0)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 967
                self.match(PS_origParser.EXP_E)
                self.state = 969
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
                if la_ == 1:
                    self.state = 968
                    self.supexpr()


                pass


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


    class ArgsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def args(self):
            return self.getTypedRuleContext(PS_origParser.ArgsContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_args

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

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




    def args(self):

        localctx = PS_origParser.ArgsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_args)
        try:
            self.state = 978
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 973
                self.expr()
                self.state = 974
                self.match(PS_origParser.COMMA)
                self.state = 975
                self.args()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 977
                self.expr()
                pass


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


    class Func_common_argsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def args(self):
            return self.getTypedRuleContext(PS_origParser.ArgsContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_func_common_args

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

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




    def func_common_args(self):

        localctx = PS_origParser.Func_common_argsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_func_common_args)
        try:
            self.state = 988
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 980
                self.atom()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 981
                self.expr()
                self.state = 982
                self.match(PS_origParser.COMMA)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 984
                self.expr()
                self.state = 985
                self.match(PS_origParser.COMMA)
                self.state = 986
                self.args()
                pass


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


    class Limit_subContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

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

        def LIM_APPROACH_SYM(self):
            return self.getToken(PS_origParser.LIM_APPROACH_SYM, 0)

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


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

        def LETTER_NO_E(self):
            return self.getToken(PS_origParser.LETTER_NO_E, 0)

        def GREEK_CMD(self):
            return self.getToken(PS_origParser.GREEK_CMD, 0)

        def OTHER_SYMBOL_CMD(self):
            return self.getToken(PS_origParser.OTHER_SYMBOL_CMD, 0)

        def CARET(self):
            return self.getToken(PS_origParser.CARET, 0)

        def ADD(self):
            return self.getToken(PS_origParser.ADD, 0)

        def SUB(self):
            return self.getToken(PS_origParser.SUB, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_limit_sub

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

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




    def limit_sub(self):

        localctx = PS_origParser.Limit_subContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_limit_sub)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 990
            self.match(PS_origParser.UNDERSCORE)
            self.state = 991
            self.match(PS_origParser.L_BRACE)
            self.state = 992
            _la = self._input.LA(1)
            if not((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & 98305) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 993
            self.match(PS_origParser.LIM_APPROACH_SYM)
            self.state = 994
            self.expr()
            self.state = 999
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==169:
                self.state = 995
                self.match(PS_origParser.CARET)
                self.state = 996
                self.match(PS_origParser.L_BRACE)
                self.state = 997
                _la = self._input.LA(1)
                if not(_la==48 or _la==49):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 998
                self.match(PS_origParser.R_BRACE)


            self.state = 1001
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_single_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return PS_origParser.RULE_func_single_arg

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

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




    def func_single_arg(self):

        localctx = PS_origParser.Func_single_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_func_single_arg)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1003
            self.expr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_single_arg_noparensContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def mp_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Mp_nofuncContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_func_single_arg_noparens

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

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




    def func_single_arg_noparens(self):

        localctx = PS_origParser.Func_single_arg_noparensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_func_single_arg_noparens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1005
            self.mp_nofunc(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Func_multi_argContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def func_multi_arg(self):
            return self.getTypedRuleContext(PS_origParser.Func_multi_argContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_func_multi_arg

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

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




    def func_multi_arg(self):

        localctx = PS_origParser.Func_multi_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_func_multi_arg)
        try:
            self.state = 1012
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1007
                self.expr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1008
                self.expr()
                self.state = 1009
                self.match(PS_origParser.COMMA)
                self.state = 1010
                self.func_multi_arg()
                pass


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


    class Func_multi_arg_noparensContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def mp_nofunc(self):
            return self.getTypedRuleContext(PS_origParser.Mp_nofuncContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_func_multi_arg_noparens

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

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




    def func_multi_arg_noparens(self):

        localctx = PS_origParser.Func_multi_arg_noparensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_func_multi_arg_noparens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1014
            self.mp_nofunc(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubexprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

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


        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

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


        def args(self):
            return self.getTypedRuleContext(PS_origParser.ArgsContext,0)


        def getRuleIndex(self):
            return PS_origParser.RULE_subexpr

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

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




    def subexpr(self):

        localctx = PS_origParser.SubexprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_subexpr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1016
            self.match(PS_origParser.UNDERSCORE)
            self.state = 1025
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 155, 174, 177, 180, 181, 191, 192, 193, 194, 195]:
                self.state = 1017
                self.atom()
                pass
            elif token in [56]:
                self.state = 1018
                self.match(PS_origParser.L_BRACE)
                self.state = 1021
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
                if la_ == 1:
                    self.state = 1019
                    self.expr()
                    pass

                elif la_ == 2:
                    self.state = 1020
                    self.args()
                    pass


                self.state = 1023
                self.match(PS_origParser.R_BRACE)
                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 SupexprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CARET(self):
            return self.getToken(PS_origParser.CARET, 0)

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


        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

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


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_supexpr

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

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




    def supexpr(self):

        localctx = PS_origParser.SupexprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_supexpr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1027
            self.match(PS_origParser.CARET)
            self.state = 1033
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 155, 174, 177, 180, 181, 191, 192, 193, 194, 195]:
                self.state = 1028
                self.atom()
                pass
            elif token in [56]:
                self.state = 1029
                self.match(PS_origParser.L_BRACE)
                self.state = 1030
                self.expr()
                self.state = 1031
                self.match(PS_origParser.R_BRACE)
                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 SubeqContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def equality(self):
            return self.getTypedRuleContext(PS_origParser.EqualityContext,0)


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_subeq

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

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




    def subeq(self):

        localctx = PS_origParser.SubeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_subeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1035
            self.match(PS_origParser.UNDERSCORE)
            self.state = 1036
            self.match(PS_origParser.L_BRACE)
            self.state = 1037
            self.equality()
            self.state = 1038
            self.match(PS_origParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SupeqContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNDERSCORE(self):
            return self.getToken(PS_origParser.UNDERSCORE, 0)

        def L_BRACE(self):
            return self.getToken(PS_origParser.L_BRACE, 0)

        def equality(self):
            return self.getTypedRuleContext(PS_origParser.EqualityContext,0)


        def R_BRACE(self):
            return self.getToken(PS_origParser.R_BRACE, 0)

        def getRuleIndex(self):
            return PS_origParser.RULE_supeq

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

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




    def supeq(self):

        localctx = PS_origParser.SupeqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_supeq)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1040
            self.match(PS_origParser.UNDERSCORE)
            self.state = 1041
            self.match(PS_origParser.L_BRACE)
            self.state = 1042
            self.equality()
            self.state = 1043
            self.match(PS_origParser.R_BRACE)
        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[12] = self.relation_sempred
        self._predicates[17] = self.additive_sempred
        self._predicates[18] = self.mp_sempred
        self._predicates[19] = self.mp_nofunc_sempred
        self._predicates[28] = self.exp_sempred
        self._predicates[29] = self.exp_nofunc_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 relation_sempred(self, localctx:RelationContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

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

    def mp_sempred(self, localctx:MpContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 2)
         

    def mp_nofunc_sempred(self, localctx:Mp_nofuncContext, predIndex:int):
            if predIndex == 3:
                return self.precpred(self._ctx, 2)
         

    def exp_sempred(self, localctx:ExpContext, predIndex:int):
            if predIndex == 4:
                return self.precpred(self._ctx, 2)
         

    def exp_nofunc_sempred(self, localctx:Exp_nofuncContext, predIndex:int):
            if predIndex == 5:
                return self.precpred(self._ctx, 2)
         




