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

class BOCLParser ( Parser ):

    grammarFileName = "BOCL.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'*'", "'now'", "'today'", "'addDays'", 
                     "'context'", "'inv'", "'pre'", "'post'", "'self'", 
                     "'forAll'", "'exists'", "'select'", "'reject'", "'collect'", 
                     "'OclAny'", "'OclVoid'", "<INVALID>", "<INVALID>", 
                     "'..'", "'::'", "'('", "')'", "'{'", "'}'", "';'", 
                     "':'", "','", "'.'", "'='", "'''", "'Boolean'", "'Integer'", 
                     "'Real'", "'String'", "'if'", "'then'", "'else'", "'endif'", 
                     "'and'", "'or'", "'not'", "'<>'", "'<'", "'<='", "'>'", 
                     "'>='", "'|'", "<INVALID>", "'Bag'", "'Sequence'", 
                     "'OrderedSet'", "'-'", "'+'", "'/'", "' '", "'xor'", 
                     "'implies'", "'oclAsType'", "'oclIsTypeOf'", "'oclIsKindOf'", 
                     "'allInstances'", "'isEmpty'", "'sum'", "'size'", "'includes'", 
                     "'excludes'", "'subSequence'", "'subOrderedSet'", "'prepend'", 
                     "'last'", "'append'", "'symmetricDifference'", "'first'", 
                     "'derive'", "'body'", "'init'", "'union'", "'null'", 
                     "'let'", "'in'", "<INVALID>", "'def'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "CONTEXT", "INV", "PRE", "POST", "SELF", 
                      "FORALL", "EXISTS", "SELECT", "REJECT", "COLLECT", 
                      "OCLANY", "OCLVOID", "DATE", "WS", "DoubleDots", "DoubleCOLON", 
                      "LPAREN", "RPAREN", "LBRACE", "RBRACE", "SEMI", "COLON", 
                      "COMMA", "DOT", "EQUAL", "SingleQuote", "BOOLEAN_TYPE", 
                      "INTEGER_TYPE", "REAL_TYPE", "STRING_TYPE", "IF", 
                      "THEN", "ELSE", "ENDIF", "AND", "OR", "NOT", "NOTEQUAL", 
                      "LT", "LE", "GT", "GE", "PIPE", "SET", "BAG", "SEQUENCE", 
                      "ORDEREDSET", "MINUS", "PLUS", "Divide", "EMPTYSTRING", 
                      "XOR", "IMPLIES", "OCLASTYPE", "OCLISTYPEOF", "OCLISKINDOF", 
                      "ALLINSTANCES", "ISEMPTY", "SUM", "SIZE", "INCLUDES", 
                      "EXCLUDES", "SUBSEQUENCE", "SUBORDEREDSET", "PREPEND", 
                      "LAST", "APPEND", "SYMMETRICDIFFERENCE", "FIRST", 
                      "DERIVE", "BODY", "Init", "UNION", "NULL", "LET", 
                      "IN", "Arrow", "Def", "ID", "NUMBER", "STRING_LITERAL", 
                      "BOOLEAN_LITERAL", "COMMENT", "LINE_COMMENT" ]

    RULE_oclFile = 0
    RULE_contextDeclaration = 1
    RULE_constraint = 2
    RULE_functionCall = 3
    RULE_type = 4
    RULE_collectionType = 5
    RULE_userDefinedType = 6
    RULE_expression = 7
    RULE_endExpression = 8
    RULE_binaryFunctionCall = 9
    RULE_binaryExpression = 10
    RULE_unaryExpression = 11
    RULE_operator = 12
    RULE_numberORUserDefined = 13
    RULE_primaryExpression = 14
    RULE_literal = 15
    RULE_dateLiteral = 16

    ruleNames =  [ "oclFile", "contextDeclaration", "constraint", "functionCall", 
                   "type", "collectionType", "userDefinedType", "expression", 
                   "endExpression", "binaryFunctionCall", "binaryExpression", 
                   "unaryExpression", "operator", "numberORUserDefined", 
                   "primaryExpression", "literal", "dateLiteral" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    CONTEXT=5
    INV=6
    PRE=7
    POST=8
    SELF=9
    FORALL=10
    EXISTS=11
    SELECT=12
    REJECT=13
    COLLECT=14
    OCLANY=15
    OCLVOID=16
    DATE=17
    WS=18
    DoubleDots=19
    DoubleCOLON=20
    LPAREN=21
    RPAREN=22
    LBRACE=23
    RBRACE=24
    SEMI=25
    COLON=26
    COMMA=27
    DOT=28
    EQUAL=29
    SingleQuote=30
    BOOLEAN_TYPE=31
    INTEGER_TYPE=32
    REAL_TYPE=33
    STRING_TYPE=34
    IF=35
    THEN=36
    ELSE=37
    ENDIF=38
    AND=39
    OR=40
    NOT=41
    NOTEQUAL=42
    LT=43
    LE=44
    GT=45
    GE=46
    PIPE=47
    SET=48
    BAG=49
    SEQUENCE=50
    ORDEREDSET=51
    MINUS=52
    PLUS=53
    Divide=54
    EMPTYSTRING=55
    XOR=56
    IMPLIES=57
    OCLASTYPE=58
    OCLISTYPEOF=59
    OCLISKINDOF=60
    ALLINSTANCES=61
    ISEMPTY=62
    SUM=63
    SIZE=64
    INCLUDES=65
    EXCLUDES=66
    SUBSEQUENCE=67
    SUBORDEREDSET=68
    PREPEND=69
    LAST=70
    APPEND=71
    SYMMETRICDIFFERENCE=72
    FIRST=73
    DERIVE=74
    BODY=75
    Init=76
    UNION=77
    NULL=78
    LET=79
    IN=80
    Arrow=81
    Def=82
    ID=83
    NUMBER=84
    STRING_LITERAL=85
    BOOLEAN_LITERAL=86
    COMMENT=87
    LINE_COMMENT=88

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




    class OclFileContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def contextDeclaration(self):
            return self.getTypedRuleContext(BOCLParser.ContextDeclarationContext,0)


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


        def getRuleIndex(self):
            return BOCLParser.RULE_oclFile

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

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




    def oclFile(self):

        localctx = BOCLParser.OclFileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_oclFile)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 34
            self.contextDeclaration()
            self.state = 38
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                self.state = 35
                self.expression()
                self.state = 40
                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 ContextDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return BOCLParser.RULE_contextDeclaration

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



    class ContextExpContext(ContextDeclarationContext):

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

        def CONTEXT(self):
            return self.getToken(BOCLParser.CONTEXT, 0)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.COLON)
            else:
                return self.getToken(BOCLParser.COLON, i)
        def type_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.TypeContext)
            else:
                return self.getTypedRuleContext(BOCLParser.TypeContext,i)

        def LBRACE(self):
            return self.getToken(BOCLParser.LBRACE, 0)
        def constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ConstraintContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ConstraintContext,i)

        def RBRACE(self):
            return self.getToken(BOCLParser.RBRACE, 0)
        def DoubleCOLON(self):
            return self.getToken(BOCLParser.DoubleCOLON, 0)
        def functionCall(self):
            return self.getTypedRuleContext(BOCLParser.FunctionCallContext,0)

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

        def DERIVE(self):
            return self.getToken(BOCLParser.DERIVE, 0)
        def BODY(self):
            return self.getToken(BOCLParser.BODY, 0)
        def Init(self):
            return self.getToken(BOCLParser.Init, 0)
        def PRE(self):
            return self.getToken(BOCLParser.PRE, 0)
        def POST(self):
            return self.getToken(BOCLParser.POST, 0)
        def Def(self):
            return self.getToken(BOCLParser.Def, 0)

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

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



    def contextDeclaration(self):

        localctx = BOCLParser.ContextDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_contextDeclaration)
        self._la = 0 # Token type
        try:
            localctx = BOCLParser.ContextExpContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 41
            self.match(BOCLParser.CONTEXT)
            self.state = 42
            self.match(BOCLParser.ID)
            self.state = 45
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.state = 43
                self.match(BOCLParser.COLON)
                self.state = 44
                self.type_()


            self.state = 48
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==23:
                self.state = 47
                self.match(BOCLParser.LBRACE)


            self.state = 53
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 50
                    self.constraint() 
                self.state = 55
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

            self.state = 57
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==24:
                self.state = 56
                self.match(BOCLParser.RBRACE)


            self.state = 60
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.state = 59
                self.match(BOCLParser.DoubleCOLON)


            self.state = 63
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.state = 62
                self.functionCall()


            self.state = 66
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 65
                self.match(BOCLParser.COLON)


            self.state = 69
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 68
                self.type_()


            self.state = 72
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 71
                self.match(BOCLParser.LPAREN)


            self.state = 75
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.state = 74
                self.match(BOCLParser.ID)


            self.state = 78
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==22:
                self.state = 77
                self.match(BOCLParser.RPAREN)


            self.state = 81
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.state = 80
                self.match(BOCLParser.COLON)


            self.state = 84
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.state = 83
                _la = self._input.LA(1)
                if not(_la==7 or _la==8 or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 263) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 87
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26:
                self.state = 86
                self.match(BOCLParser.COLON)


            self.state = 90
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.state = 89
                self.expression()


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


    class ConstraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def INV(self):
            return self.getToken(BOCLParser.INV, 0)

        def PRE(self):
            return self.getToken(BOCLParser.PRE, 0)

        def POST(self):
            return self.getToken(BOCLParser.POST, 0)

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

        def SEMI(self):
            return self.getToken(BOCLParser.SEMI, 0)

        def getRuleIndex(self):
            return BOCLParser.RULE_constraint

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

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




    def constraint(self):

        localctx = BOCLParser.ConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 92
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 448) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 94
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==83:
                self.state = 93
                self.match(BOCLParser.ID)


            self.state = 96
            self.match(BOCLParser.COLON)
            self.state = 97
            self.expression()
            self.state = 99
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==25:
                self.state = 98
                self.match(BOCLParser.SEMI)


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


    class FunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


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

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

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

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

        def getRuleIndex(self):
            return BOCLParser.RULE_functionCall

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

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




    def functionCall(self):

        localctx = BOCLParser.FunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_functionCall)
        self._la = 0 # Token type
        try:
            self.state = 141
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 101
                self.match(BOCLParser.ID)
                self.state = 102
                self.match(BOCLParser.LPAREN)
                self.state = 115
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                    self.state = 104
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                    if la_ == 1:
                        self.state = 103
                        self.match(BOCLParser.SingleQuote)


                    self.state = 106
                    self.expression()
                    self.state = 108
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
                    if la_ == 1:
                        self.state = 107
                        self.match(BOCLParser.SingleQuote)


                    self.state = 111
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==27:
                        self.state = 110
                        self.match(BOCLParser.COMMA)


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

                self.state = 118
                self.match(BOCLParser.RPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 119
                self.match(BOCLParser.ID)
                self.state = 120
                self.match(BOCLParser.LPAREN)
                self.state = 126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==83:
                    self.state = 121
                    self.match(BOCLParser.ID)
                    self.state = 122
                    self.match(BOCLParser.COLON)
                    self.state = 123
                    self.match(BOCLParser.ID)
                    self.state = 128
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 129
                self.match(BOCLParser.RPAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 130
                self.match(BOCLParser.LPAREN)
                self.state = 137
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==84:
                    self.state = 131
                    self.match(BOCLParser.NUMBER)
                    self.state = 133
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==27:
                        self.state = 132
                        self.match(BOCLParser.COMMA)


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

                self.state = 140
                self.match(BOCLParser.RPAREN)
                pass


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


    class TypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BOOLEAN_TYPE(self):
            return self.getToken(BOCLParser.BOOLEAN_TYPE, 0)

        def INTEGER_TYPE(self):
            return self.getToken(BOCLParser.INTEGER_TYPE, 0)

        def REAL_TYPE(self):
            return self.getToken(BOCLParser.REAL_TYPE, 0)

        def STRING_TYPE(self):
            return self.getToken(BOCLParser.STRING_TYPE, 0)

        def OCLANY(self):
            return self.getToken(BOCLParser.OCLANY, 0)

        def OCLVOID(self):
            return self.getToken(BOCLParser.OCLVOID, 0)

        def collectionType(self):
            return self.getTypedRuleContext(BOCLParser.CollectionTypeContext,0)


        def userDefinedType(self):
            return self.getTypedRuleContext(BOCLParser.UserDefinedTypeContext,0)


        def SET(self):
            return self.getToken(BOCLParser.SET, 0)

        def getRuleIndex(self):
            return BOCLParser.RULE_type

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

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




    def type_(self):

        localctx = BOCLParser.TypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_type)
        try:
            self.state = 152
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 143
                self.match(BOCLParser.BOOLEAN_TYPE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 144
                self.match(BOCLParser.INTEGER_TYPE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 145
                self.match(BOCLParser.REAL_TYPE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 146
                self.match(BOCLParser.STRING_TYPE)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 147
                self.match(BOCLParser.OCLANY)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 148
                self.match(BOCLParser.OCLVOID)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 149
                self.collectionType()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 150
                self.userDefinedType()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 151
                self.match(BOCLParser.SET)
                pass


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


    class CollectionTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SET(self):
            return self.getToken(BOCLParser.SET, 0)

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

        def type_(self):
            return self.getTypedRuleContext(BOCLParser.TypeContext,0)


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

        def BAG(self):
            return self.getToken(BOCLParser.BAG, 0)

        def SEQUENCE(self):
            return self.getToken(BOCLParser.SEQUENCE, 0)

        def ORDEREDSET(self):
            return self.getToken(BOCLParser.ORDEREDSET, 0)

        def getRuleIndex(self):
            return BOCLParser.RULE_collectionType

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

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




    def collectionType(self):

        localctx = BOCLParser.CollectionTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_collectionType)
        try:
            self.state = 174
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [48]:
                self.enterOuterAlt(localctx, 1)
                self.state = 154
                self.match(BOCLParser.SET)
                self.state = 155
                self.match(BOCLParser.LT)
                self.state = 156
                self.type_()
                self.state = 157
                self.match(BOCLParser.GT)
                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 2)
                self.state = 159
                self.match(BOCLParser.BAG)
                self.state = 160
                self.match(BOCLParser.LT)
                self.state = 161
                self.type_()
                self.state = 162
                self.match(BOCLParser.GT)
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 3)
                self.state = 164
                self.match(BOCLParser.SEQUENCE)
                self.state = 165
                self.match(BOCLParser.LT)
                self.state = 166
                self.type_()
                self.state = 167
                self.match(BOCLParser.GT)
                pass
            elif token in [51]:
                self.enterOuterAlt(localctx, 4)
                self.state = 169
                self.match(BOCLParser.ORDEREDSET)
                self.state = 170
                self.match(BOCLParser.LT)
                self.state = 171
                self.type_()
                self.state = 172
                self.match(BOCLParser.GT)
                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 UserDefinedTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return BOCLParser.RULE_userDefinedType

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

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




    def userDefinedType(self):

        localctx = BOCLParser.UserDefinedTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_userDefinedType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 176
            self.match(BOCLParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return BOCLParser.RULE_expression

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



    class ElseExpContext(ExpressionContext):

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

        def ELSE(self):
            return self.getToken(BOCLParser.ELSE, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class ArrowexpContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class COLLECTIONContext(ExpressionContext):

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

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

        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def FORALL(self):
            return self.getToken(BOCLParser.FORALL, 0)
        def EXISTS(self):
            return self.getToken(BOCLParser.EXISTS, 0)
        def SELECT(self):
            return self.getToken(BOCLParser.SELECT, 0)
        def REJECT(self):
            return self.getToken(BOCLParser.REJECT, 0)
        def COLLECT(self):
            return self.getToken(BOCLParser.COLLECT, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def endExpression(self):
            return self.getTypedRuleContext(BOCLParser.EndExpressionContext,0)

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

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

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


    class SETContext(ExpressionContext):

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

        def SET(self):
            return self.getToken(BOCLParser.SET, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def LBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LBRACE)
            else:
                return self.getToken(BOCLParser.LBRACE, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

        def RBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RBRACE)
            else:
                return self.getToken(BOCLParser.RBRACE, i)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def SingleQuote(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.SingleQuote)
            else:
                return self.getToken(BOCLParser.SingleQuote, i)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.COMMA)
            else:
                return self.getToken(BOCLParser.COMMA, i)

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

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


    class DefIDAssignmentexpressionContext(ExpressionContext):

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

        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def COLON(self):
            return self.getToken(BOCLParser.COLON, 0)
        def EQUAL(self):
            return self.getToken(BOCLParser.EQUAL, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class PredefinedfunctionCallContext(ExpressionContext):

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

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class UnaryContext(ExpressionContext):

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

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

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


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

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


    class INCLUDESContext(ExpressionContext):

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

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

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

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

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


    class ThenExpContext(ExpressionContext):

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

        def THEN(self):
            return self.getToken(BOCLParser.THEN, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class SUBORDEREDSETContext(ExpressionContext):

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

        def SUBORDEREDSET(self):
            return self.getToken(BOCLParser.SUBORDEREDSET, 0)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def LBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LBRACE)
            else:
                return self.getToken(BOCLParser.LBRACE, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class PrimaryExpContext(ExpressionContext):

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

        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def primaryExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.PrimaryExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.PrimaryExpressionContext,i)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def operator(self):
            return self.getTypedRuleContext(BOCLParser.OperatorContext,0)

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


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

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


    class OCLISKINDOFContext(ExpressionContext):

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

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

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def OCLISKINDOF(self):
            return self.getToken(BOCLParser.OCLISKINDOF, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def type_(self):
            return self.getTypedRuleContext(BOCLParser.TypeContext,0)

        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class NumberContext(ExpressionContext):

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

        def NUMBER(self):
            return self.getToken(BOCLParser.NUMBER, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class DoubleCOLONsContext(ExpressionContext):

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

        def DoubleCOLON(self):
            return self.getToken(BOCLParser.DoubleCOLON, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)

        def AND(self):
            return self.getToken(BOCLParser.AND, 0)
        def OR(self):
            return self.getToken(BOCLParser.OR, 0)
        def ID(self):
            return self.getToken(BOCLParser.ID, 0)

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

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


    class SYMMETRICDIFFERENCEContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def SYMMETRICDIFFERENCE(self):
            return self.getToken(BOCLParser.SYMMETRICDIFFERENCE, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class SEQUENCEContext(ExpressionContext):

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

        def SEQUENCE(self):
            return self.getToken(BOCLParser.SEQUENCE, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def LBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LBRACE)
            else:
                return self.getToken(BOCLParser.LBRACE, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

        def RBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RBRACE)
            else:
                return self.getToken(BOCLParser.RBRACE, i)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def SingleQuote(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.SingleQuote)
            else:
                return self.getToken(BOCLParser.SingleQuote, i)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.COMMA)
            else:
                return self.getToken(BOCLParser.COMMA, i)

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

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


    class ORDEREDSETContext(ExpressionContext):

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

        def ORDEREDSET(self):
            return self.getToken(BOCLParser.ORDEREDSET, 0)
        def LBRACE(self):
            return self.getToken(BOCLParser.LBRACE, 0)
        def RBRACE(self):
            return self.getToken(BOCLParser.RBRACE, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class DoubleDotsContext(ExpressionContext):

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

        def DoubleDots(self):
            return self.getToken(BOCLParser.DoubleDots, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class EXCLUDESContext(ExpressionContext):

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

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

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

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

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


    class DERIVEContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def DERIVE(self):
            return self.getToken(BOCLParser.DERIVE, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class IDContext(ExpressionContext):

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

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

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


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

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


    class ALLINSTANCESContext(ExpressionContext):

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

        def ALLINSTANCES(self):
            return self.getToken(BOCLParser.ALLINSTANCES, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class OpContext(ExpressionContext):

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

        def operator(self):
            return self.getTypedRuleContext(BOCLParser.OperatorContext,0)

        def numberORUserDefined(self):
            return self.getTypedRuleContext(BOCLParser.NumberORUserDefinedContext,0)


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

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


    class SUBSEQUENCEContext(ExpressionContext):

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

        def SUBSEQUENCE(self):
            return self.getToken(BOCLParser.SUBSEQUENCE, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def LBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LBRACE)
            else:
                return self.getToken(BOCLParser.LBRACE, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def RBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RBRACE)
            else:
                return self.getToken(BOCLParser.RBRACE, i)
        def SingleQuote(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.SingleQuote)
            else:
                return self.getToken(BOCLParser.SingleQuote, i)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.COMMA)
            else:
                return self.getToken(BOCLParser.COMMA, i)

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

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


    class SIZEContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def SIZE(self):
            return self.getToken(BOCLParser.SIZE, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def primaryExpression(self):
            return self.getTypedRuleContext(BOCLParser.PrimaryExpressionContext,0)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def binaryFunctionCall(self):
            return self.getTypedRuleContext(BOCLParser.BinaryFunctionCallContext,0)

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


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

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


    class SingleQuoteExpContext(ExpressionContext):

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

        def SingleQuote(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.SingleQuote)
            else:
                return self.getToken(BOCLParser.SingleQuote, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class BAGContext(ExpressionContext):

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

        def BAG(self):
            return self.getToken(BOCLParser.BAG, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def LBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LBRACE)
            else:
                return self.getToken(BOCLParser.LBRACE, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

        def RBRACE(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RBRACE)
            else:
                return self.getToken(BOCLParser.RBRACE, i)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def SingleQuote(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.SingleQuote)
            else:
                return self.getToken(BOCLParser.SingleQuote, i)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.COMMA)
            else:
                return self.getToken(BOCLParser.COMMA, i)

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

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


    class OCLISTYPEOFContext(ExpressionContext):

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

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

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def OCLISTYPEOF(self):
            return self.getToken(BOCLParser.OCLISTYPEOF, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def type_(self):
            return self.getTypedRuleContext(BOCLParser.TypeContext,0)

        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class SUMContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def SUM(self):
            return self.getToken(BOCLParser.SUM, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def primaryExpression(self):
            return self.getTypedRuleContext(BOCLParser.PrimaryExpressionContext,0)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def binaryFunctionCall(self):
            return self.getTypedRuleContext(BOCLParser.BinaryFunctionCallContext,0)

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


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

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


    class FIRSTContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def FIRST(self):
            return self.getToken(BOCLParser.FIRST, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class APPENDContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def APPEND(self):
            return self.getToken(BOCLParser.APPEND, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class OCLASTYPEContext(ExpressionContext):

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

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

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def OCLASTYPE(self):
            return self.getToken(BOCLParser.OCLASTYPE, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def type_(self):
            return self.getTypedRuleContext(BOCLParser.TypeContext,0)

        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class CollectionExpressionVariableContext(ExpressionContext):

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

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

        def RPAREN(self):
            return self.getToken(BOCLParser.RPAREN, 0)
        def FORALL(self):
            return self.getToken(BOCLParser.FORALL, 0)
        def EXISTS(self):
            return self.getToken(BOCLParser.EXISTS, 0)
        def SELECT(self):
            return self.getToken(BOCLParser.SELECT, 0)
        def REJECT(self):
            return self.getToken(BOCLParser.REJECT, 0)
        def COLLECT(self):
            return self.getToken(BOCLParser.COLLECT, 0)
        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def endExpression(self):
            return self.getTypedRuleContext(BOCLParser.EndExpressionContext,0)


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

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


    class LASTContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def LAST(self):
            return self.getToken(BOCLParser.LAST, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class BinaryContext(ExpressionContext):

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

        def binaryExpression(self):
            return self.getTypedRuleContext(BOCLParser.BinaryExpressionContext,0)

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

        def AND(self):
            return self.getToken(BOCLParser.AND, 0)
        def OR(self):
            return self.getToken(BOCLParser.OR, 0)

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

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


    class IfExpContext(ExpressionContext):

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

        def IF(self):
            return self.getToken(BOCLParser.IF, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class EndIfExpContext(ExpressionContext):

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

        def ENDIF(self):
            return self.getToken(BOCLParser.ENDIF, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class ISEMPTYContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def ISEMPTY(self):
            return self.getToken(BOCLParser.ISEMPTY, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def RPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.RPAREN)
            else:
                return self.getToken(BOCLParser.RPAREN, i)
        def primaryExpression(self):
            return self.getTypedRuleContext(BOCLParser.PrimaryExpressionContext,0)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class DefExpContext(ExpressionContext):

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

        def Def(self):
            return self.getToken(BOCLParser.Def, 0)
        def COLON(self):
            return self.getToken(BOCLParser.COLON, 0)
        def expression(self):
            return self.getTypedRuleContext(BOCLParser.ExpressionContext,0)


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

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


    class FuncCallContext(ExpressionContext):

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

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

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

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.DOT)
            else:
                return self.getToken(BOCLParser.DOT, i)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.ID)
            else:
                return self.getToken(BOCLParser.ID, i)
        def operator(self):
            return self.getTypedRuleContext(BOCLParser.OperatorContext,0)

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


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

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


    class UNIONContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def UNION(self):
            return self.getToken(BOCLParser.UNION, 0)
        def LPAREN(self):
            return self.getToken(BOCLParser.LPAREN, 0)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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


    class PREPENDContext(ExpressionContext):

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

        def Arrow(self):
            return self.getToken(BOCLParser.Arrow, 0)
        def PREPEND(self):
            return self.getToken(BOCLParser.PREPEND, 0)
        def LPAREN(self, i:int=None):
            if i is None:
                return self.getTokens(BOCLParser.LPAREN)
            else:
                return self.getToken(BOCLParser.LPAREN, i)
        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.ExpressionContext,i)

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

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

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



    def expression(self):

        localctx = BOCLParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.state = 910
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
            if la_ == 1:
                localctx = BOCLParser.BinaryContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 179
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==39 or _la==40:
                    self.state = 178
                    _la = self._input.LA(1)
                    if not(_la==39 or _la==40):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 181
                self.binaryExpression()
                self.state = 183
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
                if la_ == 1:
                    self.state = 182
                    self.expression()


                pass

            elif la_ == 2:
                localctx = BOCLParser.UnaryContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 185
                self.unaryExpression()
                self.state = 187
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
                if la_ == 1:
                    self.state = 186
                    self.expression()


                pass

            elif la_ == 3:
                localctx = BOCLParser.IfExpContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 189
                self.match(BOCLParser.IF)
                self.state = 190
                self.expression()
                pass

            elif la_ == 4:
                localctx = BOCLParser.ThenExpContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 191
                self.match(BOCLParser.THEN)
                self.state = 192
                self.expression()
                pass

            elif la_ == 5:
                localctx = BOCLParser.ElseExpContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 193
                self.match(BOCLParser.ELSE)
                self.state = 194
                self.expression()
                pass

            elif la_ == 6:
                localctx = BOCLParser.EndIfExpContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 195
                self.match(BOCLParser.ENDIF)
                self.state = 197
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                if la_ == 1:
                    self.state = 196
                    self.expression()


                pass

            elif la_ == 7:
                localctx = BOCLParser.OCLISTYPEOFContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 199
                self.primaryExpression()
                self.state = 204
                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:
                        self.state = 200
                        self.match(BOCLParser.DOT)
                        self.state = 201
                        self.match(BOCLParser.ID) 
                    self.state = 206
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,32,self._ctx)

                self.state = 207
                self.match(BOCLParser.DOT)
                self.state = 208
                self.match(BOCLParser.OCLISTYPEOF)
                self.state = 209
                self.match(BOCLParser.LPAREN)
                self.state = 210
                self.type_()
                self.state = 211
                self.match(BOCLParser.RPAREN)
                self.state = 213
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
                if la_ == 1:
                    self.state = 212
                    self.expression()


                pass

            elif la_ == 8:
                localctx = BOCLParser.OCLASTYPEContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 215
                self.primaryExpression()
                self.state = 220
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 216
                        self.match(BOCLParser.DOT)
                        self.state = 217
                        self.match(BOCLParser.ID) 
                    self.state = 222
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

                self.state = 223
                self.match(BOCLParser.DOT)
                self.state = 224
                self.match(BOCLParser.OCLASTYPE)
                self.state = 225
                self.match(BOCLParser.LPAREN)
                self.state = 226
                self.type_()
                self.state = 227
                self.match(BOCLParser.RPAREN)
                self.state = 229
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                if la_ == 1:
                    self.state = 228
                    self.expression()


                pass

            elif la_ == 9:
                localctx = BOCLParser.OCLISKINDOFContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 231
                self.primaryExpression()
                self.state = 236
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 232
                        self.match(BOCLParser.DOT)
                        self.state = 233
                        self.match(BOCLParser.ID) 
                    self.state = 238
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

                self.state = 239
                self.match(BOCLParser.DOT)
                self.state = 240
                self.match(BOCLParser.OCLISKINDOF)
                self.state = 241
                self.match(BOCLParser.LPAREN)
                self.state = 242
                self.type_()
                self.state = 243
                self.match(BOCLParser.RPAREN)
                self.state = 245
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
                if la_ == 1:
                    self.state = 244
                    self.expression()


                pass

            elif la_ == 10:
                localctx = BOCLParser.ISEMPTYContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 248
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9 or _la==21 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & 481) != 0):
                    self.state = 247
                    self.primaryExpression()


                self.state = 254
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==28:
                    self.state = 250
                    self.match(BOCLParser.DOT)
                    self.state = 251
                    self.match(BOCLParser.ID)
                    self.state = 256
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 257
                self.match(BOCLParser.Arrow)
                self.state = 258
                self.match(BOCLParser.ISEMPTY)
                self.state = 259
                self.match(BOCLParser.LPAREN)
                self.state = 260
                self.match(BOCLParser.RPAREN)
                self.state = 262
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
                if la_ == 1:
                    self.state = 261
                    self.expression()


                self.state = 267
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 264
                        self.match(BOCLParser.RPAREN) 
                    self.state = 269
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

                pass

            elif la_ == 11:
                localctx = BOCLParser.SUMContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 271
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9 or _la==21 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & 481) != 0):
                    self.state = 270
                    self.primaryExpression()


                self.state = 277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==28:
                    self.state = 273
                    self.match(BOCLParser.DOT)
                    self.state = 274
                    self.match(BOCLParser.ID)
                    self.state = 279
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 280
                self.match(BOCLParser.Arrow)
                self.state = 281
                self.match(BOCLParser.SUM)
                self.state = 282
                self.match(BOCLParser.LPAREN)
                self.state = 283
                self.match(BOCLParser.RPAREN)
                self.state = 285
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
                if la_ == 1:
                    self.state = 284
                    self.binaryFunctionCall()


                self.state = 288
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
                if la_ == 1:
                    self.state = 287
                    self.expression()


                self.state = 293
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 290
                        self.match(BOCLParser.RPAREN) 
                    self.state = 295
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,46,self._ctx)

                pass

            elif la_ == 12:
                localctx = BOCLParser.SIZEContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 297
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9 or _la==21 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & 481) != 0):
                    self.state = 296
                    self.primaryExpression()


                self.state = 303
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==28:
                    self.state = 299
                    self.match(BOCLParser.DOT)
                    self.state = 300
                    self.match(BOCLParser.ID)
                    self.state = 305
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 306
                self.match(BOCLParser.Arrow)
                self.state = 307
                self.match(BOCLParser.SIZE)
                self.state = 308
                self.match(BOCLParser.LPAREN)
                self.state = 309
                self.match(BOCLParser.RPAREN)
                self.state = 311
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
                if la_ == 1:
                    self.state = 310
                    self.binaryFunctionCall()


                self.state = 314
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
                if la_ == 1:
                    self.state = 313
                    self.expression()


                self.state = 319
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,51,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 316
                        self.match(BOCLParser.RPAREN) 
                    self.state = 321
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,51,self._ctx)

                pass

            elif la_ == 13:
                localctx = BOCLParser.INCLUDESContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 323
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 322
                    self.match(BOCLParser.Arrow)


                self.state = 325
                self.match(BOCLParser.INCLUDES)
                self.state = 326
                self.match(BOCLParser.LPAREN)
                self.state = 327
                self.expression()
                self.state = 328
                self.match(BOCLParser.RPAREN)
                self.state = 330
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
                if la_ == 1:
                    self.state = 329
                    self.expression()


                self.state = 335
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,54,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 332
                        self.match(BOCLParser.RPAREN) 
                    self.state = 337
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,54,self._ctx)

                pass

            elif la_ == 14:
                localctx = BOCLParser.EXCLUDESContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 339
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 338
                    self.match(BOCLParser.Arrow)


                self.state = 341
                self.match(BOCLParser.EXCLUDES)
                self.state = 342
                self.match(BOCLParser.LPAREN)
                self.state = 343
                self.expression()
                self.state = 344
                self.match(BOCLParser.RPAREN)
                self.state = 346
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
                if la_ == 1:
                    self.state = 345
                    self.expression()


                self.state = 351
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 348
                        self.match(BOCLParser.RPAREN) 
                    self.state = 353
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,57,self._ctx)

                pass

            elif la_ == 15:
                localctx = BOCLParser.SEQUENCEContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 355
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 354
                    self.match(BOCLParser.Arrow)


                self.state = 360
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==21:
                    self.state = 357
                    self.match(BOCLParser.LPAREN)
                    self.state = 362
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 363
                self.match(BOCLParser.SEQUENCE)
                self.state = 367
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==23:
                    self.state = 364
                    self.match(BOCLParser.LBRACE)
                    self.state = 369
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 373
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 370
                        self.match(BOCLParser.LPAREN) 
                    self.state = 375
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

                self.state = 388
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 377
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
                        if la_ == 1:
                            self.state = 376
                            self.match(BOCLParser.SingleQuote)


                        self.state = 379
                        self.expression()
                        self.state = 381
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
                        if la_ == 1:
                            self.state = 380
                            self.match(BOCLParser.SingleQuote)


                        self.state = 384
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
                        if la_ == 1:
                            self.state = 383
                            self.match(BOCLParser.COMMA)

                 
                    self.state = 390
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,65,self._ctx)

                self.state = 394
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 391
                        self.match(BOCLParser.RBRACE) 
                    self.state = 396
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,66,self._ctx)

                self.state = 400
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,67,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 397
                        self.match(BOCLParser.RPAREN) 
                    self.state = 402
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,67,self._ctx)

                self.state = 404
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 403
                    self.expression()


                pass

            elif la_ == 16:
                localctx = BOCLParser.SUBSEQUENCEContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 407
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 406
                    self.match(BOCLParser.Arrow)


                self.state = 412
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==21:
                    self.state = 409
                    self.match(BOCLParser.LPAREN)
                    self.state = 414
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 415
                self.match(BOCLParser.SUBSEQUENCE)
                self.state = 419
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==23:
                    self.state = 416
                    self.match(BOCLParser.LBRACE)
                    self.state = 421
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 425
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,72,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 422
                        self.match(BOCLParser.LPAREN) 
                    self.state = 427
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,72,self._ctx)

                self.state = 440
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 429
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
                        if la_ == 1:
                            self.state = 428
                            self.match(BOCLParser.SingleQuote)


                        self.state = 431
                        self.expression()
                        self.state = 433
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                        if la_ == 1:
                            self.state = 432
                            self.match(BOCLParser.SingleQuote)


                        self.state = 436
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
                        if la_ == 1:
                            self.state = 435
                            self.match(BOCLParser.COMMA)

                 
                    self.state = 442
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,76,self._ctx)

                self.state = 446
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,77,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 443
                        self.match(BOCLParser.RPAREN) 
                    self.state = 448
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,77,self._ctx)

                self.state = 452
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 449
                        self.match(BOCLParser.RBRACE) 
                    self.state = 454
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,78,self._ctx)

                self.state = 456
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
                if la_ == 1:
                    self.state = 455
                    self.expression()


                pass

            elif la_ == 17:
                localctx = BOCLParser.ALLINSTANCESContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 459
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 458
                    self.match(BOCLParser.Arrow)


                self.state = 461
                self.match(BOCLParser.ALLINSTANCES)
                self.state = 463 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 462
                        self.match(BOCLParser.LPAREN)

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

                self.state = 468
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                    self.state = 467
                    self.expression()


                self.state = 471 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 470
                        self.match(BOCLParser.RPAREN)

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

                self.state = 476
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
                if la_ == 1:
                    self.state = 475
                    self.expression()


                pass

            elif la_ == 18:
                localctx = BOCLParser.ORDEREDSETContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 479
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 478
                    self.match(BOCLParser.Arrow)


                self.state = 484
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==21:
                    self.state = 481
                    self.match(BOCLParser.LPAREN)
                    self.state = 486
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 487
                self.match(BOCLParser.ORDEREDSET)
                self.state = 488
                self.match(BOCLParser.LBRACE)
                self.state = 501
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                    self.state = 490
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
                    if la_ == 1:
                        self.state = 489
                        self.match(BOCLParser.SingleQuote)


                    self.state = 492
                    self.expression()
                    self.state = 494
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
                    if la_ == 1:
                        self.state = 493
                        self.match(BOCLParser.SingleQuote)


                    self.state = 497
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==27:
                        self.state = 496
                        self.match(BOCLParser.COMMA)


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

                self.state = 504
                self.match(BOCLParser.RBRACE)
                self.state = 508
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,91,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 505
                        self.match(BOCLParser.RPAREN) 
                    self.state = 510
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,91,self._ctx)

                self.state = 512
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                if la_ == 1:
                    self.state = 511
                    self.expression()


                pass

            elif la_ == 19:
                localctx = BOCLParser.SUBORDEREDSETContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 514
                    self.match(BOCLParser.Arrow)


                self.state = 520
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==21:
                    self.state = 517
                    self.match(BOCLParser.LPAREN)
                    self.state = 522
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 523
                self.match(BOCLParser.SUBORDEREDSET)
                self.state = 527
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==23:
                    self.state = 524
                    self.match(BOCLParser.LBRACE)
                    self.state = 529
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 533
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,96,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 530
                        self.match(BOCLParser.LPAREN) 
                    self.state = 535
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,96,self._ctx)

                self.state = 548
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,100,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 537
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
                        if la_ == 1:
                            self.state = 536
                            self.match(BOCLParser.SingleQuote)


                        self.state = 539
                        self.expression()
                        self.state = 541
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
                        if la_ == 1:
                            self.state = 540
                            self.match(BOCLParser.SingleQuote)


                        self.state = 544
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==27:
                            self.state = 543
                            self.match(BOCLParser.COMMA)

                 
                    self.state = 550
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,100,self._ctx)

                self.state = 554
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==24:
                    self.state = 551
                    self.match(BOCLParser.RBRACE)
                    self.state = 556
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 560
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,102,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 557
                        self.match(BOCLParser.RPAREN) 
                    self.state = 562
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,102,self._ctx)

                self.state = 564
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                    self.state = 563
                    self.expression()


                self.state = 566
                self.match(BOCLParser.RPAREN)
                pass

            elif la_ == 20:
                localctx = BOCLParser.SETContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 568
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 567
                    self.match(BOCLParser.Arrow)


                self.state = 573
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==21:
                    self.state = 570
                    self.match(BOCLParser.LPAREN)
                    self.state = 575
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 576
                self.match(BOCLParser.SET)
                self.state = 580
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,106,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 577
                        self.match(BOCLParser.LPAREN) 
                    self.state = 582
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,106,self._ctx)

                self.state = 586
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==23:
                    self.state = 583
                    self.match(BOCLParser.LBRACE)
                    self.state = 588
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 601
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,111,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 590
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
                        if la_ == 1:
                            self.state = 589
                            self.match(BOCLParser.SingleQuote)


                        self.state = 592
                        self.expression()
                        self.state = 594
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                        if la_ == 1:
                            self.state = 593
                            self.match(BOCLParser.SingleQuote)


                        self.state = 597
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
                        if la_ == 1:
                            self.state = 596
                            self.match(BOCLParser.COMMA)

                 
                    self.state = 603
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,111,self._ctx)

                self.state = 607
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,112,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 604
                        self.match(BOCLParser.RBRACE) 
                    self.state = 609
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,112,self._ctx)

                self.state = 613
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,113,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 610
                        self.match(BOCLParser.RPAREN) 
                    self.state = 615
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,113,self._ctx)

                self.state = 617
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
                if la_ == 1:
                    self.state = 616
                    self.expression()


                pass

            elif la_ == 21:
                localctx = BOCLParser.BAGContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 620
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 619
                    self.match(BOCLParser.Arrow)


                self.state = 625
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==21:
                    self.state = 622
                    self.match(BOCLParser.LPAREN)
                    self.state = 627
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 628
                self.match(BOCLParser.BAG)
                self.state = 632
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,117,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 629
                        self.match(BOCLParser.LPAREN) 
                    self.state = 634
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,117,self._ctx)

                self.state = 638
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==23:
                    self.state = 635
                    self.match(BOCLParser.LBRACE)
                    self.state = 640
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 653
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,122,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 642
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
                        if la_ == 1:
                            self.state = 641
                            self.match(BOCLParser.SingleQuote)


                        self.state = 644
                        self.expression()
                        self.state = 646
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
                        if la_ == 1:
                            self.state = 645
                            self.match(BOCLParser.SingleQuote)


                        self.state = 649
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
                        if la_ == 1:
                            self.state = 648
                            self.match(BOCLParser.COMMA)

                 
                    self.state = 655
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,122,self._ctx)

                self.state = 659
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,123,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 656
                        self.match(BOCLParser.RBRACE) 
                    self.state = 661
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,123,self._ctx)

                self.state = 665
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,124,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 662
                        self.match(BOCLParser.RPAREN) 
                    self.state = 667
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,124,self._ctx)

                self.state = 669
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
                if la_ == 1:
                    self.state = 668
                    self.expression()


                pass

            elif la_ == 22:
                localctx = BOCLParser.PREPENDContext(self, localctx)
                self.enterOuterAlt(localctx, 22)
                self.state = 671
                self.match(BOCLParser.Arrow)
                self.state = 672
                self.match(BOCLParser.PREPEND)
                self.state = 674 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 673
                        self.match(BOCLParser.LPAREN)

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

                self.state = 690
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                    self.state = 679
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
                    if la_ == 1:
                        self.state = 678
                        self.match(BOCLParser.SingleQuote)


                    self.state = 681
                    self.expression()
                    self.state = 683
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
                    if la_ == 1:
                        self.state = 682
                        self.match(BOCLParser.SingleQuote)


                    self.state = 686
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==27:
                        self.state = 685
                        self.match(BOCLParser.COMMA)


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

                self.state = 694 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 693
                        self.match(BOCLParser.RPAREN)

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

                self.state = 699
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
                if la_ == 1:
                    self.state = 698
                    self.expression()


                pass

            elif la_ == 23:
                localctx = BOCLParser.LASTContext(self, localctx)
                self.enterOuterAlt(localctx, 23)
                self.state = 701
                self.match(BOCLParser.Arrow)
                self.state = 702
                self.match(BOCLParser.LAST)
                self.state = 703
                self.match(BOCLParser.LPAREN)
                self.state = 705 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 704
                        self.match(BOCLParser.RPAREN)

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

                self.state = 710
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                if la_ == 1:
                    self.state = 709
                    self.expression()


                pass

            elif la_ == 24:
                localctx = BOCLParser.APPENDContext(self, localctx)
                self.enterOuterAlt(localctx, 24)
                self.state = 712
                self.match(BOCLParser.Arrow)
                self.state = 713
                self.match(BOCLParser.APPEND)
                self.state = 714
                self.match(BOCLParser.LPAREN)
                self.state = 727
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2593932615400193538) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4136975) != 0):
                    self.state = 716
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
                    if la_ == 1:
                        self.state = 715
                        self.match(BOCLParser.SingleQuote)


                    self.state = 718
                    self.expression()
                    self.state = 720
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                    if la_ == 1:
                        self.state = 719
                        self.match(BOCLParser.SingleQuote)


                    self.state = 723
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==27:
                        self.state = 722
                        self.match(BOCLParser.COMMA)


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

                self.state = 731 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 730
                        self.match(BOCLParser.RPAREN)

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

                self.state = 736
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
                if la_ == 1:
                    self.state = 735
                    self.expression()


                pass

            elif la_ == 25:
                localctx = BOCLParser.COLLECTIONContext(self, localctx)
                self.enterOuterAlt(localctx, 25)
                self.state = 739
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 738
                    self.match(BOCLParser.Arrow)


                self.state = 741
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 31744) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 742
                self.match(BOCLParser.LPAREN)
                self.state = 751 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 743
                    self.match(BOCLParser.ID)
                    self.state = 746
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==26:
                        self.state = 744
                        self.match(BOCLParser.COLON)
                        self.state = 745
                        self.match(BOCLParser.ID)


                    self.state = 749
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==27:
                        self.state = 748
                        self.match(BOCLParser.COMMA)


                    self.state = 753 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==83):
                        break

                self.state = 755
                self.match(BOCLParser.PIPE)
                self.state = 756
                self.expression()
                self.state = 757
                self.match(BOCLParser.RPAREN)
                self.state = 759
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                if la_ == 1:
                    self.state = 758
                    self.endExpression()


                pass

            elif la_ == 26:
                localctx = BOCLParser.CollectionExpressionVariableContext(self, localctx)
                self.enterOuterAlt(localctx, 26)
                self.state = 762
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 761
                    self.match(BOCLParser.Arrow)


                self.state = 764
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 31744) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 765
                self.match(BOCLParser.LPAREN)
                self.state = 766
                self.expression()
                self.state = 767
                self.match(BOCLParser.RPAREN)
                self.state = 769
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
                if la_ == 1:
                    self.state = 768
                    self.endExpression()


                pass

            elif la_ == 27:
                localctx = BOCLParser.SYMMETRICDIFFERENCEContext(self, localctx)
                self.enterOuterAlt(localctx, 27)
                self.state = 771
                self.match(BOCLParser.Arrow)
                self.state = 772
                self.match(BOCLParser.SYMMETRICDIFFERENCE)
                self.state = 773
                self.match(BOCLParser.LPAREN)
                self.state = 774
                self.expression()
                self.state = 776 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 775
                        self.match(BOCLParser.RPAREN)

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

                self.state = 781
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,149,self._ctx)
                if la_ == 1:
                    self.state = 780
                    self.expression()


                pass

            elif la_ == 28:
                localctx = BOCLParser.FIRSTContext(self, localctx)
                self.enterOuterAlt(localctx, 28)
                self.state = 783
                self.match(BOCLParser.Arrow)
                self.state = 784
                self.match(BOCLParser.FIRST)
                self.state = 785
                self.match(BOCLParser.LPAREN)
                self.state = 786
                self.match(BOCLParser.RPAREN)
                self.state = 788
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
                if la_ == 1:
                    self.state = 787
                    self.expression()


                pass

            elif la_ == 29:
                localctx = BOCLParser.DERIVEContext(self, localctx)
                self.enterOuterAlt(localctx, 29)
                self.state = 790
                self.match(BOCLParser.Arrow)
                self.state = 791
                self.match(BOCLParser.DERIVE)
                self.state = 792
                self.match(BOCLParser.LPAREN)
                self.state = 793
                self.match(BOCLParser.RPAREN)
                self.state = 795
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
                if la_ == 1:
                    self.state = 794
                    self.expression()


                pass

            elif la_ == 30:
                localctx = BOCLParser.UNIONContext(self, localctx)
                self.enterOuterAlt(localctx, 30)
                self.state = 797
                self.match(BOCLParser.Arrow)
                self.state = 798
                self.match(BOCLParser.UNION)
                self.state = 799
                self.match(BOCLParser.LPAREN)
                self.state = 800
                self.expression()
                self.state = 801
                self.match(BOCLParser.RPAREN)
                self.state = 803
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,152,self._ctx)
                if la_ == 1:
                    self.state = 802
                    self.expression()


                pass

            elif la_ == 31:
                localctx = BOCLParser.DefExpContext(self, localctx)
                self.enterOuterAlt(localctx, 31)
                self.state = 805
                self.match(BOCLParser.Def)
                self.state = 806
                self.match(BOCLParser.COLON)
                self.state = 807
                self.expression()
                pass

            elif la_ == 32:
                localctx = BOCLParser.DefIDAssignmentexpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 32)
                self.state = 808
                self.match(BOCLParser.ID)
                self.state = 809
                self.match(BOCLParser.COLON)
                self.state = 810
                self.match(BOCLParser.ID)
                self.state = 811
                self.match(BOCLParser.EQUAL)
                self.state = 812
                self.expression()
                pass

            elif la_ == 33:
                localctx = BOCLParser.PrimaryExpContext(self, localctx)
                self.enterOuterAlt(localctx, 33)
                self.state = 816
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 813
                        self.match(BOCLParser.LPAREN) 
                    self.state = 818
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

                self.state = 820
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
                if la_ == 1:
                    self.state = 819
                    self.primaryExpression()


                self.state = 826
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,155,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 822
                        self.match(BOCLParser.DOT)
                        self.state = 823
                        self.match(BOCLParser.ID) 
                    self.state = 828
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,155,self._ctx)

                self.state = 830
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 283864765770498050) != 0):
                    self.state = 829
                    self.operator()


                self.state = 833
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9 or _la==21 or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & 481) != 0):
                    self.state = 832
                    self.primaryExpression()


                self.state = 837 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 835
                        self.match(BOCLParser.DOT)
                        self.state = 836
                        self.match(BOCLParser.ID)

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

                self.state = 842
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
                if la_ == 1:
                    self.state = 841
                    self.expression()


                pass

            elif la_ == 34:
                localctx = BOCLParser.FuncCallContext(self, localctx)
                self.enterOuterAlt(localctx, 34)
                self.state = 844
                self.primaryExpression()
                self.state = 848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==28:
                    self.state = 845
                    self.match(BOCLParser.DOT)
                    self.state = 850
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 854
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,161,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 851
                        self.match(BOCLParser.ID) 
                    self.state = 856
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,161,self._ctx)

                self.state = 857
                self.functionCall()
                self.state = 859
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
                if la_ == 1:
                    self.state = 858
                    self.operator()


                self.state = 862
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
                if la_ == 1:
                    self.state = 861
                    self.expression()


                pass

            elif la_ == 35:
                localctx = BOCLParser.ArrowexpContext(self, localctx)
                self.enterOuterAlt(localctx, 35)
                self.state = 864
                self.match(BOCLParser.Arrow)
                self.state = 865
                self.expression()
                pass

            elif la_ == 36:
                localctx = BOCLParser.NumberContext(self, localctx)
                self.enterOuterAlt(localctx, 36)
                self.state = 866
                self.match(BOCLParser.NUMBER)
                self.state = 868
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
                if la_ == 1:
                    self.state = 867
                    self.expression()


                pass

            elif la_ == 37:
                localctx = BOCLParser.PredefinedfunctionCallContext(self, localctx)
                self.enterOuterAlt(localctx, 37)
                self.state = 871
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==81:
                    self.state = 870
                    self.match(BOCLParser.Arrow)


                self.state = 873
                self.functionCall()
                self.state = 875
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
                if la_ == 1:
                    self.state = 874
                    self.expression()


                pass

            elif la_ == 38:
                localctx = BOCLParser.SingleQuoteExpContext(self, localctx)
                self.enterOuterAlt(localctx, 38)
                self.state = 877
                self.match(BOCLParser.SingleQuote)
                self.state = 878
                self.expression()
                self.state = 880
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==28:
                    self.state = 879
                    self.match(BOCLParser.DOT)


                self.state = 882
                self.match(BOCLParser.SingleQuote)
                self.state = 884
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
                if la_ == 1:
                    self.state = 883
                    self.match(BOCLParser.DOT)


                self.state = 887
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
                if la_ == 1:
                    self.state = 886
                    self.expression()


                pass

            elif la_ == 39:
                localctx = BOCLParser.DoubleDotsContext(self, localctx)
                self.enterOuterAlt(localctx, 39)
                self.state = 889
                self.match(BOCLParser.DoubleDots)
                self.state = 890
                self.expression()
                pass

            elif la_ == 40:
                localctx = BOCLParser.DoubleCOLONsContext(self, localctx)
                self.enterOuterAlt(localctx, 40)
                self.state = 892
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==39:
                    self.state = 891
                    self.match(BOCLParser.AND)


                self.state = 895
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==40:
                    self.state = 894
                    self.match(BOCLParser.OR)


                self.state = 898
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==83:
                    self.state = 897
                    self.match(BOCLParser.ID)


                self.state = 900
                self.match(BOCLParser.DoubleCOLON)
                self.state = 901
                self.expression()
                pass

            elif la_ == 41:
                localctx = BOCLParser.OpContext(self, localctx)
                self.enterOuterAlt(localctx, 41)
                self.state = 902
                self.operator()
                self.state = 904
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
                if la_ == 1:
                    self.state = 903
                    self.numberORUserDefined()


                pass

            elif la_ == 42:
                localctx = BOCLParser.IDContext(self, localctx)
                self.enterOuterAlt(localctx, 42)
                self.state = 906
                self.primaryExpression()
                self.state = 908
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                if la_ == 1:
                    self.state = 907
                    self.expression()


                pass


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


    class EndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def AND(self):
            return self.getToken(BOCLParser.AND, 0)

        def OR(self):
            return self.getToken(BOCLParser.OR, 0)

        def getRuleIndex(self):
            return BOCLParser.RULE_endExpression

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

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




    def endExpression(self):

        localctx = BOCLParser.EndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_endExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 913
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,176,self._ctx)
            if la_ == 1:
                self.state = 912
                _la = self._input.LA(1)
                if not(_la==39 or _la==40):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class BinaryFunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def operator(self):
            return self.getTypedRuleContext(BOCLParser.OperatorContext,0)


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

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


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

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

        def getRuleIndex(self):
            return BOCLParser.RULE_binaryFunctionCall

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

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




    def binaryFunctionCall(self):

        localctx = BOCLParser.BinaryFunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_binaryFunctionCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 917
            self.operator()
            self.state = 927
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.state = 918
                self.primaryExpression()
                self.state = 923
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,177,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 919
                        self.match(BOCLParser.DOT)
                        self.state = 920
                        self.match(BOCLParser.ID) 
                    self.state = 925
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,177,self._ctx)

                pass

            elif la_ == 2:
                self.state = 926
                self.match(BOCLParser.NUMBER)
                pass


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


    class BinaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def operator(self):
            return self.getTypedRuleContext(BOCLParser.OperatorContext,0)


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

        def dateLiteral(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.DateLiteralContext)
            else:
                return self.getTypedRuleContext(BOCLParser.DateLiteralContext,i)


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

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

        def primaryExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BOCLParser.PrimaryExpressionContext)
            else:
                return self.getTypedRuleContext(BOCLParser.PrimaryExpressionContext,i)


        def getRuleIndex(self):
            return BOCLParser.RULE_binaryExpression

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

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




    def binaryExpression(self):

        localctx = BOCLParser.BinaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_binaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 939
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 929
                self.primaryExpression()
                self.state = 934
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,179,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 930
                        self.match(BOCLParser.DOT)
                        self.state = 931
                        self.match(BOCLParser.ID) 
                    self.state = 936
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,179,self._ctx)

                pass

            elif la_ == 2:
                self.state = 937
                self.match(BOCLParser.NUMBER)
                pass

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


            self.state = 945
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==28:
                self.state = 941
                self.match(BOCLParser.DOT)
                self.state = 942
                self.match(BOCLParser.ID)
                self.state = 947
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 948
            self.operator()
            self.state = 959
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
            if la_ == 1:
                self.state = 949
                self.primaryExpression()
                self.state = 954
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,182,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 950
                        self.match(BOCLParser.DOT)
                        self.state = 951
                        self.match(BOCLParser.ID) 
                    self.state = 956
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,182,self._ctx)

                pass

            elif la_ == 2:
                self.state = 957
                self.match(BOCLParser.NUMBER)
                pass

            elif la_ == 3:
                self.state = 958
                self.dateLiteral()
                pass


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


    class UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def NOT(self):
            return self.getToken(BOCLParser.NOT, 0)

        def MINUS(self):
            return self.getToken(BOCLParser.MINUS, 0)

        def PLUS(self):
            return self.getToken(BOCLParser.PLUS, 0)

        def Divide(self):
            return self.getToken(BOCLParser.Divide, 0)

        def getRuleIndex(self):
            return BOCLParser.RULE_unaryExpression

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

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




    def unaryExpression(self):

        localctx = BOCLParser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_unaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 961
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 31527396414849026) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 962
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def NOTEQUAL(self):
            return self.getToken(BOCLParser.NOTEQUAL, 0)

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

        def LE(self):
            return self.getToken(BOCLParser.LE, 0)

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

        def GE(self):
            return self.getToken(BOCLParser.GE, 0)

        def PLUS(self):
            return self.getToken(BOCLParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(BOCLParser.MINUS, 0)

        def EMPTYSTRING(self):
            return self.getToken(BOCLParser.EMPTYSTRING, 0)

        def Divide(self):
            return self.getToken(BOCLParser.Divide, 0)

        def AND(self):
            return self.getToken(BOCLParser.AND, 0)

        def OR(self):
            return self.getToken(BOCLParser.OR, 0)

        def XOR(self):
            return self.getToken(BOCLParser.XOR, 0)

        def IMPLIES(self):
            return self.getToken(BOCLParser.IMPLIES, 0)

        def getRuleIndex(self):
            return BOCLParser.RULE_operator

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

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




    def operator(self):

        localctx = BOCLParser.OperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 964
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 283864765770498050) != 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 NumberORUserDefinedContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

        def getRuleIndex(self):
            return BOCLParser.RULE_numberORUserDefined

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

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




    def numberORUserDefined(self):

        localctx = BOCLParser.NumberORUserDefinedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_numberORUserDefined)
        self._la = 0 # Token type
        try:
            self.state = 980
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [84]:
                self.enterOuterAlt(localctx, 1)
                self.state = 966
                self.match(BOCLParser.NUMBER)
                pass
            elif token in [30, 83]:
                self.enterOuterAlt(localctx, 2)
                self.state = 968
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==30:
                    self.state = 967
                    self.match(BOCLParser.SingleQuote)


                self.state = 970
                self.match(BOCLParser.ID)
                self.state = 972
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
                if la_ == 1:
                    self.state = 971
                    self.match(BOCLParser.LPAREN)


                self.state = 975
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 974
                    self.match(BOCLParser.RPAREN)


                self.state = 978
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
                if la_ == 1:
                    self.state = 977
                    self.match(BOCLParser.SingleQuote)


                pass
            else:
                raise NoViableAltException(self)

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


    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def literal(self):
            return self.getTypedRuleContext(BOCLParser.LiteralContext,0)


        def SELF(self):
            return self.getToken(BOCLParser.SELF, 0)

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


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

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


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

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

        def getRuleIndex(self):
            return BOCLParser.RULE_primaryExpression

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

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




    def primaryExpression(self):

        localctx = BOCLParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_primaryExpression)
        try:
            self.state = 990
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 982
                self.literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 983
                self.match(BOCLParser.SELF)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 984
                self.functionCall()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 985
                self.match(BOCLParser.LPAREN)
                self.state = 986
                self.expression()
                self.state = 987
                self.match(BOCLParser.RPAREN)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 989
                self.match(BOCLParser.ID)
                pass


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


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def STRING_LITERAL(self):
            return self.getToken(BOCLParser.STRING_LITERAL, 0)

        def BOOLEAN_LITERAL(self):
            return self.getToken(BOCLParser.BOOLEAN_LITERAL, 0)

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

        def getRuleIndex(self):
            return BOCLParser.RULE_literal

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

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




    def literal(self):

        localctx = BOCLParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 992
            _la = self._input.LA(1)
            if not(((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & 449) != 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 DateLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATE(self):
            return self.getToken(BOCLParser.DATE, 0)

        def DoubleCOLON(self):
            return self.getToken(BOCLParser.DoubleCOLON, 0)

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

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

        def DOT(self):
            return self.getToken(BOCLParser.DOT, 0)

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

        def getRuleIndex(self):
            return BOCLParser.RULE_dateLiteral

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

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




    def dateLiteral(self):

        localctx = BOCLParser.DateLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_dateLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 994
            self.match(BOCLParser.DATE)
            self.state = 996
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.state = 995
                self.match(BOCLParser.DoubleCOLON)


            self.state = 999
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==2 or _la==3:
                self.state = 998
                _la = self._input.LA(1)
                if not(_la==2 or _la==3):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1002
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
            if la_ == 1:
                self.state = 1001
                self.match(BOCLParser.LPAREN)


            self.state = 1005
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
            if la_ == 1:
                self.state = 1004
                self.match(BOCLParser.RPAREN)


            self.state = 1008
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.state = 1007
                self.match(BOCLParser.DOT)


            self.state = 1011
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 1010
                self.match(BOCLParser.T__3)


            self.state = 1014
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
            if la_ == 1:
                self.state = 1013
                self.match(BOCLParser.LPAREN)


            self.state = 1017
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
            if la_ == 1:
                self.state = 1016
                self.match(BOCLParser.NUMBER)


            self.state = 1020
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1019
                self.match(BOCLParser.RPAREN)


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





