# Copyright (c) 2023, 2025, Oracle and/or its affiliates.
# 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,215,2051,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,
        7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
        2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
        7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,
        2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,
        7,175,2,176,7,176,2,177,7,177,1,0,1,0,4,0,359,8,0,11,0,12,0,360,
        1,0,5,0,364,8,0,10,0,12,0,367,9,0,3,0,369,8,0,1,0,3,0,372,8,0,1,
        0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
        1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,436,8,
        1,1,2,1,2,1,3,1,3,1,4,1,4,3,4,444,8,4,1,5,3,5,447,8,5,1,5,1,5,1,
        5,1,6,1,6,1,6,1,7,1,7,1,7,1,8,1,8,3,8,460,8,8,1,8,1,8,1,9,1,9,1,
        9,1,9,1,9,1,10,1,10,1,11,1,11,3,11,473,8,11,1,11,1,11,1,11,1,12,
        1,12,3,12,480,8,12,1,12,1,12,1,12,1,13,1,13,1,13,1,13,3,13,489,8,
        13,1,13,3,13,492,8,13,1,14,1,14,1,14,1,14,3,14,498,8,14,1,15,1,15,
        1,15,4,15,503,8,15,11,15,12,15,504,1,16,1,16,1,16,3,16,510,8,16,
        1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,523,
        8,17,3,17,525,8,17,1,17,1,17,3,17,529,8,17,1,18,1,18,1,18,1,18,1,
        18,1,18,1,18,1,18,1,18,4,18,540,8,18,11,18,12,18,541,1,19,1,19,1,
        20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,5,21,554,8,21,10,21,12,21,
        557,9,21,1,22,1,22,1,22,1,23,1,23,1,23,1,24,1,24,1,24,1,25,1,25,
        1,25,1,25,1,26,1,26,1,26,1,26,1,26,3,26,577,8,26,1,27,1,27,1,27,
        1,27,1,27,1,27,3,27,585,8,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,
        593,8,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
        3,29,606,8,29,3,29,608,8,29,1,29,3,29,611,8,29,1,29,1,29,3,29,615,
        8,29,1,29,3,29,618,8,29,1,29,1,29,1,29,3,29,623,8,29,1,30,1,30,1,
        30,1,30,1,30,1,30,4,30,631,8,30,11,30,12,30,632,1,31,1,31,1,31,1,
        31,1,31,3,31,640,8,31,1,31,3,31,643,8,31,1,31,1,31,1,31,1,31,3,31,
        649,8,31,1,31,3,31,652,8,31,1,31,1,31,1,31,1,31,3,31,658,8,31,3,
        31,660,8,31,1,31,1,31,1,31,3,31,665,8,31,1,31,1,31,1,31,1,31,3,31,
        671,8,31,1,31,3,31,674,8,31,1,31,3,31,677,8,31,1,31,3,31,680,8,31,
        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,4,32,691,8,32,11,32,
        12,32,692,1,33,1,33,1,33,1,33,3,33,699,8,33,1,34,1,34,1,34,1,35,
        1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,
        1,36,3,36,719,8,36,3,36,721,8,36,1,36,1,36,1,36,3,36,726,8,36,1,
        36,1,36,1,36,3,36,731,8,36,1,36,1,36,3,36,735,8,36,1,36,3,36,738,
        8,36,1,36,5,36,741,8,36,10,36,12,36,744,9,36,1,36,3,36,747,8,36,
        1,37,1,37,3,37,751,8,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,38,
        1,38,1,38,1,38,1,38,1,38,3,38,766,8,38,3,38,768,8,38,1,38,1,38,1,
        38,3,38,773,8,38,1,38,1,38,1,38,3,38,778,8,38,1,38,1,38,3,38,782,
        8,38,1,38,3,38,785,8,38,1,38,3,38,788,8,38,1,38,3,38,791,8,38,1,
        39,1,39,3,39,795,8,39,1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,40,1,
        40,1,40,1,40,1,40,1,40,1,40,1,40,3,40,812,8,40,3,40,814,8,40,1,40,
        1,40,1,40,3,40,819,8,40,1,40,3,40,822,8,40,1,40,1,40,3,40,826,8,
        40,1,40,3,40,829,8,40,1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,4,
        42,839,8,42,11,42,12,42,840,1,43,1,43,1,43,1,44,1,44,3,44,848,8,
        44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,
        45,1,45,1,45,3,45,865,8,45,3,45,867,8,45,1,45,1,45,1,45,3,45,872,
        8,45,1,45,3,45,875,8,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,883,8,
        45,1,45,1,45,3,45,887,8,45,1,45,3,45,890,8,45,1,46,1,46,1,46,4,46,
        895,8,46,11,46,12,46,896,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,
        1,47,1,47,1,47,1,47,1,47,3,47,912,8,47,3,47,914,8,47,1,47,1,47,1,
        47,1,47,1,47,3,47,921,8,47,1,47,3,47,924,8,47,1,48,1,48,1,49,1,49,
        1,50,1,50,1,50,1,50,1,50,1,50,1,50,4,50,937,8,50,11,50,12,50,938,
        1,51,1,51,3,51,943,8,51,1,51,1,51,1,51,1,51,1,51,3,51,950,8,51,1,
        52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,55,1,
        55,1,55,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,3,
        56,978,8,56,3,56,980,8,56,1,56,1,56,1,56,1,56,1,56,1,56,3,56,988,
        8,56,1,56,3,56,991,8,56,1,57,1,57,1,58,1,58,1,59,1,59,1,59,4,59,
        1000,8,59,11,59,12,59,1001,1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,
        62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,1022,8,
        62,3,62,1024,8,62,1,62,1,62,1,62,3,62,1029,8,62,1,62,3,62,1032,8,
        62,1,62,3,62,1035,8,62,1,63,1,63,4,63,1039,8,63,11,63,12,63,1040,
        1,64,1,64,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,1,66,
        1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,1064,8,67,1,67,3,67,
        1067,8,67,1,68,1,68,1,68,1,68,3,68,1073,8,68,1,68,1,68,3,68,1077,
        8,68,1,68,3,68,1080,8,68,1,68,1,68,1,68,1,68,3,68,1086,8,68,1,68,
        1,68,3,68,1090,8,68,1,68,3,68,1093,8,68,1,69,1,69,1,69,3,69,1098,
        8,69,1,69,3,69,1101,8,69,1,69,1,69,1,69,1,69,3,69,1107,8,69,1,69,
        1,69,1,69,1,69,3,69,1113,8,69,1,69,1,69,1,69,3,69,1118,8,69,1,69,
        3,69,1121,8,69,3,69,1123,8,69,1,69,3,69,1126,8,69,1,70,1,70,1,70,
        1,70,1,70,1,70,3,70,1134,8,70,1,70,1,70,1,70,1,70,3,70,1140,8,70,
        1,70,1,70,3,70,1144,8,70,1,70,3,70,1147,8,70,1,70,5,70,1150,8,70,
        10,70,12,70,1153,9,70,1,70,3,70,1156,8,70,1,71,1,71,1,71,1,71,1,
        71,1,71,3,71,1164,8,71,1,71,1,71,1,71,1,71,3,71,1170,8,71,1,71,1,
        71,3,71,1174,8,71,1,71,3,71,1177,8,71,1,71,5,71,1180,8,71,10,71,
        12,71,1183,9,71,1,71,3,71,1186,8,71,1,72,1,72,1,72,1,72,1,72,1,72,
        1,72,3,72,1195,8,72,1,72,3,72,1198,8,72,1,72,1,72,1,72,1,72,3,72,
        1204,8,72,1,72,3,72,1207,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,
        1,73,3,73,1217,8,73,1,73,3,73,1220,8,73,1,74,1,74,1,75,1,75,1,75,
        1,75,1,75,1,75,1,75,1,75,1,75,3,75,1233,8,75,1,75,3,75,1236,8,75,
        1,76,1,76,1,76,1,76,1,76,3,76,1243,8,76,1,76,1,76,1,77,1,77,1,77,
        1,77,1,77,3,77,1252,8,77,1,77,1,77,1,77,3,77,1257,8,77,1,77,3,77,
        1260,8,77,1,78,1,78,1,78,3,78,1265,8,78,1,78,3,78,1268,8,78,1,78,
        1,78,1,78,3,78,1273,8,78,1,78,1,78,1,78,3,78,1278,8,78,1,79,1,79,
        1,79,1,79,1,79,3,79,1285,8,79,1,79,1,79,1,79,3,79,1290,8,79,1,80,
        1,80,1,80,1,80,1,80,3,80,1297,8,80,1,80,1,80,1,80,3,80,1302,8,80,
        1,81,1,81,1,81,1,81,1,81,1,81,3,81,1310,8,81,1,81,1,81,1,81,3,81,
        1315,8,81,1,81,3,81,1318,8,81,1,82,1,82,1,82,1,82,1,82,1,82,3,82,
        1326,8,82,1,82,1,82,1,82,3,82,1331,8,82,1,82,3,82,1334,8,82,1,82,
        1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1346,8,83,1,83,
        1,83,1,84,1,84,1,84,1,84,1,84,3,84,1355,8,84,1,84,1,84,1,84,1,84,
        1,85,1,85,1,85,1,85,1,85,3,85,1366,8,85,1,85,1,85,3,85,1370,8,85,
        1,86,1,86,1,86,1,86,1,86,3,86,1377,8,86,1,86,1,86,1,86,1,86,1,86,
        3,86,1384,8,86,3,86,1386,8,86,1,86,1,86,1,86,3,86,1391,8,86,1,87,
        1,87,1,87,1,87,1,87,3,87,1398,8,87,1,88,1,88,1,89,1,89,1,89,1,89,
        1,89,3,89,1407,8,89,1,89,1,89,1,89,1,89,1,89,3,89,1414,8,89,1,90,
        1,90,1,90,1,90,1,90,3,90,1421,8,90,1,90,1,90,1,90,1,90,1,90,3,90,
        1428,8,90,3,90,1430,8,90,1,90,1,90,1,90,3,90,1435,8,90,1,91,1,91,
        1,91,1,91,1,91,3,91,1442,8,91,1,91,1,91,1,91,1,91,1,91,1,92,1,92,
        1,92,1,92,1,93,1,93,1,93,3,93,1456,8,93,1,94,1,94,1,94,3,94,1461,
        8,94,1,94,1,94,1,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,3,96,
        1474,8,96,1,96,3,96,1477,8,96,1,97,1,97,1,97,3,97,1482,8,97,1,97,
        3,97,1485,8,97,1,97,1,97,1,97,3,97,1490,8,97,1,98,1,98,1,98,1,98,
        1,98,3,98,1497,8,98,1,99,1,99,1,99,1,99,1,99,3,99,1504,8,99,1,100,
        1,100,1,100,1,100,1,100,1,100,3,100,1512,8,100,1,100,3,100,1515,
        8,100,1,101,1,101,1,101,1,101,1,101,1,101,3,101,1523,8,101,1,101,
        3,101,1526,8,101,1,101,1,101,1,101,1,101,1,102,1,102,1,102,1,102,
        1,102,1,102,3,102,1538,8,102,1,102,3,102,1541,8,102,1,103,1,103,
        1,103,1,103,1,103,1,103,1,103,3,103,1550,8,103,1,103,3,103,1553,
        8,103,3,103,1555,8,103,1,103,1,103,3,103,1559,8,103,1,103,1,103,
        3,103,1563,8,103,1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,104,
        1,104,3,104,1574,8,104,1,104,3,104,1577,8,104,3,104,1579,8,104,1,
        105,1,105,1,105,1,105,1,105,3,105,1586,8,105,1,105,1,105,1,105,3,
        105,1591,8,105,1,106,1,106,1,106,1,106,1,106,3,106,1598,8,106,1,
        106,1,106,3,106,1602,8,106,1,106,3,106,1605,8,106,1,107,1,107,1,
        107,1,107,3,107,1611,8,107,1,107,3,107,1614,8,107,1,107,1,107,1,
        107,1,107,3,107,1620,8,107,1,108,1,108,1,108,1,108,1,108,1,108,1,
        108,3,108,1629,8,108,1,109,1,109,1,109,1,109,1,109,1,109,1,109,3,
        109,1638,8,109,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,3,
        110,1648,8,110,1,110,3,110,1651,8,110,1,111,1,111,1,111,1,111,1,
        111,1,111,1,111,1,111,3,111,1661,8,111,1,111,3,111,1664,8,111,1,
        111,1,111,1,111,1,111,1,112,1,112,1,112,1,112,1,112,1,112,1,112,
        1,113,1,113,1,113,1,113,1,113,1,113,3,113,1683,8,113,1,114,1,114,
        1,114,1,114,1,114,1,114,1,114,1,114,1,115,1,115,1,115,1,115,1,115,
        1,115,3,115,1699,8,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,
        3,115,1708,8,115,3,115,1710,8,115,1,115,3,115,1713,8,115,1,115,1,
        115,1,115,3,115,1718,8,115,1,115,1,115,1,116,1,116,1,116,1,116,1,
        116,1,116,1,116,4,116,1729,8,116,11,116,12,116,1730,1,116,5,116,
        1734,8,116,10,116,12,116,1737,9,116,1,116,3,116,1740,8,116,1,116,
        1,116,3,116,1744,8,116,1,116,1,116,1,117,1,117,1,117,1,117,1,117,
        3,117,1753,8,117,1,117,1,117,1,117,1,118,1,118,1,118,1,118,1,118,
        3,118,1763,8,118,1,118,1,118,1,119,1,119,1,119,1,119,1,119,1,119,
        1,119,1,119,3,119,1775,8,119,3,119,1777,8,119,1,119,3,119,1780,8,
        119,1,119,1,119,1,120,1,120,1,120,1,120,3,120,1788,8,120,1,121,1,
        121,1,121,1,121,1,121,1,121,1,121,4,121,1797,8,121,11,121,12,121,
        1798,1,122,1,122,1,123,1,123,1,124,1,124,1,125,1,125,1,126,1,126,
        1,127,1,127,1,128,3,128,1814,8,128,1,128,1,128,1,129,3,129,1819,
        8,129,1,129,1,129,1,130,1,130,1,131,1,131,1,132,1,132,1,133,1,133,
        1,134,1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,138,1,138,1,139,
        1,139,1,140,1,140,1,141,1,141,1,142,1,142,1,143,1,143,1,144,1,144,
        1,145,1,145,1,146,1,146,1,147,1,147,1,148,1,148,1,148,5,148,1862,
        8,148,10,148,12,148,1865,9,148,1,148,1,148,1,149,1,149,1,149,1,149,
        3,149,1873,8,149,1,150,1,150,1,150,1,150,3,150,1879,8,150,1,151,
        1,151,1,151,1,151,5,151,1885,8,151,10,151,12,151,1888,9,151,1,151,
        1,151,1,151,1,151,3,151,1894,8,151,1,152,1,152,1,152,1,152,1,153,
        1,153,1,153,1,153,5,153,1904,8,153,10,153,12,153,1907,9,153,3,153,
        1909,8,153,1,153,1,153,1,154,1,154,3,154,1915,8,154,1,154,1,154,
        1,154,1,154,1,154,1,154,1,154,3,154,1924,8,154,1,155,1,155,1,155,
        1,155,5,155,1930,8,155,10,155,12,155,1933,9,155,1,155,1,155,1,155,
        1,155,3,155,1939,8,155,1,156,4,156,1942,8,156,11,156,12,156,1943,
        1,157,1,157,1,157,1,157,3,157,1950,8,157,1,157,3,157,1953,8,157,
        1,157,1,157,1,157,1,157,1,157,3,157,1960,8,157,1,157,3,157,1963,
        8,157,1,157,3,157,1966,8,157,1,157,3,157,1969,8,157,1,158,4,158,
        1972,8,158,11,158,12,158,1973,1,159,1,159,1,159,1,159,1,160,1,160,
        1,161,1,161,1,161,3,161,1985,8,161,1,162,1,162,3,162,1989,8,162,
        1,163,1,163,3,163,1993,8,163,1,164,1,164,3,164,1997,8,164,1,165,
        1,165,3,165,2001,8,165,1,166,1,166,1,167,1,167,1,168,1,168,1,169,
        1,169,1,169,3,169,2012,8,169,1,170,1,170,1,171,1,171,1,171,5,171,
        2019,8,171,10,171,12,171,2022,9,171,1,172,1,172,1,172,1,172,1,173,
        1,173,3,173,2030,8,173,1,174,1,174,1,174,3,174,2035,8,174,3,174,
        2037,8,174,1,175,1,175,1,175,1,176,1,176,1,176,3,176,2045,8,176,
        1,177,1,177,3,177,2049,8,177,1,177,0,0,178,0,2,4,6,8,10,12,14,16,
        18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,
        62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,
        104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,
        136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,
        168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,
        200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230,
        232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,
        264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,
        296,298,300,302,304,306,308,310,312,314,316,318,320,322,324,326,
        328,330,332,334,336,338,340,342,344,346,348,350,352,354,0,17,2,0,
        85,85,87,87,2,0,85,85,87,88,2,0,86,86,89,89,1,0,91,92,2,0,101,101,
        103,104,2,0,21,21,106,106,2,0,62,62,108,108,1,0,56,57,3,0,1,1,35,
        35,51,52,1,0,8,9,2,0,63,63,131,131,1,0,166,167,2,0,141,143,151,155,
        1,0,138,140,3,0,142,142,144,147,156,156,6,0,1,33,35,65,67,67,71,
        71,76,125,215,215,2,0,205,205,207,207,2238,0,368,1,0,0,0,2,435,1,
        0,0,0,4,437,1,0,0,0,6,439,1,0,0,0,8,443,1,0,0,0,10,446,1,0,0,0,12,
        451,1,0,0,0,14,454,1,0,0,0,16,457,1,0,0,0,18,463,1,0,0,0,20,468,
        1,0,0,0,22,472,1,0,0,0,24,479,1,0,0,0,26,484,1,0,0,0,28,493,1,0,
        0,0,30,502,1,0,0,0,32,506,1,0,0,0,34,524,1,0,0,0,36,539,1,0,0,0,
        38,543,1,0,0,0,40,545,1,0,0,0,42,548,1,0,0,0,44,558,1,0,0,0,46,561,
        1,0,0,0,48,564,1,0,0,0,50,567,1,0,0,0,52,571,1,0,0,0,54,578,1,0,
        0,0,56,586,1,0,0,0,58,607,1,0,0,0,60,630,1,0,0,0,62,659,1,0,0,0,
        64,690,1,0,0,0,66,694,1,0,0,0,68,700,1,0,0,0,70,703,1,0,0,0,72,720,
        1,0,0,0,74,748,1,0,0,0,76,767,1,0,0,0,78,792,1,0,0,0,80,813,1,0,
        0,0,82,830,1,0,0,0,84,838,1,0,0,0,86,842,1,0,0,0,88,845,1,0,0,0,
        90,866,1,0,0,0,92,894,1,0,0,0,94,913,1,0,0,0,96,925,1,0,0,0,98,927,
        1,0,0,0,100,936,1,0,0,0,102,942,1,0,0,0,104,951,1,0,0,0,106,955,
        1,0,0,0,108,959,1,0,0,0,110,963,1,0,0,0,112,979,1,0,0,0,114,992,
        1,0,0,0,116,994,1,0,0,0,118,999,1,0,0,0,120,1003,1,0,0,0,122,1007,
        1,0,0,0,124,1023,1,0,0,0,126,1038,1,0,0,0,128,1042,1,0,0,0,130,1044,
        1,0,0,0,132,1046,1,0,0,0,134,1055,1,0,0,0,136,1068,1,0,0,0,138,1094,
        1,0,0,0,140,1127,1,0,0,0,142,1157,1,0,0,0,144,1187,1,0,0,0,146,1208,
        1,0,0,0,148,1221,1,0,0,0,150,1223,1,0,0,0,152,1237,1,0,0,0,154,1246,
        1,0,0,0,156,1261,1,0,0,0,158,1279,1,0,0,0,160,1291,1,0,0,0,162,1303,
        1,0,0,0,164,1319,1,0,0,0,166,1339,1,0,0,0,168,1349,1,0,0,0,170,1360,
        1,0,0,0,172,1371,1,0,0,0,174,1397,1,0,0,0,176,1399,1,0,0,0,178,1401,
        1,0,0,0,180,1415,1,0,0,0,182,1436,1,0,0,0,184,1448,1,0,0,0,186,1455,
        1,0,0,0,188,1457,1,0,0,0,190,1464,1,0,0,0,192,1468,1,0,0,0,194,1478,
        1,0,0,0,196,1491,1,0,0,0,198,1498,1,0,0,0,200,1505,1,0,0,0,202,1516,
        1,0,0,0,204,1531,1,0,0,0,206,1542,1,0,0,0,208,1564,1,0,0,0,210,1580,
        1,0,0,0,212,1592,1,0,0,0,214,1606,1,0,0,0,216,1621,1,0,0,0,218,1630,
        1,0,0,0,220,1639,1,0,0,0,222,1652,1,0,0,0,224,1669,1,0,0,0,226,1676,
        1,0,0,0,228,1684,1,0,0,0,230,1692,1,0,0,0,232,1721,1,0,0,0,234,1747,
        1,0,0,0,236,1757,1,0,0,0,238,1766,1,0,0,0,240,1783,1,0,0,0,242,1796,
        1,0,0,0,244,1800,1,0,0,0,246,1802,1,0,0,0,248,1804,1,0,0,0,250,1806,
        1,0,0,0,252,1808,1,0,0,0,254,1810,1,0,0,0,256,1813,1,0,0,0,258,1818,
        1,0,0,0,260,1822,1,0,0,0,262,1824,1,0,0,0,264,1826,1,0,0,0,266,1828,
        1,0,0,0,268,1830,1,0,0,0,270,1832,1,0,0,0,272,1834,1,0,0,0,274,1836,
        1,0,0,0,276,1838,1,0,0,0,278,1840,1,0,0,0,280,1842,1,0,0,0,282,1844,
        1,0,0,0,284,1846,1,0,0,0,286,1848,1,0,0,0,288,1850,1,0,0,0,290,1852,
        1,0,0,0,292,1854,1,0,0,0,294,1856,1,0,0,0,296,1858,1,0,0,0,298,1872,
        1,0,0,0,300,1878,1,0,0,0,302,1893,1,0,0,0,304,1895,1,0,0,0,306,1899,
        1,0,0,0,308,1923,1,0,0,0,310,1938,1,0,0,0,312,1941,1,0,0,0,314,1945,
        1,0,0,0,316,1971,1,0,0,0,318,1975,1,0,0,0,320,1979,1,0,0,0,322,1984,
        1,0,0,0,324,1988,1,0,0,0,326,1992,1,0,0,0,328,1996,1,0,0,0,330,2000,
        1,0,0,0,332,2002,1,0,0,0,334,2004,1,0,0,0,336,2006,1,0,0,0,338,2011,
        1,0,0,0,340,2013,1,0,0,0,342,2015,1,0,0,0,344,2023,1,0,0,0,346,2027,
        1,0,0,0,348,2031,1,0,0,0,350,2038,1,0,0,0,352,2044,1,0,0,0,354,2048,
        1,0,0,0,356,365,3,2,1,0,357,359,5,182,0,0,358,357,1,0,0,0,359,360,
        1,0,0,0,360,358,1,0,0,0,360,361,1,0,0,0,361,362,1,0,0,0,362,364,
        3,2,1,0,363,358,1,0,0,0,364,367,1,0,0,0,365,363,1,0,0,0,365,366,
        1,0,0,0,366,369,1,0,0,0,367,365,1,0,0,0,368,356,1,0,0,0,368,369,
        1,0,0,0,369,371,1,0,0,0,370,372,5,182,0,0,371,370,1,0,0,0,371,372,
        1,0,0,0,372,373,1,0,0,0,373,374,5,0,0,1,374,1,1,0,0,0,375,436,3,
        28,14,0,376,436,3,34,17,0,377,436,3,58,29,0,378,436,3,62,31,0,379,
        436,3,72,36,0,380,436,3,76,38,0,381,436,3,80,40,0,382,436,3,90,45,
        0,383,436,3,94,47,0,384,436,3,124,62,0,385,436,3,112,56,0,386,436,
        3,132,66,0,387,436,3,134,67,0,388,436,3,136,68,0,389,436,3,138,69,
        0,390,436,3,140,70,0,391,436,3,142,71,0,392,436,3,144,72,0,393,436,
        3,146,73,0,394,436,3,150,75,0,395,436,3,152,76,0,396,436,3,154,77,
        0,397,436,3,156,78,0,398,436,3,158,79,0,399,436,3,160,80,0,400,436,
        3,162,81,0,401,436,3,164,82,0,402,436,3,166,83,0,403,436,3,168,84,
        0,404,436,3,170,85,0,405,436,3,230,115,0,406,436,3,232,116,0,407,
        436,3,178,89,0,408,436,3,172,86,0,409,436,3,234,117,0,410,436,3,
        236,118,0,411,436,3,180,90,0,412,436,3,182,91,0,413,436,3,184,92,
        0,414,436,3,188,94,0,415,436,3,190,95,0,416,436,3,192,96,0,417,436,
        3,194,97,0,418,436,3,196,98,0,419,436,3,198,99,0,420,436,3,200,100,
        0,421,436,3,202,101,0,422,436,3,204,102,0,423,436,3,206,103,0,424,
        436,3,208,104,0,425,436,3,210,105,0,426,436,3,212,106,0,427,436,
        3,214,107,0,428,436,3,216,108,0,429,436,3,218,109,0,430,436,3,220,
        110,0,431,436,3,222,111,0,432,436,3,224,112,0,433,436,3,226,113,
        0,434,436,3,228,114,0,435,375,1,0,0,0,435,376,1,0,0,0,435,377,1,
        0,0,0,435,378,1,0,0,0,435,379,1,0,0,0,435,380,1,0,0,0,435,381,1,
        0,0,0,435,382,1,0,0,0,435,383,1,0,0,0,435,384,1,0,0,0,435,385,1,
        0,0,0,435,386,1,0,0,0,435,387,1,0,0,0,435,388,1,0,0,0,435,389,1,
        0,0,0,435,390,1,0,0,0,435,391,1,0,0,0,435,392,1,0,0,0,435,393,1,
        0,0,0,435,394,1,0,0,0,435,395,1,0,0,0,435,396,1,0,0,0,435,397,1,
        0,0,0,435,398,1,0,0,0,435,399,1,0,0,0,435,400,1,0,0,0,435,401,1,
        0,0,0,435,402,1,0,0,0,435,403,1,0,0,0,435,404,1,0,0,0,435,405,1,
        0,0,0,435,406,1,0,0,0,435,407,1,0,0,0,435,408,1,0,0,0,435,409,1,
        0,0,0,435,410,1,0,0,0,435,411,1,0,0,0,435,412,1,0,0,0,435,413,1,
        0,0,0,435,414,1,0,0,0,435,415,1,0,0,0,435,416,1,0,0,0,435,417,1,
        0,0,0,435,418,1,0,0,0,435,419,1,0,0,0,435,420,1,0,0,0,435,421,1,
        0,0,0,435,422,1,0,0,0,435,423,1,0,0,0,435,424,1,0,0,0,435,425,1,
        0,0,0,435,426,1,0,0,0,435,427,1,0,0,0,435,428,1,0,0,0,435,429,1,
        0,0,0,435,430,1,0,0,0,435,431,1,0,0,0,435,432,1,0,0,0,435,433,1,
        0,0,0,435,434,1,0,0,0,436,3,1,0,0,0,437,438,7,0,0,0,438,5,1,0,0,
        0,439,440,7,1,0,0,440,7,1,0,0,0,441,444,3,352,176,0,442,444,5,24,
        0,0,443,441,1,0,0,0,443,442,1,0,0,0,444,9,1,0,0,0,445,447,5,70,0,
        0,446,445,1,0,0,0,446,447,1,0,0,0,447,448,1,0,0,0,448,449,5,26,0,
        0,449,450,3,308,154,0,450,11,1,0,0,0,451,452,5,78,0,0,452,453,3,
        308,154,0,453,13,1,0,0,0,454,455,5,71,0,0,455,456,3,352,176,0,456,
        15,1,0,0,0,457,459,5,21,0,0,458,460,5,28,0,0,459,458,1,0,0,0,459,
        460,1,0,0,0,460,461,1,0,0,0,461,462,5,97,0,0,462,17,1,0,0,0,463,
        464,5,98,0,0,464,465,5,99,0,0,465,466,5,30,0,0,466,467,3,20,10,0,
        467,19,1,0,0,0,468,469,5,200,0,0,469,21,1,0,0,0,470,471,5,80,0,0,
        471,473,3,256,128,0,472,470,1,0,0,0,472,473,1,0,0,0,473,474,1,0,
        0,0,474,475,5,12,0,0,475,476,3,262,131,0,476,23,1,0,0,0,477,478,
        5,80,0,0,478,480,3,260,130,0,479,477,1,0,0,0,479,480,1,0,0,0,480,
        481,1,0,0,0,481,482,5,12,0,0,482,483,3,266,133,0,483,25,1,0,0,0,
        484,491,5,8,0,0,485,486,5,61,0,0,486,492,5,80,0,0,487,489,5,80,0,
        0,488,487,1,0,0,0,488,489,1,0,0,0,489,490,1,0,0,0,490,492,3,256,
        128,0,491,485,1,0,0,0,491,488,1,0,0,0,492,27,1,0,0,0,493,494,5,76,
        0,0,494,495,5,77,0,0,495,497,5,78,0,0,496,498,3,30,15,0,497,496,
        1,0,0,0,497,498,1,0,0,0,498,29,1,0,0,0,499,503,3,4,2,0,500,503,3,
        10,5,0,501,503,3,32,16,0,502,499,1,0,0,0,502,500,1,0,0,0,502,501,
        1,0,0,0,503,504,1,0,0,0,504,502,1,0,0,0,504,505,1,0,0,0,505,31,1,
        0,0,0,506,509,5,35,0,0,507,508,5,27,0,0,508,510,5,96,0,0,509,507,
        1,0,0,0,509,510,1,0,0,0,510,33,1,0,0,0,511,512,5,1,0,0,512,513,5,
        2,0,0,513,514,5,3,0,0,514,515,5,77,0,0,515,525,5,80,0,0,516,517,
        5,1,0,0,517,518,5,77,0,0,518,522,5,80,0,0,519,520,5,27,0,0,520,521,
        5,28,0,0,521,523,5,29,0,0,522,519,1,0,0,0,522,523,1,0,0,0,523,525,
        1,0,0,0,524,511,1,0,0,0,524,516,1,0,0,0,525,526,1,0,0,0,526,528,
        3,256,128,0,527,529,3,36,18,0,528,527,1,0,0,0,528,529,1,0,0,0,529,
        35,1,0,0,0,530,540,3,4,2,0,531,540,3,38,19,0,532,540,3,40,20,0,533,
        540,3,42,21,0,534,540,3,10,5,0,535,540,3,14,7,0,536,540,3,12,6,0,
        537,540,3,54,27,0,538,540,3,56,28,0,539,530,1,0,0,0,539,531,1,0,
        0,0,539,532,1,0,0,0,539,533,1,0,0,0,539,534,1,0,0,0,539,535,1,0,
        0,0,539,536,1,0,0,0,539,537,1,0,0,0,539,538,1,0,0,0,540,541,1,0,
        0,0,541,539,1,0,0,0,541,542,1,0,0,0,542,37,1,0,0,0,543,544,7,2,0,
        0,544,39,1,0,0,0,545,546,5,90,0,0,546,547,7,3,0,0,547,41,1,0,0,0,
        548,555,5,21,0,0,549,554,3,44,22,0,550,554,3,46,23,0,551,554,3,48,
        24,0,552,554,3,50,25,0,553,549,1,0,0,0,553,550,1,0,0,0,553,551,1,
        0,0,0,553,552,1,0,0,0,554,557,1,0,0,0,555,553,1,0,0,0,555,556,1,
        0,0,0,556,43,1,0,0,0,557,555,1,0,0,0,558,559,5,22,0,0,559,560,3,
        8,4,0,560,45,1,0,0,0,561,562,5,94,0,0,562,563,3,8,4,0,563,47,1,0,
        0,0,564,565,5,23,0,0,565,566,3,8,4,0,566,49,1,0,0,0,567,568,5,30,
        0,0,568,569,5,100,0,0,569,570,3,8,4,0,570,51,1,0,0,0,571,572,5,25,
        0,0,572,573,5,95,0,0,573,576,5,12,0,0,574,577,3,332,166,0,575,577,
        5,24,0,0,576,574,1,0,0,0,576,575,1,0,0,0,577,53,1,0,0,0,578,579,
        5,68,0,0,579,580,5,106,0,0,580,581,5,108,0,0,581,584,3,96,48,0,582,
        583,5,27,0,0,583,585,5,29,0,0,584,582,1,0,0,0,584,585,1,0,0,0,585,
        55,1,0,0,0,586,587,5,69,0,0,587,588,5,106,0,0,588,589,5,108,0,0,
        589,592,3,96,48,0,590,591,5,27,0,0,591,593,5,29,0,0,592,590,1,0,
        0,0,592,593,1,0,0,0,593,57,1,0,0,0,594,595,5,1,0,0,595,596,5,2,0,
        0,596,597,5,3,0,0,597,598,5,77,0,0,598,608,5,12,0,0,599,600,5,1,
        0,0,600,601,5,77,0,0,601,605,5,12,0,0,602,603,5,27,0,0,603,604,5,
        28,0,0,604,606,5,29,0,0,605,602,1,0,0,0,605,606,1,0,0,0,606,608,
        1,0,0,0,607,594,1,0,0,0,607,599,1,0,0,0,608,610,1,0,0,0,609,611,
        3,262,131,0,610,609,1,0,0,0,610,611,1,0,0,0,611,617,1,0,0,0,612,
        614,5,8,0,0,613,615,5,80,0,0,614,613,1,0,0,0,614,615,1,0,0,0,615,
        616,1,0,0,0,616,618,3,256,128,0,617,612,1,0,0,0,617,618,1,0,0,0,
        618,619,1,0,0,0,619,620,5,9,0,0,620,622,3,332,166,0,621,623,3,60,
        30,0,622,621,1,0,0,0,622,623,1,0,0,0,623,59,1,0,0,0,624,631,3,6,
        3,0,625,631,3,16,8,0,626,631,3,18,9,0,627,631,3,10,5,0,628,631,3,
        14,7,0,629,631,3,12,6,0,630,624,1,0,0,0,630,625,1,0,0,0,630,626,
        1,0,0,0,630,627,1,0,0,0,630,628,1,0,0,0,630,629,1,0,0,0,631,632,
        1,0,0,0,632,630,1,0,0,0,632,633,1,0,0,0,633,61,1,0,0,0,634,635,5,
        1,0,0,635,636,5,2,0,0,636,637,5,3,0,0,637,639,5,77,0,0,638,640,5,
        48,0,0,639,638,1,0,0,0,639,640,1,0,0,0,640,642,1,0,0,0,641,643,5,
        120,0,0,642,641,1,0,0,0,642,643,1,0,0,0,643,644,1,0,0,0,644,660,
        5,14,0,0,645,646,5,1,0,0,646,648,5,77,0,0,647,649,5,48,0,0,648,647,
        1,0,0,0,648,649,1,0,0,0,649,651,1,0,0,0,650,652,5,120,0,0,651,650,
        1,0,0,0,651,652,1,0,0,0,652,653,1,0,0,0,653,657,5,14,0,0,654,655,
        5,27,0,0,655,656,5,28,0,0,656,658,5,29,0,0,657,654,1,0,0,0,657,658,
        1,0,0,0,658,660,1,0,0,0,659,634,1,0,0,0,659,645,1,0,0,0,660,661,
        1,0,0,0,661,664,3,268,134,0,662,663,5,8,0,0,663,665,3,22,11,0,664,
        662,1,0,0,0,664,665,1,0,0,0,665,666,1,0,0,0,666,667,5,19,0,0,667,
        670,3,346,173,0,668,669,5,117,0,0,669,671,3,272,136,0,670,668,1,
        0,0,0,670,671,1,0,0,0,671,673,1,0,0,0,672,674,3,312,156,0,673,672,
        1,0,0,0,673,674,1,0,0,0,674,676,1,0,0,0,675,677,3,310,155,0,676,
        675,1,0,0,0,676,677,1,0,0,0,677,679,1,0,0,0,678,680,3,64,32,0,679,
        678,1,0,0,0,679,680,1,0,0,0,680,63,1,0,0,0,681,691,3,6,3,0,682,691,
        3,16,8,0,683,691,3,18,9,0,684,691,3,10,5,0,685,691,3,14,7,0,686,
        691,3,12,6,0,687,691,3,66,33,0,688,691,3,68,34,0,689,691,3,70,35,
        0,690,681,1,0,0,0,690,682,1,0,0,0,690,683,1,0,0,0,690,684,1,0,0,
        0,690,685,1,0,0,0,690,686,1,0,0,0,690,687,1,0,0,0,690,688,1,0,0,
        0,690,689,1,0,0,0,691,692,1,0,0,0,692,690,1,0,0,0,692,693,1,0,0,
        0,693,65,1,0,0,0,694,695,5,101,0,0,695,698,5,32,0,0,696,699,3,352,
        176,0,697,699,5,102,0,0,698,696,1,0,0,0,698,697,1,0,0,0,699,67,1,
        0,0,0,700,701,5,33,0,0,701,702,7,4,0,0,702,69,1,0,0,0,703,704,5,
        21,0,0,704,705,5,15,0,0,705,706,3,346,173,0,706,71,1,0,0,0,707,708,
        5,1,0,0,708,709,5,2,0,0,709,710,5,3,0,0,710,711,5,77,0,0,711,721,
        5,15,0,0,712,713,5,1,0,0,713,714,5,77,0,0,714,718,5,15,0,0,715,716,
        5,27,0,0,716,717,5,28,0,0,717,719,5,29,0,0,718,715,1,0,0,0,718,719,
        1,0,0,0,719,721,1,0,0,0,720,707,1,0,0,0,720,712,1,0,0,0,721,722,
        1,0,0,0,722,725,3,280,140,0,723,724,5,8,0,0,724,726,3,22,11,0,725,
        723,1,0,0,0,725,726,1,0,0,0,726,727,1,0,0,0,727,728,5,19,0,0,728,
        730,3,346,173,0,729,731,5,34,0,0,730,729,1,0,0,0,730,731,1,0,0,0,
        731,737,1,0,0,0,732,734,5,67,0,0,733,735,3,272,136,0,734,733,1,0,
        0,0,734,735,1,0,0,0,735,736,1,0,0,0,736,738,3,310,155,0,737,732,
        1,0,0,0,737,738,1,0,0,0,738,742,1,0,0,0,739,741,3,74,37,0,740,739,
        1,0,0,0,741,744,1,0,0,0,742,740,1,0,0,0,742,743,1,0,0,0,743,746,
        1,0,0,0,744,742,1,0,0,0,745,747,3,64,32,0,746,745,1,0,0,0,746,747,
        1,0,0,0,747,73,1,0,0,0,748,750,5,84,0,0,749,751,3,274,137,0,750,
        749,1,0,0,0,750,751,1,0,0,0,751,752,1,0,0,0,752,753,3,310,155,0,
        753,75,1,0,0,0,754,755,5,1,0,0,755,756,5,2,0,0,756,757,5,3,0,0,757,
        758,5,77,0,0,758,768,5,16,0,0,759,760,5,1,0,0,760,761,5,77,0,0,761,
        765,5,16,0,0,762,763,5,27,0,0,763,764,5,28,0,0,764,766,5,29,0,0,
        765,762,1,0,0,0,765,766,1,0,0,0,766,768,1,0,0,0,767,754,1,0,0,0,
        767,759,1,0,0,0,768,769,1,0,0,0,769,772,3,282,141,0,770,771,5,8,
        0,0,771,773,3,22,11,0,772,770,1,0,0,0,772,773,1,0,0,0,773,774,1,
        0,0,0,774,775,5,19,0,0,775,777,3,346,173,0,776,778,5,34,0,0,777,
        776,1,0,0,0,777,778,1,0,0,0,778,784,1,0,0,0,779,781,5,67,0,0,780,
        782,3,272,136,0,781,780,1,0,0,0,781,782,1,0,0,0,782,783,1,0,0,0,
        783,785,3,310,155,0,784,779,1,0,0,0,784,785,1,0,0,0,785,787,1,0,
        0,0,786,788,3,78,39,0,787,786,1,0,0,0,787,788,1,0,0,0,788,790,1,
        0,0,0,789,791,3,64,32,0,790,789,1,0,0,0,790,791,1,0,0,0,791,77,1,
        0,0,0,792,794,5,84,0,0,793,795,3,274,137,0,794,793,1,0,0,0,794,795,
        1,0,0,0,795,796,1,0,0,0,796,797,3,310,155,0,797,79,1,0,0,0,798,799,
        5,1,0,0,799,800,5,2,0,0,800,801,5,3,0,0,801,802,5,77,0,0,802,803,
        5,100,0,0,803,814,5,39,0,0,804,805,5,1,0,0,805,806,5,77,0,0,806,
        807,5,100,0,0,807,811,5,39,0,0,808,809,5,27,0,0,809,810,5,28,0,0,
        810,812,5,29,0,0,811,808,1,0,0,0,811,812,1,0,0,0,812,814,1,0,0,0,
        813,798,1,0,0,0,813,804,1,0,0,0,814,815,1,0,0,0,815,821,3,288,144,
        0,816,818,5,8,0,0,817,819,5,80,0,0,818,817,1,0,0,0,818,819,1,0,0,
        0,819,820,1,0,0,0,820,822,3,256,128,0,821,816,1,0,0,0,821,822,1,
        0,0,0,822,825,1,0,0,0,823,824,5,9,0,0,824,826,3,82,41,0,825,823,
        1,0,0,0,825,826,1,0,0,0,826,828,1,0,0,0,827,829,3,84,42,0,828,827,
        1,0,0,0,828,829,1,0,0,0,829,81,1,0,0,0,830,831,3,352,176,0,831,83,
        1,0,0,0,832,839,3,6,3,0,833,839,3,16,8,0,834,839,3,10,5,0,835,839,
        3,14,7,0,836,839,3,86,43,0,837,839,3,88,44,0,838,832,1,0,0,0,838,
        833,1,0,0,0,838,834,1,0,0,0,838,835,1,0,0,0,838,836,1,0,0,0,838,
        837,1,0,0,0,839,840,1,0,0,0,840,838,1,0,0,0,840,841,1,0,0,0,841,
        85,1,0,0,0,842,843,5,44,0,0,843,844,3,352,176,0,844,87,1,0,0,0,845,
        847,5,49,0,0,846,848,5,121,0,0,847,846,1,0,0,0,847,848,1,0,0,0,848,
        849,1,0,0,0,849,850,5,119,0,0,850,89,1,0,0,0,851,852,5,1,0,0,852,
        853,5,2,0,0,853,854,5,3,0,0,854,855,5,77,0,0,855,856,5,100,0,0,856,
        867,5,46,0,0,857,858,5,1,0,0,858,859,5,77,0,0,859,860,5,100,0,0,
        860,864,5,46,0,0,861,862,5,27,0,0,862,863,5,28,0,0,863,865,5,29,
        0,0,864,861,1,0,0,0,864,865,1,0,0,0,865,867,1,0,0,0,866,851,1,0,
        0,0,866,857,1,0,0,0,867,868,1,0,0,0,868,869,3,292,146,0,869,874,
        5,8,0,0,870,872,5,80,0,0,871,870,1,0,0,0,871,872,1,0,0,0,872,873,
        1,0,0,0,873,875,3,256,128,0,874,871,1,0,0,0,874,875,1,0,0,0,875,
        876,1,0,0,0,876,877,5,100,0,0,877,878,5,39,0,0,878,886,3,288,144,
        0,879,880,5,9,0,0,880,887,3,82,41,0,881,883,5,47,0,0,882,881,1,0,
        0,0,882,883,1,0,0,0,883,884,1,0,0,0,884,885,5,100,0,0,885,887,3,
        352,176,0,886,879,1,0,0,0,886,882,1,0,0,0,887,889,1,0,0,0,888,890,
        3,92,46,0,889,888,1,0,0,0,889,890,1,0,0,0,890,91,1,0,0,0,891,895,
        3,6,3,0,892,895,3,16,8,0,893,895,3,10,5,0,894,891,1,0,0,0,894,892,
        1,0,0,0,894,893,1,0,0,0,895,896,1,0,0,0,896,894,1,0,0,0,896,897,
        1,0,0,0,897,93,1,0,0,0,898,899,5,1,0,0,899,900,5,2,0,0,900,901,5,
        3,0,0,901,902,5,77,0,0,902,903,7,5,0,0,903,914,5,108,0,0,904,905,
        5,1,0,0,905,906,5,77,0,0,906,907,7,5,0,0,907,911,5,108,0,0,908,909,
        5,27,0,0,909,910,5,28,0,0,910,912,5,29,0,0,911,908,1,0,0,0,911,912,
        1,0,0,0,912,914,1,0,0,0,913,898,1,0,0,0,913,904,1,0,0,0,914,915,
        1,0,0,0,915,916,3,96,48,0,916,920,5,111,0,0,917,921,5,112,0,0,918,
        921,5,113,0,0,919,921,3,98,49,0,920,917,1,0,0,0,920,918,1,0,0,0,
        920,919,1,0,0,0,921,923,1,0,0,0,922,924,3,100,50,0,923,922,1,0,0,
        0,923,924,1,0,0,0,924,95,1,0,0,0,925,926,3,354,177,0,926,97,1,0,
        0,0,927,928,3,354,177,0,928,99,1,0,0,0,929,937,3,4,2,0,930,937,3,
        14,7,0,931,937,3,102,51,0,932,937,3,104,52,0,933,937,3,106,53,0,
        934,937,3,108,54,0,935,937,3,110,55,0,936,929,1,0,0,0,936,930,1,
        0,0,0,936,931,1,0,0,0,936,932,1,0,0,0,936,933,1,0,0,0,936,934,1,
        0,0,0,936,935,1,0,0,0,937,938,1,0,0,0,938,936,1,0,0,0,938,939,1,
        0,0,0,939,101,1,0,0,0,940,941,5,65,0,0,941,943,5,28,0,0,942,940,
        1,0,0,0,942,943,1,0,0,0,943,944,1,0,0,0,944,945,5,115,0,0,945,946,
        5,7,0,0,946,949,5,114,0,0,947,948,5,43,0,0,948,950,5,116,0,0,949,
        947,1,0,0,0,949,950,1,0,0,0,950,103,1,0,0,0,951,952,5,24,0,0,952,
        953,5,42,0,0,953,954,3,354,177,0,954,105,1,0,0,0,955,956,7,6,0,0,
        956,957,5,109,0,0,957,958,3,352,176,0,958,107,1,0,0,0,959,960,7,
        6,0,0,960,961,5,110,0,0,961,962,3,352,176,0,962,109,1,0,0,0,963,
        964,5,63,0,0,964,965,3,352,176,0,965,111,1,0,0,0,966,967,5,1,0,0,
        967,968,5,2,0,0,968,969,5,3,0,0,969,970,5,77,0,0,970,980,5,25,0,
        0,971,972,5,1,0,0,972,973,5,77,0,0,973,977,5,25,0,0,974,975,5,27,
        0,0,975,976,5,28,0,0,976,978,5,29,0,0,977,974,1,0,0,0,977,978,1,
        0,0,0,978,980,1,0,0,0,979,966,1,0,0,0,979,971,1,0,0,0,980,981,1,
        0,0,0,981,982,3,114,57,0,982,983,5,193,0,0,983,987,3,96,48,0,984,
        985,5,40,0,0,985,986,5,41,0,0,986,988,3,116,58,0,987,984,1,0,0,0,
        987,988,1,0,0,0,988,990,1,0,0,0,989,991,3,118,59,0,990,989,1,0,0,
        0,990,991,1,0,0,0,991,113,1,0,0,0,992,993,3,354,177,0,993,115,1,
        0,0,0,994,995,3,352,176,0,995,117,1,0,0,0,996,1000,3,122,61,0,997,
        1000,3,120,60,0,998,1000,3,10,5,0,999,996,1,0,0,0,999,997,1,0,0,
        0,999,998,1,0,0,0,1000,1001,1,0,0,0,1001,999,1,0,0,0,1001,1002,1,
        0,0,0,1002,119,1,0,0,0,1003,1004,5,108,0,0,1004,1005,5,26,0,0,1005,
        1006,3,308,154,0,1006,121,1,0,0,0,1007,1008,5,55,0,0,1008,1009,7,
        7,0,0,1009,123,1,0,0,0,1010,1011,5,1,0,0,1011,1012,5,2,0,0,1012,
        1013,5,3,0,0,1013,1014,5,77,0,0,1014,1024,5,42,0,0,1015,1016,5,1,
        0,0,1016,1017,5,77,0,0,1017,1021,5,42,0,0,1018,1019,5,27,0,0,1019,
        1020,5,28,0,0,1020,1022,5,29,0,0,1021,1018,1,0,0,0,1021,1022,1,0,
        0,0,1022,1024,1,0,0,0,1023,1010,1,0,0,0,1023,1015,1,0,0,0,1024,1025,
        1,0,0,0,1025,1028,3,130,65,0,1026,1027,5,123,0,0,1027,1029,3,128,
        64,0,1028,1026,1,0,0,0,1028,1029,1,0,0,0,1029,1031,1,0,0,0,1030,
        1032,3,26,13,0,1031,1030,1,0,0,0,1031,1032,1,0,0,0,1032,1034,1,0,
        0,0,1033,1035,3,126,63,0,1034,1033,1,0,0,0,1034,1035,1,0,0,0,1035,
        125,1,0,0,0,1036,1039,3,10,5,0,1037,1039,3,14,7,0,1038,1036,1,0,
        0,0,1038,1037,1,0,0,0,1039,1040,1,0,0,0,1040,1038,1,0,0,0,1040,1041,
        1,0,0,0,1041,127,1,0,0,0,1042,1043,3,354,177,0,1043,129,1,0,0,0,
        1044,1045,3,354,177,0,1045,131,1,0,0,0,1046,1047,5,45,0,0,1047,1048,
        5,77,0,0,1048,1049,5,80,0,0,1049,1050,3,256,128,0,1050,1051,5,7,
        0,0,1051,1052,5,93,0,0,1052,1053,5,22,0,0,1053,1054,3,258,129,0,
        1054,133,1,0,0,0,1055,1056,5,4,0,0,1056,1057,5,77,0,0,1057,1058,
        5,80,0,0,1058,1063,3,256,128,0,1059,1060,5,7,0,0,1060,1061,5,93,
        0,0,1061,1062,5,22,0,0,1062,1064,3,258,129,0,1063,1059,1,0,0,0,1063,
        1064,1,0,0,0,1064,1066,1,0,0,0,1065,1067,3,36,18,0,1066,1065,1,0,
        0,0,1066,1067,1,0,0,0,1067,135,1,0,0,0,1068,1069,5,4,0,0,1069,1070,
        5,77,0,0,1070,1072,5,12,0,0,1071,1073,3,262,131,0,1072,1071,1,0,
        0,0,1072,1073,1,0,0,0,1073,1079,1,0,0,0,1074,1076,5,8,0,0,1075,1077,
        5,80,0,0,1076,1075,1,0,0,0,1076,1077,1,0,0,0,1077,1078,1,0,0,0,1078,
        1080,3,256,128,0,1079,1074,1,0,0,0,1079,1080,1,0,0,0,1080,1085,1,
        0,0,0,1081,1082,5,7,0,0,1082,1083,5,93,0,0,1083,1084,5,22,0,0,1084,
        1086,3,264,132,0,1085,1081,1,0,0,0,1085,1086,1,0,0,0,1086,1089,1,
        0,0,0,1087,1088,5,9,0,0,1088,1090,3,332,166,0,1089,1087,1,0,0,0,
        1089,1090,1,0,0,0,1090,1092,1,0,0,0,1091,1093,3,60,30,0,1092,1091,
        1,0,0,0,1092,1093,1,0,0,0,1093,137,1,0,0,0,1094,1095,5,4,0,0,1095,
        1097,5,77,0,0,1096,1098,5,48,0,0,1097,1096,1,0,0,0,1097,1098,1,0,
        0,0,1098,1100,1,0,0,0,1099,1101,5,120,0,0,1100,1099,1,0,0,0,1100,
        1101,1,0,0,0,1101,1102,1,0,0,0,1102,1103,5,14,0,0,1103,1106,3,268,
        134,0,1104,1105,5,8,0,0,1105,1107,3,22,11,0,1106,1104,1,0,0,0,1106,
        1107,1,0,0,0,1107,1112,1,0,0,0,1108,1109,5,7,0,0,1109,1110,5,93,
        0,0,1110,1111,5,22,0,0,1111,1113,3,270,135,0,1112,1108,1,0,0,0,1112,
        1113,1,0,0,0,1113,1122,1,0,0,0,1114,1115,5,117,0,0,1115,1117,3,272,
        136,0,1116,1118,3,312,156,0,1117,1116,1,0,0,0,1117,1118,1,0,0,0,
        1118,1120,1,0,0,0,1119,1121,3,310,155,0,1120,1119,1,0,0,0,1120,1121,
        1,0,0,0,1121,1123,1,0,0,0,1122,1114,1,0,0,0,1122,1123,1,0,0,0,1123,
        1125,1,0,0,0,1124,1126,3,64,32,0,1125,1124,1,0,0,0,1125,1126,1,0,
        0,0,1126,139,1,0,0,0,1127,1128,5,4,0,0,1128,1129,5,77,0,0,1129,1130,
        5,15,0,0,1130,1133,3,280,140,0,1131,1132,5,8,0,0,1132,1134,3,22,
        11,0,1133,1131,1,0,0,0,1133,1134,1,0,0,0,1134,1139,1,0,0,0,1135,
        1136,5,7,0,0,1136,1137,5,93,0,0,1137,1138,5,22,0,0,1138,1140,3,284,
        142,0,1139,1135,1,0,0,0,1139,1140,1,0,0,0,1140,1146,1,0,0,0,1141,
        1143,5,67,0,0,1142,1144,3,272,136,0,1143,1142,1,0,0,0,1143,1144,
        1,0,0,0,1144,1145,1,0,0,0,1145,1147,3,310,155,0,1146,1141,1,0,0,
        0,1146,1147,1,0,0,0,1147,1151,1,0,0,0,1148,1150,3,74,37,0,1149,1148,
        1,0,0,0,1150,1153,1,0,0,0,1151,1149,1,0,0,0,1151,1152,1,0,0,0,1152,
        1155,1,0,0,0,1153,1151,1,0,0,0,1154,1156,3,64,32,0,1155,1154,1,0,
        0,0,1155,1156,1,0,0,0,1156,141,1,0,0,0,1157,1158,5,4,0,0,1158,1159,
        5,77,0,0,1159,1160,5,16,0,0,1160,1163,3,282,141,0,1161,1162,5,8,
        0,0,1162,1164,3,22,11,0,1163,1161,1,0,0,0,1163,1164,1,0,0,0,1164,
        1169,1,0,0,0,1165,1166,5,7,0,0,1166,1167,5,93,0,0,1167,1168,5,22,
        0,0,1168,1170,3,286,143,0,1169,1165,1,0,0,0,1169,1170,1,0,0,0,1170,
        1176,1,0,0,0,1171,1173,5,67,0,0,1172,1174,3,272,136,0,1173,1172,
        1,0,0,0,1173,1174,1,0,0,0,1174,1175,1,0,0,0,1175,1177,3,310,155,
        0,1176,1171,1,0,0,0,1176,1177,1,0,0,0,1177,1181,1,0,0,0,1178,1180,
        3,78,39,0,1179,1178,1,0,0,0,1180,1183,1,0,0,0,1181,1179,1,0,0,0,
        1181,1182,1,0,0,0,1182,1185,1,0,0,0,1183,1181,1,0,0,0,1184,1186,
        3,64,32,0,1185,1184,1,0,0,0,1185,1186,1,0,0,0,1186,143,1,0,0,0,1187,
        1188,5,4,0,0,1188,1189,5,77,0,0,1189,1190,5,100,0,0,1190,1191,5,
        39,0,0,1191,1197,3,288,144,0,1192,1194,5,8,0,0,1193,1195,5,80,0,
        0,1194,1193,1,0,0,0,1194,1195,1,0,0,0,1195,1196,1,0,0,0,1196,1198,
        3,256,128,0,1197,1192,1,0,0,0,1197,1198,1,0,0,0,1198,1203,1,0,0,
        0,1199,1200,5,7,0,0,1200,1201,5,93,0,0,1201,1202,5,22,0,0,1202,1204,
        3,290,145,0,1203,1199,1,0,0,0,1203,1204,1,0,0,0,1204,1206,1,0,0,
        0,1205,1207,3,84,42,0,1206,1205,1,0,0,0,1206,1207,1,0,0,0,1207,145,
        1,0,0,0,1208,1209,5,4,0,0,1209,1210,5,77,0,0,1210,1211,7,5,0,0,1211,
        1212,5,108,0,0,1212,1216,3,96,48,0,1213,1214,5,7,0,0,1214,1215,5,
        64,0,0,1215,1217,3,148,74,0,1216,1213,1,0,0,0,1216,1217,1,0,0,0,
        1217,1219,1,0,0,0,1218,1220,3,100,50,0,1219,1218,1,0,0,0,1219,1220,
        1,0,0,0,1220,147,1,0,0,0,1221,1222,3,354,177,0,1222,149,1,0,0,0,
        1223,1224,5,4,0,0,1224,1225,5,77,0,0,1225,1226,5,25,0,0,1226,1227,
        3,114,57,0,1227,1228,5,193,0,0,1228,1232,3,96,48,0,1229,1230,5,40,
        0,0,1230,1231,5,41,0,0,1231,1233,3,116,58,0,1232,1229,1,0,0,0,1232,
        1233,1,0,0,0,1233,1235,1,0,0,0,1234,1236,3,118,59,0,1235,1234,1,
        0,0,0,1235,1236,1,0,0,0,1236,151,1,0,0,0,1237,1238,5,17,0,0,1238,
        1239,5,77,0,0,1239,1242,5,80,0,0,1240,1241,5,27,0,0,1241,1243,5,
        29,0,0,1242,1240,1,0,0,0,1242,1243,1,0,0,0,1243,1244,1,0,0,0,1244,
        1245,3,256,128,0,1245,153,1,0,0,0,1246,1247,5,17,0,0,1247,1248,5,
        77,0,0,1248,1251,5,12,0,0,1249,1250,5,27,0,0,1250,1252,5,29,0,0,
        1251,1249,1,0,0,0,1251,1252,1,0,0,0,1252,1253,1,0,0,0,1253,1259,
        3,262,131,0,1254,1256,5,9,0,0,1255,1257,5,80,0,0,1256,1255,1,0,0,
        0,1256,1257,1,0,0,0,1257,1258,1,0,0,0,1258,1260,3,256,128,0,1259,
        1254,1,0,0,0,1259,1260,1,0,0,0,1260,155,1,0,0,0,1261,1262,5,17,0,
        0,1262,1264,5,77,0,0,1263,1265,5,48,0,0,1264,1263,1,0,0,0,1264,1265,
        1,0,0,0,1265,1267,1,0,0,0,1266,1268,5,120,0,0,1267,1266,1,0,0,0,
        1267,1268,1,0,0,0,1268,1269,1,0,0,0,1269,1272,5,14,0,0,1270,1271,
        5,27,0,0,1271,1273,5,29,0,0,1272,1270,1,0,0,0,1272,1273,1,0,0,0,
        1273,1274,1,0,0,0,1274,1277,3,268,134,0,1275,1276,5,9,0,0,1276,1278,
        3,22,11,0,1277,1275,1,0,0,0,1277,1278,1,0,0,0,1278,157,1,0,0,0,1279,
        1280,5,17,0,0,1280,1281,5,77,0,0,1281,1284,5,15,0,0,1282,1283,5,
        27,0,0,1283,1285,5,29,0,0,1284,1282,1,0,0,0,1284,1285,1,0,0,0,1285,
        1286,1,0,0,0,1286,1289,3,280,140,0,1287,1288,5,9,0,0,1288,1290,3,
        22,11,0,1289,1287,1,0,0,0,1289,1290,1,0,0,0,1290,159,1,0,0,0,1291,
        1292,5,17,0,0,1292,1293,5,77,0,0,1293,1296,5,16,0,0,1294,1295,5,
        27,0,0,1295,1297,5,29,0,0,1296,1294,1,0,0,0,1296,1297,1,0,0,0,1297,
        1298,1,0,0,0,1298,1301,3,282,141,0,1299,1300,5,9,0,0,1300,1302,3,
        22,11,0,1301,1299,1,0,0,0,1301,1302,1,0,0,0,1302,161,1,0,0,0,1303,
        1304,5,17,0,0,1304,1305,5,77,0,0,1305,1306,5,100,0,0,1306,1309,5,
        39,0,0,1307,1308,5,27,0,0,1308,1310,5,29,0,0,1309,1307,1,0,0,0,1309,
        1310,1,0,0,0,1310,1311,1,0,0,0,1311,1317,3,288,144,0,1312,1314,5,
        9,0,0,1313,1315,5,80,0,0,1314,1313,1,0,0,0,1314,1315,1,0,0,0,1315,
        1316,1,0,0,0,1316,1318,3,256,128,0,1317,1312,1,0,0,0,1317,1318,1,
        0,0,0,1318,163,1,0,0,0,1319,1320,5,17,0,0,1320,1321,5,77,0,0,1321,
        1322,5,100,0,0,1322,1325,5,46,0,0,1323,1324,5,27,0,0,1324,1326,5,
        29,0,0,1325,1323,1,0,0,0,1325,1326,1,0,0,0,1326,1327,1,0,0,0,1327,
        1328,3,292,146,0,1328,1333,5,9,0,0,1329,1331,5,80,0,0,1330,1329,
        1,0,0,0,1330,1331,1,0,0,0,1331,1332,1,0,0,0,1332,1334,3,256,128,
        0,1333,1330,1,0,0,0,1333,1334,1,0,0,0,1334,1335,1,0,0,0,1335,1336,
        5,100,0,0,1336,1337,5,39,0,0,1337,1338,3,288,144,0,1338,165,1,0,
        0,0,1339,1340,5,17,0,0,1340,1341,5,77,0,0,1341,1342,7,5,0,0,1342,
        1345,5,108,0,0,1343,1344,5,27,0,0,1344,1346,5,29,0,0,1345,1343,1,
        0,0,0,1345,1346,1,0,0,0,1346,1347,1,0,0,0,1347,1348,3,96,48,0,1348,
        167,1,0,0,0,1349,1350,5,17,0,0,1350,1351,5,77,0,0,1351,1354,5,25,
        0,0,1352,1353,5,27,0,0,1353,1355,5,29,0,0,1354,1352,1,0,0,0,1354,
        1355,1,0,0,0,1355,1356,1,0,0,0,1356,1357,3,114,57,0,1357,1358,5,
        193,0,0,1358,1359,3,96,48,0,1359,169,1,0,0,0,1360,1361,5,17,0,0,
        1361,1362,5,77,0,0,1362,1365,5,42,0,0,1363,1364,5,27,0,0,1364,1366,
        5,29,0,0,1365,1363,1,0,0,0,1365,1366,1,0,0,0,1366,1367,1,0,0,0,1367,
        1369,3,130,65,0,1368,1370,3,26,13,0,1369,1368,1,0,0,0,1369,1370,
        1,0,0,0,1370,171,1,0,0,0,1371,1372,5,50,0,0,1372,1373,5,77,0,0,1373,
        1385,3,174,87,0,1374,1376,5,8,0,0,1375,1377,5,80,0,0,1376,1375,1,
        0,0,0,1376,1377,1,0,0,0,1377,1378,1,0,0,0,1378,1386,3,260,130,0,
        1379,1380,5,8,0,0,1380,1383,3,24,12,0,1381,1382,5,124,0,0,1382,1384,
        3,278,139,0,1383,1381,1,0,0,0,1383,1384,1,0,0,0,1384,1386,1,0,0,
        0,1385,1374,1,0,0,0,1385,1379,1,0,0,0,1385,1386,1,0,0,0,1386,1387,
        1,0,0,0,1387,1388,5,43,0,0,1388,1390,3,130,65,0,1389,1391,3,26,13,
        0,1390,1389,1,0,0,0,1390,1391,1,0,0,0,1391,173,1,0,0,0,1392,1398,
        3,176,88,0,1393,1394,3,176,88,0,1394,1395,5,181,0,0,1395,1396,3,
        174,87,0,1396,1398,1,0,0,0,1397,1392,1,0,0,0,1397,1393,1,0,0,0,1398,
        175,1,0,0,0,1399,1400,7,8,0,0,1400,177,1,0,0,0,1401,1402,5,50,0,
        0,1402,1403,5,77,0,0,1403,1404,5,42,0,0,1404,1406,3,130,65,0,1405,
        1407,3,26,13,0,1406,1405,1,0,0,0,1406,1407,1,0,0,0,1407,1408,1,0,
        0,0,1408,1409,5,43,0,0,1409,1410,3,114,57,0,1410,1411,5,193,0,0,
        1411,1413,3,96,48,0,1412,1414,3,14,7,0,1413,1412,1,0,0,0,1413,1414,
        1,0,0,0,1414,179,1,0,0,0,1415,1416,5,54,0,0,1416,1417,5,77,0,0,1417,
        1429,3,174,87,0,1418,1420,5,8,0,0,1419,1421,5,80,0,0,1420,1419,1,
        0,0,0,1420,1421,1,0,0,0,1421,1422,1,0,0,0,1422,1430,3,260,130,0,
        1423,1424,5,8,0,0,1424,1427,3,24,12,0,1425,1426,5,124,0,0,1426,1428,
        3,278,139,0,1427,1425,1,0,0,0,1427,1428,1,0,0,0,1428,1430,1,0,0,
        0,1429,1418,1,0,0,0,1429,1423,1,0,0,0,1429,1430,1,0,0,0,1430,1431,
        1,0,0,0,1431,1432,5,9,0,0,1432,1434,3,130,65,0,1433,1435,3,26,13,
        0,1434,1433,1,0,0,0,1434,1435,1,0,0,0,1435,181,1,0,0,0,1436,1437,
        5,54,0,0,1437,1438,5,77,0,0,1438,1439,5,42,0,0,1439,1441,3,130,65,
        0,1440,1442,3,26,13,0,1441,1440,1,0,0,0,1441,1442,1,0,0,0,1442,1443,
        1,0,0,0,1443,1444,5,9,0,0,1444,1445,3,114,57,0,1445,1446,5,193,0,
        0,1446,1447,3,96,48,0,1447,183,1,0,0,0,1448,1449,5,18,0,0,1449,1450,
        5,77,0,0,1450,1451,3,186,93,0,1451,185,1,0,0,0,1452,1453,5,80,0,
        0,1453,1456,3,256,128,0,1454,1456,3,22,11,0,1455,1452,1,0,0,0,1455,
        1454,1,0,0,0,1456,187,1,0,0,0,1457,1458,5,5,0,0,1458,1460,5,77,0,
        0,1459,1461,5,78,0,0,1460,1459,1,0,0,0,1460,1461,1,0,0,0,1461,1462,
        1,0,0,0,1462,1463,5,6,0,0,1463,189,1,0,0,0,1464,1465,5,5,0,0,1465,
        1466,5,77,0,0,1466,1467,5,79,0,0,1467,191,1,0,0,0,1468,1469,5,5,
        0,0,1469,1470,5,77,0,0,1470,1476,5,11,0,0,1471,1473,7,9,0,0,1472,
        1474,5,80,0,0,1473,1472,1,0,0,0,1473,1474,1,0,0,0,1474,1475,1,0,
        0,0,1475,1477,3,256,128,0,1476,1471,1,0,0,0,1476,1477,1,0,0,0,1477,
        193,1,0,0,0,1478,1479,5,5,0,0,1479,1481,5,77,0,0,1480,1482,5,48,
        0,0,1481,1480,1,0,0,0,1481,1482,1,0,0,0,1482,1484,1,0,0,0,1483,1485,
        5,120,0,0,1484,1483,1,0,0,0,1484,1485,1,0,0,0,1485,1486,1,0,0,0,
        1486,1489,5,81,0,0,1487,1488,7,9,0,0,1488,1490,3,22,11,0,1489,1487,
        1,0,0,0,1489,1490,1,0,0,0,1490,195,1,0,0,0,1491,1492,5,5,0,0,1492,
        1493,5,77,0,0,1493,1496,5,82,0,0,1494,1495,7,9,0,0,1495,1497,3,22,
        11,0,1496,1494,1,0,0,0,1496,1497,1,0,0,0,1497,197,1,0,0,0,1498,1499,
        5,5,0,0,1499,1500,5,77,0,0,1500,1503,5,83,0,0,1501,1502,7,9,0,0,
        1502,1504,3,22,11,0,1503,1501,1,0,0,0,1503,1504,1,0,0,0,1504,199,
        1,0,0,0,1505,1506,5,5,0,0,1506,1507,5,77,0,0,1507,1508,5,100,0,0,
        1508,1514,5,105,0,0,1509,1511,7,9,0,0,1510,1512,5,80,0,0,1511,1510,
        1,0,0,0,1511,1512,1,0,0,0,1512,1513,1,0,0,0,1513,1515,3,256,128,
        0,1514,1509,1,0,0,0,1514,1515,1,0,0,0,1515,201,1,0,0,0,1516,1517,
        5,5,0,0,1517,1518,5,77,0,0,1518,1519,5,100,0,0,1519,1520,5,215,0,
        0,1520,1525,7,9,0,0,1521,1523,5,80,0,0,1522,1521,1,0,0,0,1522,1523,
        1,0,0,0,1523,1524,1,0,0,0,1524,1526,3,256,128,0,1525,1522,1,0,0,
        0,1525,1526,1,0,0,0,1526,1527,1,0,0,0,1527,1528,5,100,0,0,1528,1529,
        5,39,0,0,1529,1530,3,288,144,0,1530,203,1,0,0,0,1531,1532,5,5,0,
        0,1532,1533,5,77,0,0,1533,1534,5,106,0,0,1534,1540,5,107,0,0,1535,
        1537,7,9,0,0,1536,1538,5,80,0,0,1537,1536,1,0,0,0,1537,1538,1,0,
        0,0,1538,1539,1,0,0,0,1539,1541,3,256,128,0,1540,1535,1,0,0,0,1540,
        1541,1,0,0,0,1541,205,1,0,0,0,1542,1543,5,5,0,0,1543,1544,5,77,0,
        0,1544,1554,5,122,0,0,1545,1552,7,9,0,0,1546,1547,5,61,0,0,1547,
        1553,5,80,0,0,1548,1550,5,80,0,0,1549,1548,1,0,0,0,1549,1550,1,0,
        0,0,1550,1551,1,0,0,0,1551,1553,3,256,128,0,1552,1546,1,0,0,0,1552,
        1549,1,0,0,0,1553,1555,1,0,0,0,1554,1545,1,0,0,0,1554,1555,1,0,0,
        0,1555,1562,1,0,0,0,1556,1558,5,59,0,0,1557,1559,3,114,57,0,1558,
        1557,1,0,0,0,1558,1559,1,0,0,0,1559,1560,1,0,0,0,1560,1561,5,193,
        0,0,1561,1563,3,96,48,0,1562,1556,1,0,0,0,1562,1563,1,0,0,0,1563,
        207,1,0,0,0,1564,1565,5,5,0,0,1565,1566,5,77,0,0,1566,1567,5,58,
        0,0,1567,1568,5,59,0,0,1568,1578,3,130,65,0,1569,1576,7,9,0,0,1570,
        1571,5,61,0,0,1571,1577,5,80,0,0,1572,1574,5,80,0,0,1573,1572,1,
        0,0,0,1573,1574,1,0,0,0,1574,1575,1,0,0,0,1575,1577,3,256,128,0,
        1576,1570,1,0,0,0,1576,1573,1,0,0,0,1577,1579,1,0,0,0,1578,1569,
        1,0,0,0,1578,1579,1,0,0,0,1579,209,1,0,0,0,1580,1581,5,5,0,0,1581,
        1582,5,1,0,0,1582,1583,5,77,0,0,1583,1585,5,80,0,0,1584,1586,3,256,
        128,0,1585,1584,1,0,0,0,1585,1586,1,0,0,0,1586,1590,1,0,0,0,1587,
        1588,5,127,0,0,1588,1589,5,12,0,0,1589,1591,5,128,0,0,1590,1587,
        1,0,0,0,1590,1591,1,0,0,0,1591,211,1,0,0,0,1592,1593,5,5,0,0,1593,
        1594,5,1,0,0,1594,1595,5,77,0,0,1595,1597,5,12,0,0,1596,1598,3,262,
        131,0,1597,1596,1,0,0,0,1597,1598,1,0,0,0,1598,1604,1,0,0,0,1599,
        1601,7,9,0,0,1600,1602,5,80,0,0,1601,1600,1,0,0,0,1601,1602,1,0,
        0,0,1602,1603,1,0,0,0,1603,1605,3,256,128,0,1604,1599,1,0,0,0,1604,
        1605,1,0,0,0,1605,213,1,0,0,0,1606,1607,5,5,0,0,1607,1608,5,1,0,
        0,1608,1610,5,77,0,0,1609,1611,5,48,0,0,1610,1609,1,0,0,0,1610,1611,
        1,0,0,0,1611,1613,1,0,0,0,1612,1614,5,120,0,0,1613,1612,1,0,0,0,
        1613,1614,1,0,0,0,1614,1615,1,0,0,0,1615,1616,5,14,0,0,1616,1619,
        3,268,134,0,1617,1618,7,9,0,0,1618,1620,3,22,11,0,1619,1617,1,0,
        0,0,1619,1620,1,0,0,0,1620,215,1,0,0,0,1621,1622,5,5,0,0,1622,1623,
        5,1,0,0,1623,1624,5,77,0,0,1624,1625,5,15,0,0,1625,1628,3,280,140,
        0,1626,1627,7,9,0,0,1627,1629,3,22,11,0,1628,1626,1,0,0,0,1628,1629,
        1,0,0,0,1629,217,1,0,0,0,1630,1631,5,5,0,0,1631,1632,5,1,0,0,1632,
        1633,5,77,0,0,1633,1634,5,16,0,0,1634,1637,3,282,141,0,1635,1636,
        7,9,0,0,1636,1638,3,22,11,0,1637,1635,1,0,0,0,1637,1638,1,0,0,0,
        1638,219,1,0,0,0,1639,1640,5,5,0,0,1640,1641,5,1,0,0,1641,1642,5,
        77,0,0,1642,1643,5,100,0,0,1643,1644,5,39,0,0,1644,1650,3,288,144,
        0,1645,1647,7,9,0,0,1646,1648,5,80,0,0,1647,1646,1,0,0,0,1647,1648,
        1,0,0,0,1648,1649,1,0,0,0,1649,1651,3,256,128,0,1650,1645,1,0,0,
        0,1650,1651,1,0,0,0,1651,221,1,0,0,0,1652,1653,5,5,0,0,1653,1654,
        5,1,0,0,1654,1655,5,77,0,0,1655,1656,5,100,0,0,1656,1657,5,46,0,
        0,1657,1658,3,292,146,0,1658,1663,7,9,0,0,1659,1661,5,80,0,0,1660,
        1659,1,0,0,0,1660,1661,1,0,0,0,1661,1662,1,0,0,0,1662,1664,3,256,
        128,0,1663,1660,1,0,0,0,1663,1664,1,0,0,0,1664,1665,1,0,0,0,1665,
        1666,5,100,0,0,1666,1667,5,39,0,0,1667,1668,3,288,144,0,1668,223,
        1,0,0,0,1669,1670,5,5,0,0,1670,1671,5,1,0,0,1671,1672,5,77,0,0,1672,
        1673,5,106,0,0,1673,1674,5,108,0,0,1674,1675,3,96,48,0,1675,225,
        1,0,0,0,1676,1677,5,5,0,0,1677,1678,5,1,0,0,1678,1679,5,77,0,0,1679,
        1680,5,42,0,0,1680,1682,3,130,65,0,1681,1683,3,26,13,0,1682,1681,
        1,0,0,0,1682,1683,1,0,0,0,1683,227,1,0,0,0,1684,1685,5,5,0,0,1685,
        1686,5,1,0,0,1686,1687,5,77,0,0,1687,1688,5,25,0,0,1688,1689,3,114,
        57,0,1689,1690,5,193,0,0,1690,1691,3,96,48,0,1691,229,1,0,0,0,1692,
        1693,5,130,0,0,1693,1694,5,77,0,0,1694,1695,5,80,0,0,1695,1696,3,
        256,128,0,1696,1698,5,19,0,0,1697,1699,5,73,0,0,1698,1697,1,0,0,
        0,1698,1699,1,0,0,0,1699,1700,1,0,0,0,1700,1701,5,132,0,0,1701,1712,
        5,127,0,0,1702,1709,5,12,0,0,1703,1704,5,74,0,0,1704,1707,5,133,
        0,0,1705,1706,5,74,0,0,1706,1708,5,72,0,0,1707,1705,1,0,0,0,1707,
        1708,1,0,0,0,1708,1710,1,0,0,0,1709,1703,1,0,0,0,1709,1710,1,0,0,
        0,1710,1713,1,0,0,0,1711,1713,5,66,0,0,1712,1702,1,0,0,0,1712,1711,
        1,0,0,0,1713,1714,1,0,0,0,1714,1715,5,128,0,0,1715,1717,5,43,0,0,
        1716,1718,5,131,0,0,1717,1716,1,0,0,0,1717,1718,1,0,0,0,1718,1719,
        1,0,0,0,1719,1720,3,82,41,0,1720,231,1,0,0,0,1721,1722,5,130,0,0,
        1722,1723,5,77,0,0,1723,1724,5,134,0,0,1724,1725,3,244,122,0,1725,
        1726,5,135,0,0,1726,1728,3,254,127,0,1727,1729,3,238,119,0,1728,
        1727,1,0,0,0,1729,1730,1,0,0,0,1730,1728,1,0,0,0,1730,1731,1,0,0,
        0,1731,1735,1,0,0,0,1732,1734,3,240,120,0,1733,1732,1,0,0,0,1734,
        1737,1,0,0,0,1735,1733,1,0,0,0,1735,1736,1,0,0,0,1736,1739,1,0,0,
        0,1737,1735,1,0,0,0,1738,1740,3,242,121,0,1739,1738,1,0,0,0,1739,
        1740,1,0,0,0,1740,1741,1,0,0,0,1741,1743,5,43,0,0,1742,1744,5,131,
        0,0,1743,1742,1,0,0,0,1743,1744,1,0,0,0,1744,1745,1,0,0,0,1745,1746,
        3,82,41,0,1746,233,1,0,0,0,1747,1748,5,49,0,0,1748,1749,5,77,0,0,
        1749,1752,5,80,0,0,1750,1751,5,19,0,0,1751,1753,3,256,128,0,1752,
        1750,1,0,0,0,1752,1753,1,0,0,0,1753,1754,1,0,0,0,1754,1755,5,9,0,
        0,1755,1756,3,82,41,0,1756,235,1,0,0,0,1757,1758,5,49,0,0,1758,1759,
        5,77,0,0,1759,1760,5,134,0,0,1760,1762,5,9,0,0,1761,1763,7,10,0,
        0,1762,1761,1,0,0,0,1762,1763,1,0,0,0,1763,1764,1,0,0,0,1764,1765,
        3,82,41,0,1765,237,1,0,0,0,1766,1767,5,80,0,0,1767,1768,3,256,128,
        0,1768,1779,5,127,0,0,1769,1776,5,12,0,0,1770,1771,5,74,0,0,1771,
        1774,5,133,0,0,1772,1773,5,74,0,0,1773,1775,5,72,0,0,1774,1772,1,
        0,0,0,1774,1775,1,0,0,0,1775,1777,1,0,0,0,1776,1770,1,0,0,0,1776,
        1777,1,0,0,0,1777,1780,1,0,0,0,1778,1780,5,66,0,0,1779,1769,1,0,
        0,0,1779,1778,1,0,0,0,1780,1781,1,0,0,0,1781,1782,5,128,0,0,1782,
        239,1,0,0,0,1783,1784,5,12,0,0,1784,1787,3,332,166,0,1785,1786,5,
        9,0,0,1786,1788,3,246,123,0,1787,1785,1,0,0,0,1787,1788,1,0,0,0,
        1788,241,1,0,0,0,1789,1790,5,136,0,0,1790,1791,5,9,0,0,1791,1797,
        3,248,124,0,1792,1793,5,75,0,0,1793,1797,3,250,125,0,1794,1795,5,
        137,0,0,1795,1797,3,252,126,0,1796,1789,1,0,0,0,1796,1792,1,0,0,
        0,1796,1794,1,0,0,0,1797,1798,1,0,0,0,1798,1796,1,0,0,0,1798,1799,
        1,0,0,0,1799,243,1,0,0,0,1800,1801,3,352,176,0,1801,245,1,0,0,0,
        1802,1803,3,352,176,0,1803,247,1,0,0,0,1804,1805,3,352,176,0,1805,
        249,1,0,0,0,1806,1807,3,352,176,0,1807,251,1,0,0,0,1808,1809,3,352,
        176,0,1809,253,1,0,0,0,1810,1811,3,352,176,0,1811,255,1,0,0,0,1812,
        1814,3,296,148,0,1813,1812,1,0,0,0,1813,1814,1,0,0,0,1814,1815,1,
        0,0,0,1815,1816,3,298,149,0,1816,257,1,0,0,0,1817,1819,3,296,148,
        0,1818,1817,1,0,0,0,1818,1819,1,0,0,0,1819,1820,1,0,0,0,1820,1821,
        3,298,149,0,1821,259,1,0,0,0,1822,1823,3,300,150,0,1823,261,1,0,
        0,0,1824,1825,3,298,149,0,1825,263,1,0,0,0,1826,1827,3,298,149,0,
        1827,265,1,0,0,0,1828,1829,3,300,150,0,1829,267,1,0,0,0,1830,1831,
        3,298,149,0,1831,269,1,0,0,0,1832,1833,3,298,149,0,1833,271,1,0,
        0,0,1834,1835,3,340,170,0,1835,273,1,0,0,0,1836,1837,3,340,170,0,
        1837,275,1,0,0,0,1838,1839,3,298,149,0,1839,277,1,0,0,0,1840,1841,
        3,300,150,0,1841,279,1,0,0,0,1842,1843,3,298,149,0,1843,281,1,0,
        0,0,1844,1845,3,298,149,0,1845,283,1,0,0,0,1846,1847,3,298,149,0,
        1847,285,1,0,0,0,1848,1849,3,298,149,0,1849,287,1,0,0,0,1850,1851,
        3,298,149,0,1851,289,1,0,0,0,1852,1853,3,298,149,0,1853,291,1,0,
        0,0,1854,1855,3,298,149,0,1855,293,1,0,0,0,1856,1857,3,354,177,0,
        1857,295,1,0,0,0,1858,1863,3,294,147,0,1859,1860,5,181,0,0,1860,
        1862,3,294,147,0,1861,1859,1,0,0,0,1862,1865,1,0,0,0,1863,1861,1,
        0,0,0,1863,1864,1,0,0,0,1864,1866,1,0,0,0,1865,1863,1,0,0,0,1866,
        1867,5,193,0,0,1867,297,1,0,0,0,1868,1873,5,157,0,0,1869,1873,5,
        207,0,0,1870,1871,4,149,0,0,1871,1873,5,208,0,0,1872,1868,1,0,0,
        0,1872,1869,1,0,0,0,1872,1870,1,0,0,0,1873,299,1,0,0,0,1874,1879,
        5,157,0,0,1875,1879,5,207,0,0,1876,1877,4,150,1,0,1877,1879,5,208,
        0,0,1878,1874,1,0,0,0,1878,1875,1,0,0,0,1878,1876,1,0,0,0,1879,301,
        1,0,0,0,1880,1881,5,186,0,0,1881,1886,3,304,152,0,1882,1883,5,181,
        0,0,1883,1885,3,304,152,0,1884,1882,1,0,0,0,1885,1888,1,0,0,0,1886,
        1884,1,0,0,0,1886,1887,1,0,0,0,1887,1889,1,0,0,0,1888,1886,1,0,0,
        0,1889,1890,5,187,0,0,1890,1894,1,0,0,0,1891,1892,5,186,0,0,1892,
        1894,5,187,0,0,1893,1880,1,0,0,0,1893,1891,1,0,0,0,1894,303,1,0,
        0,0,1895,1896,5,208,0,0,1896,1897,5,183,0,0,1897,1898,3,308,154,
        0,1898,305,1,0,0,0,1899,1908,5,189,0,0,1900,1905,3,308,154,0,1901,
        1902,5,181,0,0,1902,1904,3,308,154,0,1903,1901,1,0,0,0,1904,1907,
        1,0,0,0,1905,1903,1,0,0,0,1905,1906,1,0,0,0,1906,1909,1,0,0,0,1907,
        1905,1,0,0,0,1908,1900,1,0,0,0,1908,1909,1,0,0,0,1909,1910,1,0,0,
        0,1910,1911,5,190,0,0,1911,307,1,0,0,0,1912,1924,5,208,0,0,1913,
        1915,7,11,0,0,1914,1913,1,0,0,0,1914,1915,1,0,0,0,1915,1916,1,0,
        0,0,1916,1924,5,202,0,0,1917,1924,5,200,0,0,1918,1924,3,302,151,
        0,1919,1924,3,306,153,0,1920,1924,5,37,0,0,1921,1924,5,38,0,0,1922,
        1924,5,36,0,0,1923,1912,1,0,0,0,1923,1914,1,0,0,0,1923,1917,1,0,
        0,0,1923,1918,1,0,0,0,1923,1919,1,0,0,0,1923,1920,1,0,0,0,1923,1921,
        1,0,0,0,1923,1922,1,0,0,0,1924,309,1,0,0,0,1925,1926,5,186,0,0,1926,
        1931,3,314,157,0,1927,1928,5,181,0,0,1928,1930,3,314,157,0,1929,
        1927,1,0,0,0,1930,1933,1,0,0,0,1931,1929,1,0,0,0,1931,1932,1,0,0,
        0,1932,1934,1,0,0,0,1933,1931,1,0,0,0,1934,1935,5,187,0,0,1935,1939,
        1,0,0,0,1936,1937,5,186,0,0,1937,1939,5,187,0,0,1938,1925,1,0,0,
        0,1938,1936,1,0,0,0,1939,311,1,0,0,0,1940,1942,7,12,0,0,1941,1940,
        1,0,0,0,1942,1943,1,0,0,0,1943,1941,1,0,0,0,1943,1944,1,0,0,0,1944,
        313,1,0,0,0,1945,1946,3,322,161,0,1946,1947,5,183,0,0,1947,1949,
        3,324,162,0,1948,1950,7,13,0,0,1949,1948,1,0,0,0,1949,1950,1,0,0,
        0,1950,1952,1,0,0,0,1951,1953,3,316,158,0,1952,1951,1,0,0,0,1952,
        1953,1,0,0,0,1953,1959,1,0,0,0,1954,1955,5,148,0,0,1955,1956,5,184,
        0,0,1956,1957,3,328,164,0,1957,1958,5,185,0,0,1958,1960,1,0,0,0,
        1959,1954,1,0,0,0,1959,1960,1,0,0,0,1960,1962,1,0,0,0,1961,1963,
        3,312,156,0,1962,1961,1,0,0,0,1962,1963,1,0,0,0,1963,1965,1,0,0,
        0,1964,1966,3,318,159,0,1965,1964,1,0,0,0,1965,1966,1,0,0,0,1966,
        1968,1,0,0,0,1967,1969,3,310,155,0,1968,1967,1,0,0,0,1968,1969,1,
        0,0,0,1969,315,1,0,0,0,1970,1972,7,14,0,0,1971,1970,1,0,0,0,1972,
        1973,1,0,0,0,1973,1971,1,0,0,0,1973,1974,1,0,0,0,1974,317,1,0,0,
        0,1975,1976,5,13,0,0,1976,1977,5,12,0,0,1977,1978,3,308,154,0,1978,
        319,1,0,0,0,1979,1980,7,15,0,0,1980,321,1,0,0,0,1981,1985,5,208,
        0,0,1982,1985,3,340,170,0,1983,1985,3,320,160,0,1984,1981,1,0,0,
        0,1984,1982,1,0,0,0,1984,1983,1,0,0,0,1985,323,1,0,0,0,1986,1989,
        3,346,173,0,1987,1989,3,320,160,0,1988,1986,1,0,0,0,1988,1987,1,
        0,0,0,1989,325,1,0,0,0,1990,1993,5,208,0,0,1991,1993,3,340,170,0,
        1992,1990,1,0,0,0,1992,1991,1,0,0,0,1993,327,1,0,0,0,1994,1997,5,
        208,0,0,1995,1997,3,340,170,0,1996,1994,1,0,0,0,1996,1995,1,0,0,
        0,1997,329,1,0,0,0,1998,2001,3,346,173,0,1999,2001,3,310,155,0,2000,
        1998,1,0,0,0,2000,1999,1,0,0,0,2001,331,1,0,0,0,2002,2003,3,340,
        170,0,2003,333,1,0,0,0,2004,2005,3,340,170,0,2005,335,1,0,0,0,2006,
        2007,3,340,170,0,2007,337,1,0,0,0,2008,2012,7,16,0,0,2009,2010,4,
        169,2,0,2010,2012,5,208,0,0,2011,2008,1,0,0,0,2011,2009,1,0,0,0,
        2012,339,1,0,0,0,2013,2014,3,338,169,0,2014,341,1,0,0,0,2015,2020,
        3,340,170,0,2016,2017,5,181,0,0,2017,2019,3,340,170,0,2018,2016,
        1,0,0,0,2019,2022,1,0,0,0,2020,2018,1,0,0,0,2020,2021,1,0,0,0,2021,
        343,1,0,0,0,2022,2020,1,0,0,0,2023,2024,5,184,0,0,2024,2025,3,342,
        171,0,2025,2026,5,185,0,0,2026,345,1,0,0,0,2027,2029,3,340,170,0,
        2028,2030,3,350,175,0,2029,2028,1,0,0,0,2029,2030,1,0,0,0,2030,347,
        1,0,0,0,2031,2036,3,340,170,0,2032,2034,3,350,175,0,2033,2035,3,
        350,175,0,2034,2033,1,0,0,0,2034,2035,1,0,0,0,2035,2037,1,0,0,0,
        2036,2032,1,0,0,0,2036,2037,1,0,0,0,2037,349,1,0,0,0,2038,2039,5,
        180,0,0,2039,2040,3,340,170,0,2040,351,1,0,0,0,2041,2045,5,209,0,
        0,2042,2043,4,176,3,0,2043,2045,5,208,0,0,2044,2041,1,0,0,0,2044,
        2042,1,0,0,0,2045,353,1,0,0,0,2046,2049,3,340,170,0,2047,2049,3,
        352,176,0,2048,2046,1,0,0,0,2048,2047,1,0,0,0,2049,355,1,0,0,0,263,
        360,365,368,371,435,443,446,459,472,479,488,491,497,502,504,509,
        522,524,528,539,541,553,555,576,584,592,605,607,610,614,617,622,
        630,632,639,642,648,651,657,659,664,670,673,676,679,690,692,698,
        718,720,725,730,734,737,742,746,750,765,767,772,777,781,784,787,
        790,794,811,813,818,821,825,828,838,840,847,864,866,871,874,882,
        886,889,894,896,911,913,920,923,936,938,942,949,977,979,987,990,
        999,1001,1021,1023,1028,1031,1034,1038,1040,1063,1066,1072,1076,
        1079,1085,1089,1092,1097,1100,1106,1112,1117,1120,1122,1125,1133,
        1139,1143,1146,1151,1155,1163,1169,1173,1176,1181,1185,1194,1197,
        1203,1206,1216,1219,1232,1235,1242,1251,1256,1259,1264,1267,1272,
        1277,1284,1289,1296,1301,1309,1314,1317,1325,1330,1333,1345,1354,
        1365,1369,1376,1383,1385,1390,1397,1406,1413,1420,1427,1429,1434,
        1441,1455,1460,1473,1476,1481,1484,1489,1496,1503,1511,1514,1522,
        1525,1537,1540,1549,1552,1554,1558,1562,1573,1576,1578,1585,1590,
        1597,1601,1604,1610,1613,1619,1628,1637,1647,1650,1660,1663,1682,
        1698,1707,1709,1712,1717,1730,1735,1739,1743,1752,1762,1774,1776,
        1779,1787,1796,1798,1813,1818,1863,1872,1878,1886,1893,1905,1908,
        1914,1923,1931,1938,1943,1949,1952,1959,1962,1965,1968,1973,1984,
        1988,1992,1996,2000,2011,2020,2029,2034,2036,2044,2048
    ]

class MRSParser ( Parser ):

    grammarFileName = "MRSParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'='", "':='", "'<=>'", "'>='", 
                     "'>'", "'<='", "'<'", "'!='", "'+'", "'-'", "'*'", 
                     "'/'", "'%'", "'!'", "'~'", "'<<'", "'>>'", "'&&'", 
                     "'&'", "'^'", "'||'", "'|'", "'.'", "','", "';'", "':'", 
                     "'('", "')'", "'{'", "'}'", "'_'", "'['", "']'", "'->'", 
                     "'->>'", "'@'", "<INVALID>", "'@@'", "'\\N'", "'?'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'<>'" ]

    symbolicNames = [ "<INVALID>", "CREATE_SYMBOL", "OR_SYMBOL", "REPLACE_SYMBOL", 
                      "ALTER_SYMBOL", "SHOW_SYMBOL", "STATUS_SYMBOL", "NEW_SYMBOL", 
                      "ON_SYMBOL", "FROM_SYMBOL", "IN_SYMBOL", "DATABASES_SYMBOL", 
                      "DATABASE_SYMBOL", "JSON_SYMBOL", "VIEW_SYMBOL", "PROCEDURE_SYMBOL", 
                      "FUNCTION_SYMBOL", "DROP_SYMBOL", "USE_SYMBOL", "AS_SYMBOL", 
                      "FILTER_SYMBOL", "AUTHENTICATION_SYMBOL", "PATH_SYMBOL", 
                      "VALIDATION_SYMBOL", "DEFAULT_SYMBOL", "USER_SYMBOL", 
                      "OPTIONS_SYMBOL", "IF_SYMBOL", "NOT_SYMBOL", "EXISTS_SYMBOL", 
                      "PAGE_SYMBOL", "HOST_SYMBOL", "TYPE_SYMBOL", "FORMAT_SYMBOL", 
                      "FORCE_SYMBOL", "UPDATE_SYMBOL", "NULL_SYMBOL", "TRUE_SYMBOL", 
                      "FALSE_SYMBOL", "SET_SYMBOL", "IDENTIFIED_SYMBOL", 
                      "BY_SYMBOL", "ROLE_SYMBOL", "TO_SYMBOL", "IGNORE_SYMBOL", 
                      "CLONE_SYMBOL", "FILE_SYMBOL", "BINARY_SYMBOL", "DATA_SYMBOL", 
                      "LOAD_SYMBOL", "GRANT_SYMBOL", "READ_SYMBOL", "DELETE_SYMBOL", 
                      "GROUP_SYMBOL", "REVOKE_SYMBOL", "ACCOUNT_SYMBOL", 
                      "LOCK_SYMBOL", "UNLOCK_SYMBOL", "GRANTS_SYMBOL", "FOR_SYMBOL", 
                      "LEVEL_SYMBOL", "ANY_SYMBOL", "CLIENT_SYMBOL", "URL_SYMBOL", 
                      "NAME_SYMBOL", "DO_SYMBOL", "ALL_SYMBOL", "PARAMETERS_SYMBOL", 
                      "ADD_SYMBOL", "REMOVE_SYMBOL", "MERGE_SYMBOL", "COMMENT_SYMBOL", 
                      "DYNAMIC_SYMBOL", "SQL_SYMBOL", "AND_SYMBOL", "DESCRIPTION_SYMBOL", 
                      "CONFIGURE_SYMBOL", "REST_SYMBOL", "METADATA_SYMBOL", 
                      "SERVICES_SYMBOL", "SERVICE_SYMBOL", "VIEWS_SYMBOL", 
                      "PROCEDURES_SYMBOL", "FUNCTIONS_SYMBOL", "RESULT_SYMBOL", 
                      "ENABLED_SYMBOL", "PUBLISHED_SYMBOL", "DISABLED_SYMBOL", 
                      "PRIVATE_SYMBOL", "UNPUBLISHED_SYMBOL", "PROTOCOL_SYMBOL", 
                      "HTTP_SYMBOL", "HTTPS_SYMBOL", "REQUEST_SYMBOL", "REDIRECTION_SYMBOL", 
                      "MANAGEMENT_SYMBOL", "AVAILABLE_SYMBOL", "REQUIRED_SYMBOL", 
                      "ITEMS_SYMBOL", "PER_SYMBOL", "CONTENT_SYMBOL", "MEDIA_SYMBOL", 
                      "AUTODETECT_SYMBOL", "FEED_SYMBOL", "ITEM_SYMBOL", 
                      "SETS_SYMBOL", "AUTH_SYMBOL", "APPS_SYMBOL", "APP_SYMBOL", 
                      "ID_SYMBOL", "SECRET_SYMBOL", "VENDOR_SYMBOL", "MRS_SYMBOL", 
                      "MYSQL_SYMBOL", "USERS_SYMBOL", "ALLOW_SYMBOL", "REGISTER_SYMBOL", 
                      "CLASS_SYMBOL", "DEVELOPMENT_SYMBOL", "SCRIPTS_SYMBOL", 
                      "MAPPING_SYMBOL", "TYPESCRIPT_SYMBOL", "ROLES_SYMBOL", 
                      "EXTENDS_SYMBOL", "OBJECT_SYMBOL", "HIERARCHY_SYMBOL", 
                      "INCLUDE_SYMBOL", "INCLUDING_SYMBOL", "ENDPOINTS_SYMBOL", 
                      "OBJECTS_SYMBOL", "DUMP_SYMBOL", "ZIP_SYMBOL", "SCRIPT_SYMBOL", 
                      "STATIC_SYMBOL", "PROJECT_SYMBOL", "VERSION_SYMBOL", 
                      "ICON_SYMBOL", "PUBLISHER_SYMBOL", "AT_INOUT_SYMBOL", 
                      "AT_IN_SYMBOL", "AT_OUT_SYMBOL", "AT_CHECK_SYMBOL", 
                      "AT_NOCHECK_SYMBOL", "AT_NOUPDATE_SYMBOL", "AT_SORTABLE_SYMBOL", 
                      "AT_NOFILTERING_SYMBOL", "AT_ROWOWNERSHIP_SYMBOL", 
                      "AT_UNNEST_SYMBOL", "AT_DATATYPE_SYMBOL", "AT_SELECT_SYMBOL", 
                      "AT_NOSELECT_SYMBOL", "AT_INSERT_SYMBOL", "AT_NOINSERT_SYMBOL", 
                      "AT_UPDATE_SYMBOL", "AT_DELETE_SYMBOL", "AT_NODELETE_SYMBOL", 
                      "AT_KEY_SYMBOL", "REST_REQUEST_PATH", "EQUAL_OPERATOR", 
                      "ASSIGN_OPERATOR", "NULL_SAFE_EQUAL_OPERATOR", "GREATER_OR_EQUAL_OPERATOR", 
                      "GREATER_THAN_OPERATOR", "LESS_OR_EQUAL_OPERATOR", 
                      "LESS_THAN_OPERATOR", "NOT_EQUAL_OPERATOR", "PLUS_OPERATOR", 
                      "MINUS_OPERATOR", "MULT_OPERATOR", "DIV_OPERATOR", 
                      "MOD_OPERATOR", "LOGICAL_NOT_OPERATOR", "BITWISE_NOT_OPERATOR", 
                      "SHIFT_LEFT_OPERATOR", "SHIFT_RIGHT_OPERATOR", "LOGICAL_AND_OPERATOR", 
                      "BITWISE_AND_OPERATOR", "BITWISE_XOR_OPERATOR", "LOGICAL_OR_OPERATOR", 
                      "BITWISE_OR_OPERATOR", "DOT_SYMBOL", "COMMA_SYMBOL", 
                      "SEMICOLON_SYMBOL", "COLON_SYMBOL", "OPEN_PAR_SYMBOL", 
                      "CLOSE_PAR_SYMBOL", "OPEN_CURLY_SYMBOL", "CLOSE_CURLY_SYMBOL", 
                      "UNDERLINE_SYMBOL", "OPEN_SQUARE_SYMBOL", "CLOSE_SQUARE_SYMBOL", 
                      "JSON_SEPARATOR_SYMBOL", "JSON_UNQUOTED_SEPARATOR_SYMBOL", 
                      "AT_SIGN_SYMBOL", "AT_TEXT_SUFFIX", "AT_AT_SIGN_SYMBOL", 
                      "NULL2_SYMBOL", "PARAM_MARKER", "HEX_NUMBER", "BIN_NUMBER", 
                      "INT_NUMBER", "DECIMAL_NUMBER", "FLOAT_NUMBER", "WHITESPACE", 
                      "INVALID_INPUT", "IDENTIFIER", "NCHAR_TEXT", "BACK_TICK_QUOTED_ID", 
                      "DOUBLE_QUOTED_TEXT", "SINGLE_QUOTED_TEXT", "BLOCK_COMMENT", 
                      "POUND_COMMENT", "DASHDASH_COMMENT", "WS", "NOT_EQUAL2_OPERATOR", 
                      "FILES_SYMBOL" ]

    RULE_mrsScript = 0
    RULE_mrsStatement = 1
    RULE_enabledDisabled = 2
    RULE_enabledDisabledPrivate = 3
    RULE_quotedTextOrDefault = 4
    RULE_jsonOptions = 5
    RULE_metadata = 6
    RULE_comments = 7
    RULE_authenticationRequired = 8
    RULE_itemsPerPage = 9
    RULE_itemsPerPageNumber = 10
    RULE_serviceSchemaSelector = 11
    RULE_serviceSchemaSelectorWildcard = 12
    RULE_roleService = 13
    RULE_configureRestMetadataStatement = 14
    RULE_restMetadataOptions = 15
    RULE_updateIfAvailable = 16
    RULE_createRestServiceStatement = 17
    RULE_restServiceOptions = 18
    RULE_publishedUnpublished = 19
    RULE_restProtocol = 20
    RULE_restAuthentication = 21
    RULE_authPath = 22
    RULE_authRedirection = 23
    RULE_authValidation = 24
    RULE_authPageContent = 25
    RULE_userManagementSchema = 26
    RULE_addAuthApp = 27
    RULE_removeAuthApp = 28
    RULE_createRestSchemaStatement = 29
    RULE_restSchemaOptions = 30
    RULE_createRestViewStatement = 31
    RULE_restObjectOptions = 32
    RULE_restViewMediaType = 33
    RULE_restViewFormat = 34
    RULE_restViewAuthenticationProcedure = 35
    RULE_createRestProcedureStatement = 36
    RULE_restProcedureResult = 37
    RULE_createRestFunctionStatement = 38
    RULE_restFunctionResult = 39
    RULE_createRestContentSetStatement = 40
    RULE_directoryFilePath = 41
    RULE_restContentSetOptions = 42
    RULE_fileIgnoreList = 43
    RULE_loadScripts = 44
    RULE_createRestContentFileStatement = 45
    RULE_restContentFileOptions = 46
    RULE_createRestAuthAppStatement = 47
    RULE_authAppName = 48
    RULE_vendorName = 49
    RULE_restAuthAppOptions = 50
    RULE_allowNewUsersToRegister = 51
    RULE_defaultRole = 52
    RULE_appId = 53
    RULE_appSecret = 54
    RULE_url = 55
    RULE_createRestUserStatement = 56
    RULE_userName = 57
    RULE_userPassword = 58
    RULE_userOptions = 59
    RULE_appOptions = 60
    RULE_accountLock = 61
    RULE_createRestRoleStatement = 62
    RULE_restRoleOptions = 63
    RULE_parentRoleName = 64
    RULE_roleName = 65
    RULE_cloneRestServiceStatement = 66
    RULE_alterRestServiceStatement = 67
    RULE_alterRestSchemaStatement = 68
    RULE_alterRestViewStatement = 69
    RULE_alterRestProcedureStatement = 70
    RULE_alterRestFunctionStatement = 71
    RULE_alterRestContentSetStatement = 72
    RULE_alterRestAuthAppStatement = 73
    RULE_newAuthAppName = 74
    RULE_alterRestUserStatement = 75
    RULE_dropRestServiceStatement = 76
    RULE_dropRestSchemaStatement = 77
    RULE_dropRestViewStatement = 78
    RULE_dropRestProcedureStatement = 79
    RULE_dropRestFunctionStatement = 80
    RULE_dropRestContentSetStatement = 81
    RULE_dropRestContentFileStatement = 82
    RULE_dropRestAuthAppStatement = 83
    RULE_dropRestUserStatement = 84
    RULE_dropRestRoleStatement = 85
    RULE_grantRestPrivilegeStatement = 86
    RULE_privilegeList = 87
    RULE_privilegeName = 88
    RULE_grantRestRoleStatement = 89
    RULE_revokeRestPrivilegeStatement = 90
    RULE_revokeRestRoleStatement = 91
    RULE_useStatement = 92
    RULE_serviceAndSchemaRequestPaths = 93
    RULE_showRestMetadataStatusStatement = 94
    RULE_showRestServicesStatement = 95
    RULE_showRestSchemasStatement = 96
    RULE_showRestViewsStatement = 97
    RULE_showRestProceduresStatement = 98
    RULE_showRestFunctionsStatement = 99
    RULE_showRestContentSetsStatement = 100
    RULE_showRestContentFilesStatement = 101
    RULE_showRestAuthAppsStatement = 102
    RULE_showRestRolesStatement = 103
    RULE_showRestGrantsStatement = 104
    RULE_showCreateRestServiceStatement = 105
    RULE_showCreateRestSchemaStatement = 106
    RULE_showCreateRestViewStatement = 107
    RULE_showCreateRestProcedureStatement = 108
    RULE_showCreateRestFunctionStatement = 109
    RULE_showCreateRestContentSetStatement = 110
    RULE_showCreateRestContentFileStatement = 111
    RULE_showCreateRestAuthAppStatement = 112
    RULE_showCreateRestRoleStatement = 113
    RULE_showCreateRestUserStatement = 114
    RULE_dumpRestServiceStatement = 115
    RULE_dumpRestProjectStatement = 116
    RULE_loadRestServiceStatement = 117
    RULE_loadRestProjectStatement = 118
    RULE_dumpRestProjectService = 119
    RULE_dumpRestProjectDatabaseSchema = 120
    RULE_dumpRestProjectSettings = 121
    RULE_restProjectName = 122
    RULE_restProjectDatabaseSchemaFilePath = 123
    RULE_restProjectIconFilePath = 124
    RULE_restProjectDescription = 125
    RULE_restProjectPublisher = 126
    RULE_restProjectVersion = 127
    RULE_serviceRequestPath = 128
    RULE_newServiceRequestPath = 129
    RULE_serviceRequestPathWildcard = 130
    RULE_schemaRequestPath = 131
    RULE_newSchemaRequestPath = 132
    RULE_schemaRequestPathWildcard = 133
    RULE_viewRequestPath = 134
    RULE_newViewRequestPath = 135
    RULE_restObjectName = 136
    RULE_restResultName = 137
    RULE_objectRequestPath = 138
    RULE_objectRequestPathWildcard = 139
    RULE_procedureRequestPath = 140
    RULE_functionRequestPath = 141
    RULE_newProcedureRequestPath = 142
    RULE_newFunctionRequestPath = 143
    RULE_contentSetRequestPath = 144
    RULE_newContentSetRequestPath = 145
    RULE_contentFileRequestPath = 146
    RULE_serviceDeveloperIdentifier = 147
    RULE_serviceDevelopersIdentifier = 148
    RULE_requestPathIdentifier = 149
    RULE_requestPathIdentifierWithWildcard = 150
    RULE_jsonObj = 151
    RULE_jsonPair = 152
    RULE_jsonArr = 153
    RULE_jsonValue = 154
    RULE_graphQlObj = 155
    RULE_graphQlCrudOptions = 156
    RULE_graphQlPair = 157
    RULE_graphQlValueOptions = 158
    RULE_graphQlValueJsonSchema = 159
    RULE_graphQlAllowedKeyword = 160
    RULE_graphQlPairKey = 161
    RULE_graphQlPairValue = 162
    RULE_graphQlReduceToValue = 163
    RULE_graphQlDatatypeValue = 164
    RULE_graphQlValue = 165
    RULE_schemaName = 166
    RULE_viewName = 167
    RULE_procedureName = 168
    RULE_pureIdentifier = 169
    RULE_identifier = 170
    RULE_identifierList = 171
    RULE_identifierListWithParentheses = 172
    RULE_qualifiedIdentifier = 173
    RULE_simpleIdentifier = 174
    RULE_dotIdentifier = 175
    RULE_textStringLiteral = 176
    RULE_textOrIdentifier = 177

    ruleNames =  [ "mrsScript", "mrsStatement", "enabledDisabled", "enabledDisabledPrivate", 
                   "quotedTextOrDefault", "jsonOptions", "metadata", "comments", 
                   "authenticationRequired", "itemsPerPage", "itemsPerPageNumber", 
                   "serviceSchemaSelector", "serviceSchemaSelectorWildcard", 
                   "roleService", "configureRestMetadataStatement", "restMetadataOptions", 
                   "updateIfAvailable", "createRestServiceStatement", "restServiceOptions", 
                   "publishedUnpublished", "restProtocol", "restAuthentication", 
                   "authPath", "authRedirection", "authValidation", "authPageContent", 
                   "userManagementSchema", "addAuthApp", "removeAuthApp", 
                   "createRestSchemaStatement", "restSchemaOptions", "createRestViewStatement", 
                   "restObjectOptions", "restViewMediaType", "restViewFormat", 
                   "restViewAuthenticationProcedure", "createRestProcedureStatement", 
                   "restProcedureResult", "createRestFunctionStatement", 
                   "restFunctionResult", "createRestContentSetStatement", 
                   "directoryFilePath", "restContentSetOptions", "fileIgnoreList", 
                   "loadScripts", "createRestContentFileStatement", "restContentFileOptions", 
                   "createRestAuthAppStatement", "authAppName", "vendorName", 
                   "restAuthAppOptions", "allowNewUsersToRegister", "defaultRole", 
                   "appId", "appSecret", "url", "createRestUserStatement", 
                   "userName", "userPassword", "userOptions", "appOptions", 
                   "accountLock", "createRestRoleStatement", "restRoleOptions", 
                   "parentRoleName", "roleName", "cloneRestServiceStatement", 
                   "alterRestServiceStatement", "alterRestSchemaStatement", 
                   "alterRestViewStatement", "alterRestProcedureStatement", 
                   "alterRestFunctionStatement", "alterRestContentSetStatement", 
                   "alterRestAuthAppStatement", "newAuthAppName", "alterRestUserStatement", 
                   "dropRestServiceStatement", "dropRestSchemaStatement", 
                   "dropRestViewStatement", "dropRestProcedureStatement", 
                   "dropRestFunctionStatement", "dropRestContentSetStatement", 
                   "dropRestContentFileStatement", "dropRestAuthAppStatement", 
                   "dropRestUserStatement", "dropRestRoleStatement", "grantRestPrivilegeStatement", 
                   "privilegeList", "privilegeName", "grantRestRoleStatement", 
                   "revokeRestPrivilegeStatement", "revokeRestRoleStatement", 
                   "useStatement", "serviceAndSchemaRequestPaths", "showRestMetadataStatusStatement", 
                   "showRestServicesStatement", "showRestSchemasStatement", 
                   "showRestViewsStatement", "showRestProceduresStatement", 
                   "showRestFunctionsStatement", "showRestContentSetsStatement", 
                   "showRestContentFilesStatement", "showRestAuthAppsStatement", 
                   "showRestRolesStatement", "showRestGrantsStatement", 
                   "showCreateRestServiceStatement", "showCreateRestSchemaStatement", 
                   "showCreateRestViewStatement", "showCreateRestProcedureStatement", 
                   "showCreateRestFunctionStatement", "showCreateRestContentSetStatement", 
                   "showCreateRestContentFileStatement", "showCreateRestAuthAppStatement", 
                   "showCreateRestRoleStatement", "showCreateRestUserStatement", 
                   "dumpRestServiceStatement", "dumpRestProjectStatement", 
                   "loadRestServiceStatement", "loadRestProjectStatement", 
                   "dumpRestProjectService", "dumpRestProjectDatabaseSchema", 
                   "dumpRestProjectSettings", "restProjectName", "restProjectDatabaseSchemaFilePath", 
                   "restProjectIconFilePath", "restProjectDescription", 
                   "restProjectPublisher", "restProjectVersion", "serviceRequestPath", 
                   "newServiceRequestPath", "serviceRequestPathWildcard", 
                   "schemaRequestPath", "newSchemaRequestPath", "schemaRequestPathWildcard", 
                   "viewRequestPath", "newViewRequestPath", "restObjectName", 
                   "restResultName", "objectRequestPath", "objectRequestPathWildcard", 
                   "procedureRequestPath", "functionRequestPath", "newProcedureRequestPath", 
                   "newFunctionRequestPath", "contentSetRequestPath", "newContentSetRequestPath", 
                   "contentFileRequestPath", "serviceDeveloperIdentifier", 
                   "serviceDevelopersIdentifier", "requestPathIdentifier", 
                   "requestPathIdentifierWithWildcard", "jsonObj", "jsonPair", 
                   "jsonArr", "jsonValue", "graphQlObj", "graphQlCrudOptions", 
                   "graphQlPair", "graphQlValueOptions", "graphQlValueJsonSchema", 
                   "graphQlAllowedKeyword", "graphQlPairKey", "graphQlPairValue", 
                   "graphQlReduceToValue", "graphQlDatatypeValue", "graphQlValue", 
                   "schemaName", "viewName", "procedureName", "pureIdentifier", 
                   "identifier", "identifierList", "identifierListWithParentheses", 
                   "qualifiedIdentifier", "simpleIdentifier", "dotIdentifier", 
                   "textStringLiteral", "textOrIdentifier" ]

    EOF = Token.EOF
    CREATE_SYMBOL=1
    OR_SYMBOL=2
    REPLACE_SYMBOL=3
    ALTER_SYMBOL=4
    SHOW_SYMBOL=5
    STATUS_SYMBOL=6
    NEW_SYMBOL=7
    ON_SYMBOL=8
    FROM_SYMBOL=9
    IN_SYMBOL=10
    DATABASES_SYMBOL=11
    DATABASE_SYMBOL=12
    JSON_SYMBOL=13
    VIEW_SYMBOL=14
    PROCEDURE_SYMBOL=15
    FUNCTION_SYMBOL=16
    DROP_SYMBOL=17
    USE_SYMBOL=18
    AS_SYMBOL=19
    FILTER_SYMBOL=20
    AUTHENTICATION_SYMBOL=21
    PATH_SYMBOL=22
    VALIDATION_SYMBOL=23
    DEFAULT_SYMBOL=24
    USER_SYMBOL=25
    OPTIONS_SYMBOL=26
    IF_SYMBOL=27
    NOT_SYMBOL=28
    EXISTS_SYMBOL=29
    PAGE_SYMBOL=30
    HOST_SYMBOL=31
    TYPE_SYMBOL=32
    FORMAT_SYMBOL=33
    FORCE_SYMBOL=34
    UPDATE_SYMBOL=35
    NULL_SYMBOL=36
    TRUE_SYMBOL=37
    FALSE_SYMBOL=38
    SET_SYMBOL=39
    IDENTIFIED_SYMBOL=40
    BY_SYMBOL=41
    ROLE_SYMBOL=42
    TO_SYMBOL=43
    IGNORE_SYMBOL=44
    CLONE_SYMBOL=45
    FILE_SYMBOL=46
    BINARY_SYMBOL=47
    DATA_SYMBOL=48
    LOAD_SYMBOL=49
    GRANT_SYMBOL=50
    READ_SYMBOL=51
    DELETE_SYMBOL=52
    GROUP_SYMBOL=53
    REVOKE_SYMBOL=54
    ACCOUNT_SYMBOL=55
    LOCK_SYMBOL=56
    UNLOCK_SYMBOL=57
    GRANTS_SYMBOL=58
    FOR_SYMBOL=59
    LEVEL_SYMBOL=60
    ANY_SYMBOL=61
    CLIENT_SYMBOL=62
    URL_SYMBOL=63
    NAME_SYMBOL=64
    DO_SYMBOL=65
    ALL_SYMBOL=66
    PARAMETERS_SYMBOL=67
    ADD_SYMBOL=68
    REMOVE_SYMBOL=69
    MERGE_SYMBOL=70
    COMMENT_SYMBOL=71
    DYNAMIC_SYMBOL=72
    SQL_SYMBOL=73
    AND_SYMBOL=74
    DESCRIPTION_SYMBOL=75
    CONFIGURE_SYMBOL=76
    REST_SYMBOL=77
    METADATA_SYMBOL=78
    SERVICES_SYMBOL=79
    SERVICE_SYMBOL=80
    VIEWS_SYMBOL=81
    PROCEDURES_SYMBOL=82
    FUNCTIONS_SYMBOL=83
    RESULT_SYMBOL=84
    ENABLED_SYMBOL=85
    PUBLISHED_SYMBOL=86
    DISABLED_SYMBOL=87
    PRIVATE_SYMBOL=88
    UNPUBLISHED_SYMBOL=89
    PROTOCOL_SYMBOL=90
    HTTP_SYMBOL=91
    HTTPS_SYMBOL=92
    REQUEST_SYMBOL=93
    REDIRECTION_SYMBOL=94
    MANAGEMENT_SYMBOL=95
    AVAILABLE_SYMBOL=96
    REQUIRED_SYMBOL=97
    ITEMS_SYMBOL=98
    PER_SYMBOL=99
    CONTENT_SYMBOL=100
    MEDIA_SYMBOL=101
    AUTODETECT_SYMBOL=102
    FEED_SYMBOL=103
    ITEM_SYMBOL=104
    SETS_SYMBOL=105
    AUTH_SYMBOL=106
    APPS_SYMBOL=107
    APP_SYMBOL=108
    ID_SYMBOL=109
    SECRET_SYMBOL=110
    VENDOR_SYMBOL=111
    MRS_SYMBOL=112
    MYSQL_SYMBOL=113
    USERS_SYMBOL=114
    ALLOW_SYMBOL=115
    REGISTER_SYMBOL=116
    CLASS_SYMBOL=117
    DEVELOPMENT_SYMBOL=118
    SCRIPTS_SYMBOL=119
    MAPPING_SYMBOL=120
    TYPESCRIPT_SYMBOL=121
    ROLES_SYMBOL=122
    EXTENDS_SYMBOL=123
    OBJECT_SYMBOL=124
    HIERARCHY_SYMBOL=125
    INCLUDE_SYMBOL=126
    INCLUDING_SYMBOL=127
    ENDPOINTS_SYMBOL=128
    OBJECTS_SYMBOL=129
    DUMP_SYMBOL=130
    ZIP_SYMBOL=131
    SCRIPT_SYMBOL=132
    STATIC_SYMBOL=133
    PROJECT_SYMBOL=134
    VERSION_SYMBOL=135
    ICON_SYMBOL=136
    PUBLISHER_SYMBOL=137
    AT_INOUT_SYMBOL=138
    AT_IN_SYMBOL=139
    AT_OUT_SYMBOL=140
    AT_CHECK_SYMBOL=141
    AT_NOCHECK_SYMBOL=142
    AT_NOUPDATE_SYMBOL=143
    AT_SORTABLE_SYMBOL=144
    AT_NOFILTERING_SYMBOL=145
    AT_ROWOWNERSHIP_SYMBOL=146
    AT_UNNEST_SYMBOL=147
    AT_DATATYPE_SYMBOL=148
    AT_SELECT_SYMBOL=149
    AT_NOSELECT_SYMBOL=150
    AT_INSERT_SYMBOL=151
    AT_NOINSERT_SYMBOL=152
    AT_UPDATE_SYMBOL=153
    AT_DELETE_SYMBOL=154
    AT_NODELETE_SYMBOL=155
    AT_KEY_SYMBOL=156
    REST_REQUEST_PATH=157
    EQUAL_OPERATOR=158
    ASSIGN_OPERATOR=159
    NULL_SAFE_EQUAL_OPERATOR=160
    GREATER_OR_EQUAL_OPERATOR=161
    GREATER_THAN_OPERATOR=162
    LESS_OR_EQUAL_OPERATOR=163
    LESS_THAN_OPERATOR=164
    NOT_EQUAL_OPERATOR=165
    PLUS_OPERATOR=166
    MINUS_OPERATOR=167
    MULT_OPERATOR=168
    DIV_OPERATOR=169
    MOD_OPERATOR=170
    LOGICAL_NOT_OPERATOR=171
    BITWISE_NOT_OPERATOR=172
    SHIFT_LEFT_OPERATOR=173
    SHIFT_RIGHT_OPERATOR=174
    LOGICAL_AND_OPERATOR=175
    BITWISE_AND_OPERATOR=176
    BITWISE_XOR_OPERATOR=177
    LOGICAL_OR_OPERATOR=178
    BITWISE_OR_OPERATOR=179
    DOT_SYMBOL=180
    COMMA_SYMBOL=181
    SEMICOLON_SYMBOL=182
    COLON_SYMBOL=183
    OPEN_PAR_SYMBOL=184
    CLOSE_PAR_SYMBOL=185
    OPEN_CURLY_SYMBOL=186
    CLOSE_CURLY_SYMBOL=187
    UNDERLINE_SYMBOL=188
    OPEN_SQUARE_SYMBOL=189
    CLOSE_SQUARE_SYMBOL=190
    JSON_SEPARATOR_SYMBOL=191
    JSON_UNQUOTED_SEPARATOR_SYMBOL=192
    AT_SIGN_SYMBOL=193
    AT_TEXT_SUFFIX=194
    AT_AT_SIGN_SYMBOL=195
    NULL2_SYMBOL=196
    PARAM_MARKER=197
    HEX_NUMBER=198
    BIN_NUMBER=199
    INT_NUMBER=200
    DECIMAL_NUMBER=201
    FLOAT_NUMBER=202
    WHITESPACE=203
    INVALID_INPUT=204
    IDENTIFIER=205
    NCHAR_TEXT=206
    BACK_TICK_QUOTED_ID=207
    DOUBLE_QUOTED_TEXT=208
    SINGLE_QUOTED_TEXT=209
    BLOCK_COMMENT=210
    POUND_COMMENT=211
    DASHDASH_COMMENT=212
    WS=213
    NOT_EQUAL2_OPERATOR=214
    FILES_SYMBOL=215

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

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

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

        def mrsStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.MrsStatementContext)
            else:
                return self.getTypedRuleContext(MRSParser.MrsStatementContext,i)


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

        def getRuleIndex(self):
            return MRSParser.RULE_mrsScript

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

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




    def mrsScript(self):

        localctx = MRSParser.MrsScriptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_mrsScript)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 368
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 19738432742228018) != 0) or _la==76 or _la==130:
                self.state = 356
                self.mrsStatement()
                self.state = 365
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 358 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 357
                            self.match(MRSParser.SEMICOLON_SYMBOL)
                            self.state = 360 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==182):
                                break

                        self.state = 362
                        self.mrsStatement() 
                    self.state = 367
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,1,self._ctx)



            self.state = 371
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==182:
                self.state = 370
                self.match(MRSParser.SEMICOLON_SYMBOL)


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


    class MrsStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def configureRestMetadataStatement(self):
            return self.getTypedRuleContext(MRSParser.ConfigureRestMetadataStatementContext,0)


        def createRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestServiceStatementContext,0)


        def createRestSchemaStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestSchemaStatementContext,0)


        def createRestViewStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestViewStatementContext,0)


        def createRestProcedureStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestProcedureStatementContext,0)


        def createRestFunctionStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestFunctionStatementContext,0)


        def createRestContentSetStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestContentSetStatementContext,0)


        def createRestContentFileStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestContentFileStatementContext,0)


        def createRestAuthAppStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestAuthAppStatementContext,0)


        def createRestRoleStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestRoleStatementContext,0)


        def createRestUserStatement(self):
            return self.getTypedRuleContext(MRSParser.CreateRestUserStatementContext,0)


        def cloneRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.CloneRestServiceStatementContext,0)


        def alterRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestServiceStatementContext,0)


        def alterRestSchemaStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestSchemaStatementContext,0)


        def alterRestViewStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestViewStatementContext,0)


        def alterRestProcedureStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestProcedureStatementContext,0)


        def alterRestFunctionStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestFunctionStatementContext,0)


        def alterRestContentSetStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestContentSetStatementContext,0)


        def alterRestAuthAppStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestAuthAppStatementContext,0)


        def alterRestUserStatement(self):
            return self.getTypedRuleContext(MRSParser.AlterRestUserStatementContext,0)


        def dropRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestServiceStatementContext,0)


        def dropRestSchemaStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestSchemaStatementContext,0)


        def dropRestViewStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestViewStatementContext,0)


        def dropRestProcedureStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestProcedureStatementContext,0)


        def dropRestFunctionStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestFunctionStatementContext,0)


        def dropRestContentSetStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestContentSetStatementContext,0)


        def dropRestContentFileStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestContentFileStatementContext,0)


        def dropRestAuthAppStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestAuthAppStatementContext,0)


        def dropRestUserStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestUserStatementContext,0)


        def dropRestRoleStatement(self):
            return self.getTypedRuleContext(MRSParser.DropRestRoleStatementContext,0)


        def dumpRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.DumpRestServiceStatementContext,0)


        def dumpRestProjectStatement(self):
            return self.getTypedRuleContext(MRSParser.DumpRestProjectStatementContext,0)


        def grantRestRoleStatement(self):
            return self.getTypedRuleContext(MRSParser.GrantRestRoleStatementContext,0)


        def grantRestPrivilegeStatement(self):
            return self.getTypedRuleContext(MRSParser.GrantRestPrivilegeStatementContext,0)


        def loadRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.LoadRestServiceStatementContext,0)


        def loadRestProjectStatement(self):
            return self.getTypedRuleContext(MRSParser.LoadRestProjectStatementContext,0)


        def revokeRestPrivilegeStatement(self):
            return self.getTypedRuleContext(MRSParser.RevokeRestPrivilegeStatementContext,0)


        def revokeRestRoleStatement(self):
            return self.getTypedRuleContext(MRSParser.RevokeRestRoleStatementContext,0)


        def useStatement(self):
            return self.getTypedRuleContext(MRSParser.UseStatementContext,0)


        def showRestMetadataStatusStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestMetadataStatusStatementContext,0)


        def showRestServicesStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestServicesStatementContext,0)


        def showRestSchemasStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestSchemasStatementContext,0)


        def showRestViewsStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestViewsStatementContext,0)


        def showRestProceduresStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestProceduresStatementContext,0)


        def showRestFunctionsStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestFunctionsStatementContext,0)


        def showRestContentSetsStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestContentSetsStatementContext,0)


        def showRestContentFilesStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestContentFilesStatementContext,0)


        def showRestAuthAppsStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestAuthAppsStatementContext,0)


        def showRestRolesStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestRolesStatementContext,0)


        def showRestGrantsStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowRestGrantsStatementContext,0)


        def showCreateRestServiceStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestServiceStatementContext,0)


        def showCreateRestSchemaStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestSchemaStatementContext,0)


        def showCreateRestViewStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestViewStatementContext,0)


        def showCreateRestProcedureStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestProcedureStatementContext,0)


        def showCreateRestFunctionStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestFunctionStatementContext,0)


        def showCreateRestContentSetStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestContentSetStatementContext,0)


        def showCreateRestContentFileStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestContentFileStatementContext,0)


        def showCreateRestAuthAppStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestAuthAppStatementContext,0)


        def showCreateRestRoleStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestRoleStatementContext,0)


        def showCreateRestUserStatement(self):
            return self.getTypedRuleContext(MRSParser.ShowCreateRestUserStatementContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_mrsStatement

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

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




    def mrsStatement(self):

        localctx = MRSParser.MrsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_mrsStatement)
        try:
            self.state = 435
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 375
                self.configureRestMetadataStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 376
                self.createRestServiceStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 377
                self.createRestSchemaStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 378
                self.createRestViewStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 379
                self.createRestProcedureStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 380
                self.createRestFunctionStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 381
                self.createRestContentSetStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 382
                self.createRestContentFileStatement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 383
                self.createRestAuthAppStatement()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 384
                self.createRestRoleStatement()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 385
                self.createRestUserStatement()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 386
                self.cloneRestServiceStatement()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 387
                self.alterRestServiceStatement()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 388
                self.alterRestSchemaStatement()
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 389
                self.alterRestViewStatement()
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 390
                self.alterRestProcedureStatement()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 391
                self.alterRestFunctionStatement()
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 392
                self.alterRestContentSetStatement()
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 393
                self.alterRestAuthAppStatement()
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 394
                self.alterRestUserStatement()
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 395
                self.dropRestServiceStatement()
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 396
                self.dropRestSchemaStatement()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 397
                self.dropRestViewStatement()
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 398
                self.dropRestProcedureStatement()
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 399
                self.dropRestFunctionStatement()
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 400
                self.dropRestContentSetStatement()
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 401
                self.dropRestContentFileStatement()
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 402
                self.dropRestAuthAppStatement()
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 403
                self.dropRestUserStatement()
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 404
                self.dropRestRoleStatement()
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 405
                self.dumpRestServiceStatement()
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 406
                self.dumpRestProjectStatement()
                pass

            elif la_ == 33:
                self.enterOuterAlt(localctx, 33)
                self.state = 407
                self.grantRestRoleStatement()
                pass

            elif la_ == 34:
                self.enterOuterAlt(localctx, 34)
                self.state = 408
                self.grantRestPrivilegeStatement()
                pass

            elif la_ == 35:
                self.enterOuterAlt(localctx, 35)
                self.state = 409
                self.loadRestServiceStatement()
                pass

            elif la_ == 36:
                self.enterOuterAlt(localctx, 36)
                self.state = 410
                self.loadRestProjectStatement()
                pass

            elif la_ == 37:
                self.enterOuterAlt(localctx, 37)
                self.state = 411
                self.revokeRestPrivilegeStatement()
                pass

            elif la_ == 38:
                self.enterOuterAlt(localctx, 38)
                self.state = 412
                self.revokeRestRoleStatement()
                pass

            elif la_ == 39:
                self.enterOuterAlt(localctx, 39)
                self.state = 413
                self.useStatement()
                pass

            elif la_ == 40:
                self.enterOuterAlt(localctx, 40)
                self.state = 414
                self.showRestMetadataStatusStatement()
                pass

            elif la_ == 41:
                self.enterOuterAlt(localctx, 41)
                self.state = 415
                self.showRestServicesStatement()
                pass

            elif la_ == 42:
                self.enterOuterAlt(localctx, 42)
                self.state = 416
                self.showRestSchemasStatement()
                pass

            elif la_ == 43:
                self.enterOuterAlt(localctx, 43)
                self.state = 417
                self.showRestViewsStatement()
                pass

            elif la_ == 44:
                self.enterOuterAlt(localctx, 44)
                self.state = 418
                self.showRestProceduresStatement()
                pass

            elif la_ == 45:
                self.enterOuterAlt(localctx, 45)
                self.state = 419
                self.showRestFunctionsStatement()
                pass

            elif la_ == 46:
                self.enterOuterAlt(localctx, 46)
                self.state = 420
                self.showRestContentSetsStatement()
                pass

            elif la_ == 47:
                self.enterOuterAlt(localctx, 47)
                self.state = 421
                self.showRestContentFilesStatement()
                pass

            elif la_ == 48:
                self.enterOuterAlt(localctx, 48)
                self.state = 422
                self.showRestAuthAppsStatement()
                pass

            elif la_ == 49:
                self.enterOuterAlt(localctx, 49)
                self.state = 423
                self.showRestRolesStatement()
                pass

            elif la_ == 50:
                self.enterOuterAlt(localctx, 50)
                self.state = 424
                self.showRestGrantsStatement()
                pass

            elif la_ == 51:
                self.enterOuterAlt(localctx, 51)
                self.state = 425
                self.showCreateRestServiceStatement()
                pass

            elif la_ == 52:
                self.enterOuterAlt(localctx, 52)
                self.state = 426
                self.showCreateRestSchemaStatement()
                pass

            elif la_ == 53:
                self.enterOuterAlt(localctx, 53)
                self.state = 427
                self.showCreateRestViewStatement()
                pass

            elif la_ == 54:
                self.enterOuterAlt(localctx, 54)
                self.state = 428
                self.showCreateRestProcedureStatement()
                pass

            elif la_ == 55:
                self.enterOuterAlt(localctx, 55)
                self.state = 429
                self.showCreateRestFunctionStatement()
                pass

            elif la_ == 56:
                self.enterOuterAlt(localctx, 56)
                self.state = 430
                self.showCreateRestContentSetStatement()
                pass

            elif la_ == 57:
                self.enterOuterAlt(localctx, 57)
                self.state = 431
                self.showCreateRestContentFileStatement()
                pass

            elif la_ == 58:
                self.enterOuterAlt(localctx, 58)
                self.state = 432
                self.showCreateRestAuthAppStatement()
                pass

            elif la_ == 59:
                self.enterOuterAlt(localctx, 59)
                self.state = 433
                self.showCreateRestRoleStatement()
                pass

            elif la_ == 60:
                self.enterOuterAlt(localctx, 60)
                self.state = 434
                self.showCreateRestUserStatement()
                pass


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


    class EnabledDisabledContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENABLED_SYMBOL(self):
            return self.getToken(MRSParser.ENABLED_SYMBOL, 0)

        def DISABLED_SYMBOL(self):
            return self.getToken(MRSParser.DISABLED_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_enabledDisabled

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

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




    def enabledDisabled(self):

        localctx = MRSParser.EnabledDisabledContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_enabledDisabled)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 437
            _la = self._input.LA(1)
            if not(_la==85 or _la==87):
                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 EnabledDisabledPrivateContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ENABLED_SYMBOL(self):
            return self.getToken(MRSParser.ENABLED_SYMBOL, 0)

        def DISABLED_SYMBOL(self):
            return self.getToken(MRSParser.DISABLED_SYMBOL, 0)

        def PRIVATE_SYMBOL(self):
            return self.getToken(MRSParser.PRIVATE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_enabledDisabledPrivate

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

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




    def enabledDisabledPrivate(self):

        localctx = MRSParser.EnabledDisabledPrivateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_enabledDisabledPrivate)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 439
            _la = self._input.LA(1)
            if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & 13) != 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 QuotedTextOrDefaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def DEFAULT_SYMBOL(self):
            return self.getToken(MRSParser.DEFAULT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_quotedTextOrDefault

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

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




    def quotedTextOrDefault(self):

        localctx = MRSParser.QuotedTextOrDefaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_quotedTextOrDefault)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 443
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.state = 441
                self.textStringLiteral()
                pass

            elif la_ == 2:
                self.state = 442
                self.match(MRSParser.DEFAULT_SYMBOL)
                pass


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


    class JsonOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPTIONS_SYMBOL(self):
            return self.getToken(MRSParser.OPTIONS_SYMBOL, 0)

        def jsonValue(self):
            return self.getTypedRuleContext(MRSParser.JsonValueContext,0)


        def MERGE_SYMBOL(self):
            return self.getToken(MRSParser.MERGE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_jsonOptions

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

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




    def jsonOptions(self):

        localctx = MRSParser.JsonOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_jsonOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 446
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==70:
                self.state = 445
                self.match(MRSParser.MERGE_SYMBOL)


            self.state = 448
            self.match(MRSParser.OPTIONS_SYMBOL)
            self.state = 449
            self.jsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MetadataContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def METADATA_SYMBOL(self):
            return self.getToken(MRSParser.METADATA_SYMBOL, 0)

        def jsonValue(self):
            return self.getTypedRuleContext(MRSParser.JsonValueContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_metadata

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

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




    def metadata(self):

        localctx = MRSParser.MetadataContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_metadata)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self.match(MRSParser.METADATA_SYMBOL)
            self.state = 452
            self.jsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CommentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def COMMENT_SYMBOL(self):
            return self.getToken(MRSParser.COMMENT_SYMBOL, 0)

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_comments

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

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




    def comments(self):

        localctx = MRSParser.CommentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_comments)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 454
            self.match(MRSParser.COMMENT_SYMBOL)
            self.state = 455
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AuthenticationRequiredContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def REQUIRED_SYMBOL(self):
            return self.getToken(MRSParser.REQUIRED_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_authenticationRequired

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

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




    def authenticationRequired(self):

        localctx = MRSParser.AuthenticationRequiredContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_authenticationRequired)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 457
            self.match(MRSParser.AUTHENTICATION_SYMBOL)
            self.state = 459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==28:
                self.state = 458
                self.match(MRSParser.NOT_SYMBOL)


            self.state = 461
            self.match(MRSParser.REQUIRED_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ItemsPerPageContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ITEMS_SYMBOL(self):
            return self.getToken(MRSParser.ITEMS_SYMBOL, 0)

        def PER_SYMBOL(self):
            return self.getToken(MRSParser.PER_SYMBOL, 0)

        def PAGE_SYMBOL(self):
            return self.getToken(MRSParser.PAGE_SYMBOL, 0)

        def itemsPerPageNumber(self):
            return self.getTypedRuleContext(MRSParser.ItemsPerPageNumberContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_itemsPerPage

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

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




    def itemsPerPage(self):

        localctx = MRSParser.ItemsPerPageContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_itemsPerPage)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.match(MRSParser.ITEMS_SYMBOL)
            self.state = 464
            self.match(MRSParser.PER_SYMBOL)
            self.state = 465
            self.match(MRSParser.PAGE_SYMBOL)
            self.state = 466
            self.itemsPerPageNumber()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ItemsPerPageNumberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INT_NUMBER(self):
            return self.getToken(MRSParser.INT_NUMBER, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_itemsPerPageNumber

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

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




    def itemsPerPageNumber(self):

        localctx = MRSParser.ItemsPerPageNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_itemsPerPageNumber)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 468
            self.match(MRSParser.INT_NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ServiceSchemaSelectorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaRequestPath(self):
            return self.getTypedRuleContext(MRSParser.SchemaRequestPathContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_serviceSchemaSelector

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

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




    def serviceSchemaSelector(self):

        localctx = MRSParser.ServiceSchemaSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_serviceSchemaSelector)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 472
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==80:
                self.state = 470
                self.match(MRSParser.SERVICE_SYMBOL)
                self.state = 471
                self.serviceRequestPath()


            self.state = 474
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 475
            self.schemaRequestPath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ServiceSchemaSelectorWildcardContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaRequestPathWildcard(self):
            return self.getTypedRuleContext(MRSParser.SchemaRequestPathWildcardContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPathWildcard(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathWildcardContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_serviceSchemaSelectorWildcard

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

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




    def serviceSchemaSelectorWildcard(self):

        localctx = MRSParser.ServiceSchemaSelectorWildcardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_serviceSchemaSelectorWildcard)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 479
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==80:
                self.state = 477
                self.match(MRSParser.SERVICE_SYMBOL)
                self.state = 478
                self.serviceRequestPathWildcard()


            self.state = 481
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 482
            self.schemaRequestPathWildcard()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RoleServiceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def ANY_SYMBOL(self):
            return self.getToken(MRSParser.ANY_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_roleService

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

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




    def roleService(self):

        localctx = MRSParser.RoleServiceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_roleService)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 484
            self.match(MRSParser.ON_SYMBOL)
            self.state = 491
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.state = 485
                self.match(MRSParser.ANY_SYMBOL)
                self.state = 486
                self.match(MRSParser.SERVICE_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 488
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
                if la_ == 1:
                    self.state = 487
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 490
                self.serviceRequestPath()
                pass


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


    class ConfigureRestMetadataStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONFIGURE_SYMBOL(self):
            return self.getToken(MRSParser.CONFIGURE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def METADATA_SYMBOL(self):
            return self.getToken(MRSParser.METADATA_SYMBOL, 0)

        def restMetadataOptions(self):
            return self.getTypedRuleContext(MRSParser.RestMetadataOptionsContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_configureRestMetadataStatement

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

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




    def configureRestMetadataStatement(self):

        localctx = MRSParser.ConfigureRestMetadataStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_configureRestMetadataStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 493
            self.match(MRSParser.CONFIGURE_SYMBOL)
            self.state = 494
            self.match(MRSParser.REST_SYMBOL)
            self.state = 495
            self.match(MRSParser.METADATA_SYMBOL)
            self.state = 497
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 26)) & ~0x3f) == 0 and ((1 << (_la - 26)) & 2882321353703162369) != 0):
                self.state = 496
                self.restMetadataOptions()


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


    class RestMetadataOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabled(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def updateIfAvailable(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.UpdateIfAvailableContext)
            else:
                return self.getTypedRuleContext(MRSParser.UpdateIfAvailableContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restMetadataOptions

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

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




    def restMetadataOptions(self):

        localctx = MRSParser.RestMetadataOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_restMetadataOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 502 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 502
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85, 87]:
                    self.state = 499
                    self.enabledDisabled()
                    pass
                elif token in [26, 70]:
                    self.state = 500
                    self.jsonOptions()
                    pass
                elif token in [35]:
                    self.state = 501
                    self.updateIfAvailable()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 504 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 26)) & ~0x3f) == 0 and ((1 << (_la - 26)) & 2882321353703162369) != 0)):
                    break

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


    class UpdateIfAvailableContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UPDATE_SYMBOL(self):
            return self.getToken(MRSParser.UPDATE_SYMBOL, 0)

        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def AVAILABLE_SYMBOL(self):
            return self.getToken(MRSParser.AVAILABLE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_updateIfAvailable

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

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




    def updateIfAvailable(self):

        localctx = MRSParser.UpdateIfAvailableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_updateIfAvailable)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 506
            self.match(MRSParser.UPDATE_SYMBOL)
            self.state = 509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==27:
                self.state = 507
                self.match(MRSParser.IF_SYMBOL)
                self.state = 508
                self.match(MRSParser.AVAILABLE_SYMBOL)


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


    class CreateRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def restServiceOptions(self):
            return self.getTypedRuleContext(MRSParser.RestServiceOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestServiceStatement

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

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




    def createRestServiceStatement(self):

        localctx = MRSParser.CreateRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_createRestServiceStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 524
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.state = 511
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 512
                self.match(MRSParser.OR_SYMBOL)
                self.state = 513
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 514
                self.match(MRSParser.REST_SYMBOL)
                self.state = 515
                self.match(MRSParser.SERVICE_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 516
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 517
                self.match(MRSParser.REST_SYMBOL)
                self.state = 518
                self.match(MRSParser.SERVICE_SYMBOL)
                self.state = 522
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
                if la_ == 1:
                    self.state = 519
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 520
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 521
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 526
            self.serviceRequestPath()
            self.state = 528
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21 or _la==26 or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 7209999) != 0):
                self.state = 527
                self.restServiceOptions()


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


    class RestServiceOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabled(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledContext,i)


        def publishedUnpublished(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.PublishedUnpublishedContext)
            else:
                return self.getTypedRuleContext(MRSParser.PublishedUnpublishedContext,i)


        def restProtocol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestProtocolContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestProtocolContext,i)


        def restAuthentication(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestAuthenticationContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestAuthenticationContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def comments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.CommentsContext)
            else:
                return self.getTypedRuleContext(MRSParser.CommentsContext,i)


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


        def addAuthApp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AddAuthAppContext)
            else:
                return self.getTypedRuleContext(MRSParser.AddAuthAppContext,i)


        def removeAuthApp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RemoveAuthAppContext)
            else:
                return self.getTypedRuleContext(MRSParser.RemoveAuthAppContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restServiceOptions

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

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




    def restServiceOptions(self):

        localctx = MRSParser.RestServiceOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_restServiceOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 539
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85, 87]:
                    self.state = 530
                    self.enabledDisabled()
                    pass
                elif token in [86, 89]:
                    self.state = 531
                    self.publishedUnpublished()
                    pass
                elif token in [90]:
                    self.state = 532
                    self.restProtocol()
                    pass
                elif token in [21]:
                    self.state = 533
                    self.restAuthentication()
                    pass
                elif token in [26, 70]:
                    self.state = 534
                    self.jsonOptions()
                    pass
                elif token in [71]:
                    self.state = 535
                    self.comments()
                    pass
                elif token in [78]:
                    self.state = 536
                    self.metadata()
                    pass
                elif token in [68]:
                    self.state = 537
                    self.addAuthApp()
                    pass
                elif token in [69]:
                    self.state = 538
                    self.removeAuthApp()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 541 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==21 or _la==26 or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 7209999) != 0)):
                    break

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


    class PublishedUnpublishedContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PUBLISHED_SYMBOL(self):
            return self.getToken(MRSParser.PUBLISHED_SYMBOL, 0)

        def UNPUBLISHED_SYMBOL(self):
            return self.getToken(MRSParser.UNPUBLISHED_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_publishedUnpublished

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

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




    def publishedUnpublished(self):

        localctx = MRSParser.PublishedUnpublishedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_publishedUnpublished)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            _la = self._input.LA(1)
            if not(_la==86 or _la==89):
                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 RestProtocolContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PROTOCOL_SYMBOL(self):
            return self.getToken(MRSParser.PROTOCOL_SYMBOL, 0)

        def HTTP_SYMBOL(self):
            return self.getToken(MRSParser.HTTP_SYMBOL, 0)

        def HTTPS_SYMBOL(self):
            return self.getToken(MRSParser.HTTPS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_restProtocol

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

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




    def restProtocol(self):

        localctx = MRSParser.RestProtocolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_restProtocol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 545
            self.match(MRSParser.PROTOCOL_SYMBOL)
            self.state = 546
            _la = self._input.LA(1)
            if not(_la==91 or _la==92):
                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 RestAuthenticationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def authPath(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthPathContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthPathContext,i)


        def authRedirection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthRedirectionContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthRedirectionContext,i)


        def authValidation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthValidationContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthValidationContext,i)


        def authPageContent(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthPageContentContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthPageContentContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restAuthentication

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

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




    def restAuthentication(self):

        localctx = MRSParser.RestAuthenticationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_restAuthentication)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 548
            self.match(MRSParser.AUTHENTICATION_SYMBOL)
            self.state = 555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 1086324736) != 0) or _la==94:
                self.state = 553
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [22]:
                    self.state = 549
                    self.authPath()
                    pass
                elif token in [94]:
                    self.state = 550
                    self.authRedirection()
                    pass
                elif token in [23]:
                    self.state = 551
                    self.authValidation()
                    pass
                elif token in [30]:
                    self.state = 552
                    self.authPageContent()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 557
                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 AuthPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def quotedTextOrDefault(self):
            return self.getTypedRuleContext(MRSParser.QuotedTextOrDefaultContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_authPath

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

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




    def authPath(self):

        localctx = MRSParser.AuthPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_authPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self.match(MRSParser.PATH_SYMBOL)
            self.state = 559
            self.quotedTextOrDefault()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AuthRedirectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REDIRECTION_SYMBOL(self):
            return self.getToken(MRSParser.REDIRECTION_SYMBOL, 0)

        def quotedTextOrDefault(self):
            return self.getTypedRuleContext(MRSParser.QuotedTextOrDefaultContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_authRedirection

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

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




    def authRedirection(self):

        localctx = MRSParser.AuthRedirectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_authRedirection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 561
            self.match(MRSParser.REDIRECTION_SYMBOL)
            self.state = 562
            self.quotedTextOrDefault()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AuthValidationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VALIDATION_SYMBOL(self):
            return self.getToken(MRSParser.VALIDATION_SYMBOL, 0)

        def quotedTextOrDefault(self):
            return self.getTypedRuleContext(MRSParser.QuotedTextOrDefaultContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_authValidation

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

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




    def authValidation(self):

        localctx = MRSParser.AuthValidationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_authValidation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 564
            self.match(MRSParser.VALIDATION_SYMBOL)
            self.state = 565
            self.quotedTextOrDefault()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AuthPageContentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PAGE_SYMBOL(self):
            return self.getToken(MRSParser.PAGE_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def quotedTextOrDefault(self):
            return self.getTypedRuleContext(MRSParser.QuotedTextOrDefaultContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_authPageContent

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

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




    def authPageContent(self):

        localctx = MRSParser.AuthPageContentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_authPageContent)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 567
            self.match(MRSParser.PAGE_SYMBOL)
            self.state = 568
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 569
            self.quotedTextOrDefault()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UserManagementSchemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def USER_SYMBOL(self):
            return self.getToken(MRSParser.USER_SYMBOL, 0)

        def MANAGEMENT_SYMBOL(self):
            return self.getToken(MRSParser.MANAGEMENT_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaName(self):
            return self.getTypedRuleContext(MRSParser.SchemaNameContext,0)


        def DEFAULT_SYMBOL(self):
            return self.getToken(MRSParser.DEFAULT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_userManagementSchema

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

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




    def userManagementSchema(self):

        localctx = MRSParser.UserManagementSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_userManagementSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 571
            self.match(MRSParser.USER_SYMBOL)
            self.state = 572
            self.match(MRSParser.MANAGEMENT_SYMBOL)
            self.state = 573
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 576
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.state = 574
                self.schemaName()
                pass

            elif la_ == 2:
                self.state = 575
                self.match(MRSParser.DEFAULT_SYMBOL)
                pass


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


    class AddAuthAppContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ADD_SYMBOL(self):
            return self.getToken(MRSParser.ADD_SYMBOL, 0)

        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_addAuthApp

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

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




    def addAuthApp(self):

        localctx = MRSParser.AddAuthAppContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_addAuthApp)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 578
            self.match(MRSParser.ADD_SYMBOL)
            self.state = 579
            self.match(MRSParser.AUTH_SYMBOL)
            self.state = 580
            self.match(MRSParser.APP_SYMBOL)
            self.state = 581
            self.authAppName()
            self.state = 584
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==27:
                self.state = 582
                self.match(MRSParser.IF_SYMBOL)
                self.state = 583
                self.match(MRSParser.EXISTS_SYMBOL)


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


    class RemoveAuthAppContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REMOVE_SYMBOL(self):
            return self.getToken(MRSParser.REMOVE_SYMBOL, 0)

        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_removeAuthApp

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

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




    def removeAuthApp(self):

        localctx = MRSParser.RemoveAuthAppContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_removeAuthApp)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 586
            self.match(MRSParser.REMOVE_SYMBOL)
            self.state = 587
            self.match(MRSParser.AUTH_SYMBOL)
            self.state = 588
            self.match(MRSParser.APP_SYMBOL)
            self.state = 589
            self.authAppName()
            self.state = 592
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==27:
                self.state = 590
                self.match(MRSParser.IF_SYMBOL)
                self.state = 591
                self.match(MRSParser.EXISTS_SYMBOL)


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


    class CreateRestSchemaStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def schemaName(self):
            return self.getTypedRuleContext(MRSParser.SchemaNameContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaRequestPath(self):
            return self.getTypedRuleContext(MRSParser.SchemaRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def restSchemaOptions(self):
            return self.getTypedRuleContext(MRSParser.RestSchemaOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestSchemaStatement

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

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




    def createRestSchemaStatement(self):

        localctx = MRSParser.CreateRestSchemaStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_createRestSchemaStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 594
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 595
                self.match(MRSParser.OR_SYMBOL)
                self.state = 596
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 597
                self.match(MRSParser.REST_SYMBOL)
                self.state = 598
                self.match(MRSParser.DATABASE_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 599
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 600
                self.match(MRSParser.REST_SYMBOL)
                self.state = 601
                self.match(MRSParser.DATABASE_SYMBOL)
                self.state = 605
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
                if la_ == 1:
                    self.state = 602
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 603
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 604
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 610
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.state = 609
                self.schemaRequestPath()


            self.state = 617
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 612
                self.match(MRSParser.ON_SYMBOL)
                self.state = 614
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
                if la_ == 1:
                    self.state = 613
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 616
                self.serviceRequestPath()


            self.state = 619
            self.match(MRSParser.FROM_SYMBOL)
            self.state = 620
            self.schemaName()
            self.state = 622
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21 or _la==26 or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 268861699) != 0):
                self.state = 621
                self.restSchemaOptions()


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


    class RestSchemaOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabledPrivate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledPrivateContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledPrivateContext,i)


        def authenticationRequired(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthenticationRequiredContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthenticationRequiredContext,i)


        def itemsPerPage(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.ItemsPerPageContext)
            else:
                return self.getTypedRuleContext(MRSParser.ItemsPerPageContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def comments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.CommentsContext)
            else:
                return self.getTypedRuleContext(MRSParser.CommentsContext,i)


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


        def getRuleIndex(self):
            return MRSParser.RULE_restSchemaOptions

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

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




    def restSchemaOptions(self):

        localctx = MRSParser.RestSchemaOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_restSchemaOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 630 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 630
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85, 87, 88]:
                    self.state = 624
                    self.enabledDisabledPrivate()
                    pass
                elif token in [21]:
                    self.state = 625
                    self.authenticationRequired()
                    pass
                elif token in [98]:
                    self.state = 626
                    self.itemsPerPage()
                    pass
                elif token in [26, 70]:
                    self.state = 627
                    self.jsonOptions()
                    pass
                elif token in [71]:
                    self.state = 628
                    self.comments()
                    pass
                elif token in [78]:
                    self.state = 629
                    self.metadata()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 632 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==21 or _la==26 or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 268861699) != 0)):
                    break

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


    class CreateRestViewStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def viewRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ViewRequestPathContext,0)


        def AS_SYMBOL(self):
            return self.getToken(MRSParser.AS_SYMBOL, 0)

        def qualifiedIdentifier(self):
            return self.getTypedRuleContext(MRSParser.QualifiedIdentifierContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def VIEW_SYMBOL(self):
            return self.getToken(MRSParser.VIEW_SYMBOL, 0)

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def CLASS_SYMBOL(self):
            return self.getToken(MRSParser.CLASS_SYMBOL, 0)

        def restObjectName(self):
            return self.getTypedRuleContext(MRSParser.RestObjectNameContext,0)


        def graphQlCrudOptions(self):
            return self.getTypedRuleContext(MRSParser.GraphQlCrudOptionsContext,0)


        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restObjectOptions(self):
            return self.getTypedRuleContext(MRSParser.RestObjectOptionsContext,0)


        def DATA_SYMBOL(self):
            return self.getToken(MRSParser.DATA_SYMBOL, 0)

        def MAPPING_SYMBOL(self):
            return self.getToken(MRSParser.MAPPING_SYMBOL, 0)

        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestViewStatement

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

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




    def createRestViewStatement(self):

        localctx = MRSParser.CreateRestViewStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_createRestViewStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 659
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 634
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 635
                self.match(MRSParser.OR_SYMBOL)
                self.state = 636
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 637
                self.match(MRSParser.REST_SYMBOL)
                self.state = 639
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==48:
                    self.state = 638
                    self.match(MRSParser.DATA_SYMBOL)


                self.state = 642
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==120:
                    self.state = 641
                    self.match(MRSParser.MAPPING_SYMBOL)


                self.state = 644
                self.match(MRSParser.VIEW_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 645
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 646
                self.match(MRSParser.REST_SYMBOL)
                self.state = 648
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==48:
                    self.state = 647
                    self.match(MRSParser.DATA_SYMBOL)


                self.state = 651
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==120:
                    self.state = 650
                    self.match(MRSParser.MAPPING_SYMBOL)


                self.state = 653
                self.match(MRSParser.VIEW_SYMBOL)
                self.state = 657
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
                if la_ == 1:
                    self.state = 654
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 655
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 656
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 661
            self.viewRequestPath()
            self.state = 664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 662
                self.match(MRSParser.ON_SYMBOL)
                self.state = 663
                self.serviceSchemaSelector()


            self.state = 666
            self.match(MRSParser.AS_SYMBOL)
            self.state = 667
            self.qualifiedIdentifier()
            self.state = 670
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==117:
                self.state = 668
                self.match(MRSParser.CLASS_SYMBOL)
                self.state = 669
                self.restObjectName()


            self.state = 673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & 31751) != 0):
                self.state = 672
                self.graphQlCrudOptions()


            self.state = 676
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==186:
                self.state = 675
                self.graphQlObj()


            self.state = 679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0):
                self.state = 678
                self.restObjectOptions()


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


    class RestObjectOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabledPrivate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledPrivateContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledPrivateContext,i)


        def authenticationRequired(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthenticationRequiredContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthenticationRequiredContext,i)


        def itemsPerPage(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.ItemsPerPageContext)
            else:
                return self.getTypedRuleContext(MRSParser.ItemsPerPageContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def comments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.CommentsContext)
            else:
                return self.getTypedRuleContext(MRSParser.CommentsContext,i)


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


        def restViewMediaType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestViewMediaTypeContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestViewMediaTypeContext,i)


        def restViewFormat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestViewFormatContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestViewFormatContext,i)


        def restViewAuthenticationProcedure(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestViewAuthenticationProcedureContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestViewAuthenticationProcedureContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restObjectOptions

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

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




    def restObjectOptions(self):

        localctx = MRSParser.RestObjectOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_restObjectOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 690 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 690
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
                if la_ == 1:
                    self.state = 681
                    self.enabledDisabledPrivate()
                    pass

                elif la_ == 2:
                    self.state = 682
                    self.authenticationRequired()
                    pass

                elif la_ == 3:
                    self.state = 683
                    self.itemsPerPage()
                    pass

                elif la_ == 4:
                    self.state = 684
                    self.jsonOptions()
                    pass

                elif la_ == 5:
                    self.state = 685
                    self.comments()
                    pass

                elif la_ == 6:
                    self.state = 686
                    self.metadata()
                    pass

                elif la_ == 7:
                    self.state = 687
                    self.restViewMediaType()
                    pass

                elif la_ == 8:
                    self.state = 688
                    self.restViewFormat()
                    pass

                elif la_ == 9:
                    self.state = 689
                    self.restViewAuthenticationProcedure()
                    pass


                self.state = 692 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0)):
                    break

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


    class RestViewMediaTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MEDIA_SYMBOL(self):
            return self.getToken(MRSParser.MEDIA_SYMBOL, 0)

        def TYPE_SYMBOL(self):
            return self.getToken(MRSParser.TYPE_SYMBOL, 0)

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def AUTODETECT_SYMBOL(self):
            return self.getToken(MRSParser.AUTODETECT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_restViewMediaType

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

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




    def restViewMediaType(self):

        localctx = MRSParser.RestViewMediaTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_restViewMediaType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 694
            self.match(MRSParser.MEDIA_SYMBOL)
            self.state = 695
            self.match(MRSParser.TYPE_SYMBOL)
            self.state = 698
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 696
                self.textStringLiteral()
                pass

            elif la_ == 2:
                self.state = 697
                self.match(MRSParser.AUTODETECT_SYMBOL)
                pass


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


    class RestViewFormatContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FORMAT_SYMBOL(self):
            return self.getToken(MRSParser.FORMAT_SYMBOL, 0)

        def FEED_SYMBOL(self):
            return self.getToken(MRSParser.FEED_SYMBOL, 0)

        def ITEM_SYMBOL(self):
            return self.getToken(MRSParser.ITEM_SYMBOL, 0)

        def MEDIA_SYMBOL(self):
            return self.getToken(MRSParser.MEDIA_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_restViewFormat

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

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




    def restViewFormat(self):

        localctx = MRSParser.RestViewFormatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_restViewFormat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 700
            self.match(MRSParser.FORMAT_SYMBOL)
            self.state = 701
            _la = self._input.LA(1)
            if not(((((_la - 101)) & ~0x3f) == 0 and ((1 << (_la - 101)) & 13) != 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 RestViewAuthenticationProcedureContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def PROCEDURE_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURE_SYMBOL, 0)

        def qualifiedIdentifier(self):
            return self.getTypedRuleContext(MRSParser.QualifiedIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restViewAuthenticationProcedure

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

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




    def restViewAuthenticationProcedure(self):

        localctx = MRSParser.RestViewAuthenticationProcedureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_restViewAuthenticationProcedure)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 703
            self.match(MRSParser.AUTHENTICATION_SYMBOL)
            self.state = 704
            self.match(MRSParser.PROCEDURE_SYMBOL)
            self.state = 705
            self.qualifiedIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateRestProcedureStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def procedureRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ProcedureRequestPathContext,0)


        def AS_SYMBOL(self):
            return self.getToken(MRSParser.AS_SYMBOL, 0)

        def qualifiedIdentifier(self):
            return self.getTypedRuleContext(MRSParser.QualifiedIdentifierContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROCEDURE_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURE_SYMBOL, 0)

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def FORCE_SYMBOL(self):
            return self.getToken(MRSParser.FORCE_SYMBOL, 0)

        def PARAMETERS_SYMBOL(self):
            return self.getToken(MRSParser.PARAMETERS_SYMBOL, 0)

        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restProcedureResult(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestProcedureResultContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestProcedureResultContext,i)


        def restObjectOptions(self):
            return self.getTypedRuleContext(MRSParser.RestObjectOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def restObjectName(self):
            return self.getTypedRuleContext(MRSParser.RestObjectNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_createRestProcedureStatement

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

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




    def createRestProcedureStatement(self):

        localctx = MRSParser.CreateRestProcedureStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_createRestProcedureStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.state = 707
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 708
                self.match(MRSParser.OR_SYMBOL)
                self.state = 709
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 710
                self.match(MRSParser.REST_SYMBOL)
                self.state = 711
                self.match(MRSParser.PROCEDURE_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 712
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 713
                self.match(MRSParser.REST_SYMBOL)
                self.state = 714
                self.match(MRSParser.PROCEDURE_SYMBOL)
                self.state = 718
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
                if la_ == 1:
                    self.state = 715
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 716
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 717
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 722
            self.procedureRequestPath()
            self.state = 725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 723
                self.match(MRSParser.ON_SYMBOL)
                self.state = 724
                self.serviceSchemaSelector()


            self.state = 727
            self.match(MRSParser.AS_SYMBOL)
            self.state = 728
            self.qualifiedIdentifier()
            self.state = 730
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==34:
                self.state = 729
                self.match(MRSParser.FORCE_SYMBOL)


            self.state = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==67:
                self.state = 732
                self.match(MRSParser.PARAMETERS_SYMBOL)
                self.state = 734
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
                if la_ == 1:
                    self.state = 733
                    self.restObjectName()


                self.state = 736
                self.graphQlObj()


            self.state = 742
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==84:
                self.state = 739
                self.restProcedureResult()
                self.state = 744
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 746
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0):
                self.state = 745
                self.restObjectOptions()


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


    class RestProcedureResultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RESULT_SYMBOL(self):
            return self.getToken(MRSParser.RESULT_SYMBOL, 0)

        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restResultName(self):
            return self.getTypedRuleContext(MRSParser.RestResultNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProcedureResult

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

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




    def restProcedureResult(self):

        localctx = MRSParser.RestProcedureResultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_restProcedureResult)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 748
            self.match(MRSParser.RESULT_SYMBOL)
            self.state = 750
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
            if la_ == 1:
                self.state = 749
                self.restResultName()


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


    class CreateRestFunctionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionRequestPath(self):
            return self.getTypedRuleContext(MRSParser.FunctionRequestPathContext,0)


        def AS_SYMBOL(self):
            return self.getToken(MRSParser.AS_SYMBOL, 0)

        def qualifiedIdentifier(self):
            return self.getTypedRuleContext(MRSParser.QualifiedIdentifierContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def FUNCTION_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTION_SYMBOL, 0)

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def FORCE_SYMBOL(self):
            return self.getToken(MRSParser.FORCE_SYMBOL, 0)

        def PARAMETERS_SYMBOL(self):
            return self.getToken(MRSParser.PARAMETERS_SYMBOL, 0)

        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restFunctionResult(self):
            return self.getTypedRuleContext(MRSParser.RestFunctionResultContext,0)


        def restObjectOptions(self):
            return self.getTypedRuleContext(MRSParser.RestObjectOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def restObjectName(self):
            return self.getTypedRuleContext(MRSParser.RestObjectNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_createRestFunctionStatement

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

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




    def createRestFunctionStatement(self):

        localctx = MRSParser.CreateRestFunctionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_createRestFunctionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 767
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
            if la_ == 1:
                self.state = 754
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 755
                self.match(MRSParser.OR_SYMBOL)
                self.state = 756
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 757
                self.match(MRSParser.REST_SYMBOL)
                self.state = 758
                self.match(MRSParser.FUNCTION_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 759
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 760
                self.match(MRSParser.REST_SYMBOL)
                self.state = 761
                self.match(MRSParser.FUNCTION_SYMBOL)
                self.state = 765
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
                if la_ == 1:
                    self.state = 762
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 763
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 764
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 769
            self.functionRequestPath()
            self.state = 772
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 770
                self.match(MRSParser.ON_SYMBOL)
                self.state = 771
                self.serviceSchemaSelector()


            self.state = 774
            self.match(MRSParser.AS_SYMBOL)
            self.state = 775
            self.qualifiedIdentifier()
            self.state = 777
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==34:
                self.state = 776
                self.match(MRSParser.FORCE_SYMBOL)


            self.state = 784
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==67:
                self.state = 779
                self.match(MRSParser.PARAMETERS_SYMBOL)
                self.state = 781
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                if la_ == 1:
                    self.state = 780
                    self.restObjectName()


                self.state = 783
                self.graphQlObj()


            self.state = 787
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==84:
                self.state = 786
                self.restFunctionResult()


            self.state = 790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0):
                self.state = 789
                self.restObjectOptions()


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


    class RestFunctionResultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RESULT_SYMBOL(self):
            return self.getToken(MRSParser.RESULT_SYMBOL, 0)

        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restResultName(self):
            return self.getTypedRuleContext(MRSParser.RestResultNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restFunctionResult

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

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




    def restFunctionResult(self):

        localctx = MRSParser.RestFunctionResultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_restFunctionResult)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 792
            self.match(MRSParser.RESULT_SYMBOL)
            self.state = 794
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.state = 793
                self.restResultName()


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


    class CreateRestContentSetStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def directoryFilePath(self):
            return self.getTypedRuleContext(MRSParser.DirectoryFilePathContext,0)


        def restContentSetOptions(self):
            return self.getTypedRuleContext(MRSParser.RestContentSetOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestContentSetStatement

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

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




    def createRestContentSetStatement(self):

        localctx = MRSParser.CreateRestContentSetStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_createRestContentSetStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 813
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
            if la_ == 1:
                self.state = 798
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 799
                self.match(MRSParser.OR_SYMBOL)
                self.state = 800
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 801
                self.match(MRSParser.REST_SYMBOL)
                self.state = 802
                self.match(MRSParser.CONTENT_SYMBOL)
                self.state = 803
                self.match(MRSParser.SET_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 804
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 805
                self.match(MRSParser.REST_SYMBOL)
                self.state = 806
                self.match(MRSParser.CONTENT_SYMBOL)
                self.state = 807
                self.match(MRSParser.SET_SYMBOL)
                self.state = 811
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
                if la_ == 1:
                    self.state = 808
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 809
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 810
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 815
            self.contentSetRequestPath()
            self.state = 821
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 816
                self.match(MRSParser.ON_SYMBOL)
                self.state = 818
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 817
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 820
                self.serviceRequestPath()


            self.state = 825
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 823
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 824
                self.directoryFilePath()


            self.state = 828
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 580542208671744) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 425987) != 0):
                self.state = 827
                self.restContentSetOptions()


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


    class DirectoryFilePathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_directoryFilePath

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

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




    def directoryFilePath(self):

        localctx = MRSParser.DirectoryFilePathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_directoryFilePath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 830
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestContentSetOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabledPrivate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledPrivateContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledPrivateContext,i)


        def authenticationRequired(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthenticationRequiredContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthenticationRequiredContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def comments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.CommentsContext)
            else:
                return self.getTypedRuleContext(MRSParser.CommentsContext,i)


        def fileIgnoreList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.FileIgnoreListContext)
            else:
                return self.getTypedRuleContext(MRSParser.FileIgnoreListContext,i)


        def loadScripts(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.LoadScriptsContext)
            else:
                return self.getTypedRuleContext(MRSParser.LoadScriptsContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restContentSetOptions

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

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




    def restContentSetOptions(self):

        localctx = MRSParser.RestContentSetOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_restContentSetOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 838 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 838
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85, 87, 88]:
                    self.state = 832
                    self.enabledDisabledPrivate()
                    pass
                elif token in [21]:
                    self.state = 833
                    self.authenticationRequired()
                    pass
                elif token in [26, 70]:
                    self.state = 834
                    self.jsonOptions()
                    pass
                elif token in [71]:
                    self.state = 835
                    self.comments()
                    pass
                elif token in [44]:
                    self.state = 836
                    self.fileIgnoreList()
                    pass
                elif token in [49]:
                    self.state = 837
                    self.loadScripts()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 840 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 580542208671744) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 425987) != 0)):
                    break

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


    class FileIgnoreListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IGNORE_SYMBOL(self):
            return self.getToken(MRSParser.IGNORE_SYMBOL, 0)

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_fileIgnoreList

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

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




    def fileIgnoreList(self):

        localctx = MRSParser.FileIgnoreListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_fileIgnoreList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 842
            self.match(MRSParser.IGNORE_SYMBOL)
            self.state = 843
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LoadScriptsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOAD_SYMBOL(self):
            return self.getToken(MRSParser.LOAD_SYMBOL, 0)

        def SCRIPTS_SYMBOL(self):
            return self.getToken(MRSParser.SCRIPTS_SYMBOL, 0)

        def TYPESCRIPT_SYMBOL(self):
            return self.getToken(MRSParser.TYPESCRIPT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_loadScripts

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

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




    def loadScripts(self):

        localctx = MRSParser.LoadScriptsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_loadScripts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 845
            self.match(MRSParser.LOAD_SYMBOL)
            self.state = 847
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==121:
                self.state = 846
                self.match(MRSParser.TYPESCRIPT_SYMBOL)


            self.state = 849
            self.match(MRSParser.SCRIPTS_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateRestContentFileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def contentFileRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentFileRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

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

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def FILE_SYMBOL(self):
            return self.getToken(MRSParser.FILE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def restContentFileOptions(self):
            return self.getTypedRuleContext(MRSParser.RestContentFileOptionsContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def directoryFilePath(self):
            return self.getTypedRuleContext(MRSParser.DirectoryFilePathContext,0)


        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def BINARY_SYMBOL(self):
            return self.getToken(MRSParser.BINARY_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestContentFileStatement

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

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




    def createRestContentFileStatement(self):

        localctx = MRSParser.CreateRestContentFileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_createRestContentFileStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 866
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 851
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 852
                self.match(MRSParser.OR_SYMBOL)
                self.state = 853
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 854
                self.match(MRSParser.REST_SYMBOL)
                self.state = 855
                self.match(MRSParser.CONTENT_SYMBOL)
                self.state = 856
                self.match(MRSParser.FILE_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 857
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 858
                self.match(MRSParser.REST_SYMBOL)
                self.state = 859
                self.match(MRSParser.CONTENT_SYMBOL)
                self.state = 860
                self.match(MRSParser.FILE_SYMBOL)
                self.state = 864
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
                if la_ == 1:
                    self.state = 861
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 862
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 863
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 868
            self.contentFileRequestPath()
            self.state = 869
            self.match(MRSParser.ON_SYMBOL)
            self.state = 874
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.state = 871
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
                if la_ == 1:
                    self.state = 870
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 873
                self.serviceRequestPath()


            self.state = 876
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 877
            self.match(MRSParser.SET_SYMBOL)
            self.state = 878
            self.contentSetRequestPath()
            self.state = 886
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.state = 879
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 880
                self.directoryFilePath()
                pass
            elif token in [47, 100]:
                self.state = 882
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==47:
                    self.state = 881
                    self.match(MRSParser.BINARY_SYMBOL)


                self.state = 884
                self.match(MRSParser.CONTENT_SYMBOL)
                self.state = 885
                self.textStringLiteral()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 889
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21 or _la==26 or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 425985) != 0):
                self.state = 888
                self.restContentFileOptions()


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


    class RestContentFileOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabledPrivate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledPrivateContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledPrivateContext,i)


        def authenticationRequired(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AuthenticationRequiredContext)
            else:
                return self.getTypedRuleContext(MRSParser.AuthenticationRequiredContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restContentFileOptions

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

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




    def restContentFileOptions(self):

        localctx = MRSParser.RestContentFileOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_restContentFileOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 894 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 894
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [85, 87, 88]:
                    self.state = 891
                    self.enabledDisabledPrivate()
                    pass
                elif token in [21]:
                    self.state = 892
                    self.authenticationRequired()
                    pass
                elif token in [26, 70]:
                    self.state = 893
                    self.jsonOptions()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 896 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==21 or _la==26 or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 425985) != 0)):
                    break

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


    class CreateRestAuthAppStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def VENDOR_SYMBOL(self):
            return self.getToken(MRSParser.VENDOR_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def MRS_SYMBOL(self):
            return self.getToken(MRSParser.MRS_SYMBOL, 0)

        def MYSQL_SYMBOL(self):
            return self.getToken(MRSParser.MYSQL_SYMBOL, 0)

        def vendorName(self):
            return self.getTypedRuleContext(MRSParser.VendorNameContext,0)


        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def restAuthAppOptions(self):
            return self.getTypedRuleContext(MRSParser.RestAuthAppOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestAuthAppStatement

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

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




    def createRestAuthAppStatement(self):

        localctx = MRSParser.CreateRestAuthAppStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_createRestAuthAppStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 913
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.state = 898
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 899
                self.match(MRSParser.OR_SYMBOL)
                self.state = 900
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 901
                self.match(MRSParser.REST_SYMBOL)
                self.state = 902
                _la = self._input.LA(1)
                if not(_la==21 or _la==106):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 903
                self.match(MRSParser.APP_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 904
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 905
                self.match(MRSParser.REST_SYMBOL)
                self.state = 906
                _la = self._input.LA(1)
                if not(_la==21 or _la==106):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 907
                self.match(MRSParser.APP_SYMBOL)
                self.state = 911
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
                if la_ == 1:
                    self.state = 908
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 909
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 910
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 915
            self.authAppName()
            self.state = 916
            self.match(MRSParser.VENDOR_SYMBOL)
            self.state = 920
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.state = 917
                self.match(MRSParser.MRS_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 918
                self.match(MRSParser.MYSQL_SYMBOL)
                pass

            elif la_ == 3:
                self.state = 919
                self.vendorName()
                pass


            self.state = 923
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4611686018410610688) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1134696005107777) != 0):
                self.state = 922
                self.restAuthAppOptions()


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


    class AuthAppNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_authAppName

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

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




    def authAppName(self):

        localctx = MRSParser.AuthAppNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_authAppName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 925
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VendorNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_vendorName

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

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




    def vendorName(self):

        localctx = MRSParser.VendorNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_vendorName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 927
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestAuthAppOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def enabledDisabled(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.EnabledDisabledContext)
            else:
                return self.getTypedRuleContext(MRSParser.EnabledDisabledContext,i)


        def comments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.CommentsContext)
            else:
                return self.getTypedRuleContext(MRSParser.CommentsContext,i)


        def allowNewUsersToRegister(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AllowNewUsersToRegisterContext)
            else:
                return self.getTypedRuleContext(MRSParser.AllowNewUsersToRegisterContext,i)


        def defaultRole(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.DefaultRoleContext)
            else:
                return self.getTypedRuleContext(MRSParser.DefaultRoleContext,i)


        def appId(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AppIdContext)
            else:
                return self.getTypedRuleContext(MRSParser.AppIdContext,i)


        def appSecret(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AppSecretContext)
            else:
                return self.getTypedRuleContext(MRSParser.AppSecretContext,i)


        def url(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.UrlContext)
            else:
                return self.getTypedRuleContext(MRSParser.UrlContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restAuthAppOptions

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

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




    def restAuthAppOptions(self):

        localctx = MRSParser.RestAuthAppOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_restAuthAppOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 936 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 936
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
                if la_ == 1:
                    self.state = 929
                    self.enabledDisabled()
                    pass

                elif la_ == 2:
                    self.state = 930
                    self.comments()
                    pass

                elif la_ == 3:
                    self.state = 931
                    self.allowNewUsersToRegister()
                    pass

                elif la_ == 4:
                    self.state = 932
                    self.defaultRole()
                    pass

                elif la_ == 5:
                    self.state = 933
                    self.appId()
                    pass

                elif la_ == 6:
                    self.state = 934
                    self.appSecret()
                    pass

                elif la_ == 7:
                    self.state = 935
                    self.url()
                    pass


                self.state = 938 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & -4611686018410610688) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1134696005107777) != 0)):
                    break

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


    class AllowNewUsersToRegisterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALLOW_SYMBOL(self):
            return self.getToken(MRSParser.ALLOW_SYMBOL, 0)

        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def USERS_SYMBOL(self):
            return self.getToken(MRSParser.USERS_SYMBOL, 0)

        def DO_SYMBOL(self):
            return self.getToken(MRSParser.DO_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def TO_SYMBOL(self):
            return self.getToken(MRSParser.TO_SYMBOL, 0)

        def REGISTER_SYMBOL(self):
            return self.getToken(MRSParser.REGISTER_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_allowNewUsersToRegister

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

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




    def allowNewUsersToRegister(self):

        localctx = MRSParser.AllowNewUsersToRegisterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_allowNewUsersToRegister)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 942
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==65:
                self.state = 940
                self.match(MRSParser.DO_SYMBOL)
                self.state = 941
                self.match(MRSParser.NOT_SYMBOL)


            self.state = 944
            self.match(MRSParser.ALLOW_SYMBOL)
            self.state = 945
            self.match(MRSParser.NEW_SYMBOL)
            self.state = 946
            self.match(MRSParser.USERS_SYMBOL)
            self.state = 949
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==43:
                self.state = 947
                self.match(MRSParser.TO_SYMBOL)
                self.state = 948
                self.match(MRSParser.REGISTER_SYMBOL)


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


    class DefaultRoleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DEFAULT_SYMBOL(self):
            return self.getToken(MRSParser.DEFAULT_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_defaultRole

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

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




    def defaultRole(self):

        localctx = MRSParser.DefaultRoleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_defaultRole)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 951
            self.match(MRSParser.DEFAULT_SYMBOL)
            self.state = 952
            self.match(MRSParser.ROLE_SYMBOL)
            self.state = 953
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AppIdContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ID_SYMBOL(self):
            return self.getToken(MRSParser.ID_SYMBOL, 0)

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def CLIENT_SYMBOL(self):
            return self.getToken(MRSParser.CLIENT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_appId

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

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




    def appId(self):

        localctx = MRSParser.AppIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_appId)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 955
            _la = self._input.LA(1)
            if not(_la==62 or _la==108):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 956
            self.match(MRSParser.ID_SYMBOL)
            self.state = 957
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AppSecretContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SECRET_SYMBOL(self):
            return self.getToken(MRSParser.SECRET_SYMBOL, 0)

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def CLIENT_SYMBOL(self):
            return self.getToken(MRSParser.CLIENT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_appSecret

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

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




    def appSecret(self):

        localctx = MRSParser.AppSecretContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_appSecret)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 959
            _la = self._input.LA(1)
            if not(_la==62 or _la==108):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 960
            self.match(MRSParser.SECRET_SYMBOL)
            self.state = 961
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UrlContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def URL_SYMBOL(self):
            return self.getToken(MRSParser.URL_SYMBOL, 0)

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_url

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

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




    def url(self):

        localctx = MRSParser.UrlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_url)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 963
            self.match(MRSParser.URL_SYMBOL)
            self.state = 964
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CreateRestUserStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def USER_SYMBOL(self):
            return self.getToken(MRSParser.USER_SYMBOL, 0)

        def IDENTIFIED_SYMBOL(self):
            return self.getToken(MRSParser.IDENTIFIED_SYMBOL, 0)

        def BY_SYMBOL(self):
            return self.getToken(MRSParser.BY_SYMBOL, 0)

        def userPassword(self):
            return self.getTypedRuleContext(MRSParser.UserPasswordContext,0)


        def userOptions(self):
            return self.getTypedRuleContext(MRSParser.UserOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestUserStatement

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

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




    def createRestUserStatement(self):

        localctx = MRSParser.CreateRestUserStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_createRestUserStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 979
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.state = 966
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 967
                self.match(MRSParser.OR_SYMBOL)
                self.state = 968
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 969
                self.match(MRSParser.REST_SYMBOL)
                self.state = 970
                self.match(MRSParser.USER_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 971
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 972
                self.match(MRSParser.REST_SYMBOL)
                self.state = 973
                self.match(MRSParser.USER_SYMBOL)
                self.state = 977
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                if la_ == 1:
                    self.state = 974
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 975
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 976
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 981
            self.userName()
            self.state = 982
            self.match(MRSParser.AT_SIGN_SYMBOL)
            self.state = 983
            self.authAppName()
            self.state = 987
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==40:
                self.state = 984
                self.match(MRSParser.IDENTIFIED_SYMBOL)
                self.state = 985
                self.match(MRSParser.BY_SYMBOL)
                self.state = 986
                self.userPassword()


            self.state = 990
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26 or _la==55 or _la==70 or _la==108:
                self.state = 989
                self.userOptions()


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


    class UserNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_userName

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

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




    def userName(self):

        localctx = MRSParser.UserNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_userName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 992
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UserPasswordContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_userPassword

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

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




    def userPassword(self):

        localctx = MRSParser.UserPasswordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_userPassword)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 994
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UserOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def accountLock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AccountLockContext)
            else:
                return self.getTypedRuleContext(MRSParser.AccountLockContext,i)


        def appOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.AppOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.AppOptionsContext,i)


        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_userOptions

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

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




    def userOptions(self):

        localctx = MRSParser.UserOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_userOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 999 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 999
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [55]:
                    self.state = 996
                    self.accountLock()
                    pass
                elif token in [108]:
                    self.state = 997
                    self.appOptions()
                    pass
                elif token in [26, 70]:
                    self.state = 998
                    self.jsonOptions()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1001 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==26 or _la==55 or _la==70 or _la==108):
                    break

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


    class AppOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def OPTIONS_SYMBOL(self):
            return self.getToken(MRSParser.OPTIONS_SYMBOL, 0)

        def jsonValue(self):
            return self.getTypedRuleContext(MRSParser.JsonValueContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_appOptions

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

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




    def appOptions(self):

        localctx = MRSParser.AppOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_appOptions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1003
            self.match(MRSParser.APP_SYMBOL)
            self.state = 1004
            self.match(MRSParser.OPTIONS_SYMBOL)
            self.state = 1005
            self.jsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AccountLockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ACCOUNT_SYMBOL(self):
            return self.getToken(MRSParser.ACCOUNT_SYMBOL, 0)

        def LOCK_SYMBOL(self):
            return self.getToken(MRSParser.LOCK_SYMBOL, 0)

        def UNLOCK_SYMBOL(self):
            return self.getToken(MRSParser.UNLOCK_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_accountLock

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

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




    def accountLock(self):

        localctx = MRSParser.AccountLockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_accountLock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1007
            self.match(MRSParser.ACCOUNT_SYMBOL)
            self.state = 1008
            _la = self._input.LA(1)
            if not(_la==56 or _la==57):
                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 CreateRestRoleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def EXTENDS_SYMBOL(self):
            return self.getToken(MRSParser.EXTENDS_SYMBOL, 0)

        def parentRoleName(self):
            return self.getTypedRuleContext(MRSParser.ParentRoleNameContext,0)


        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def restRoleOptions(self):
            return self.getTypedRuleContext(MRSParser.RestRoleOptionsContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_createRestRoleStatement

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

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




    def createRestRoleStatement(self):

        localctx = MRSParser.CreateRestRoleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_createRestRoleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1023
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
            if la_ == 1:
                self.state = 1010
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 1011
                self.match(MRSParser.OR_SYMBOL)
                self.state = 1012
                self.match(MRSParser.REPLACE_SYMBOL)
                self.state = 1013
                self.match(MRSParser.REST_SYMBOL)
                self.state = 1014
                self.match(MRSParser.ROLE_SYMBOL)
                pass

            elif la_ == 2:
                self.state = 1015
                self.match(MRSParser.CREATE_SYMBOL)
                self.state = 1016
                self.match(MRSParser.REST_SYMBOL)
                self.state = 1017
                self.match(MRSParser.ROLE_SYMBOL)
                self.state = 1021
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
                if la_ == 1:
                    self.state = 1018
                    self.match(MRSParser.IF_SYMBOL)
                    self.state = 1019
                    self.match(MRSParser.NOT_SYMBOL)
                    self.state = 1020
                    self.match(MRSParser.EXISTS_SYMBOL)


                pass


            self.state = 1025
            self.roleName()
            self.state = 1028
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==123:
                self.state = 1026
                self.match(MRSParser.EXTENDS_SYMBOL)
                self.state = 1027
                self.parentRoleName()


            self.state = 1031
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1030
                self.roleService()


            self.state = 1034
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 26)) & ~0x3f) == 0 and ((1 << (_la - 26)) & 52776558133249) != 0):
                self.state = 1033
                self.restRoleOptions()


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


    class RestRoleOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def jsonOptions(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonOptionsContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonOptionsContext,i)


        def comments(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.CommentsContext)
            else:
                return self.getTypedRuleContext(MRSParser.CommentsContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_restRoleOptions

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

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




    def restRoleOptions(self):

        localctx = MRSParser.RestRoleOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_restRoleOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1038 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1038
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [26, 70]:
                    self.state = 1036
                    self.jsonOptions()
                    pass
                elif token in [71]:
                    self.state = 1037
                    self.comments()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1040 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 26)) & ~0x3f) == 0 and ((1 << (_la - 26)) & 52776558133249) != 0)):
                    break

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


    class ParentRoleNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_parentRoleName

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

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




    def parentRoleName(self):

        localctx = MRSParser.ParentRoleNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_parentRoleName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1042
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RoleNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_roleName

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

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




    def roleName(self):

        localctx = MRSParser.RoleNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_roleName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1044
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CloneRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CLONE_SYMBOL(self):
            return self.getToken(MRSParser.CLONE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newServiceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewServiceRequestPathContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_cloneRestServiceStatement

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

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




    def cloneRestServiceStatement(self):

        localctx = MRSParser.CloneRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_cloneRestServiceStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1046
            self.match(MRSParser.CLONE_SYMBOL)
            self.state = 1047
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1048
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1049
            self.serviceRequestPath()
            self.state = 1050
            self.match(MRSParser.NEW_SYMBOL)
            self.state = 1051
            self.match(MRSParser.REQUEST_SYMBOL)
            self.state = 1052
            self.match(MRSParser.PATH_SYMBOL)
            self.state = 1053
            self.newServiceRequestPath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AlterRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newServiceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewServiceRequestPathContext,0)


        def restServiceOptions(self):
            return self.getTypedRuleContext(MRSParser.RestServiceOptionsContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_alterRestServiceStatement

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

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




    def alterRestServiceStatement(self):

        localctx = MRSParser.AlterRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_alterRestServiceStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1055
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1056
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1057
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1058
            self.serviceRequestPath()
            self.state = 1063
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1059
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1060
                self.match(MRSParser.REQUEST_SYMBOL)
                self.state = 1061
                self.match(MRSParser.PATH_SYMBOL)
                self.state = 1062
                self.newServiceRequestPath()


            self.state = 1066
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21 or _la==26 or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 7209999) != 0):
                self.state = 1065
                self.restServiceOptions()


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


    class AlterRestSchemaStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaRequestPath(self):
            return self.getTypedRuleContext(MRSParser.SchemaRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newSchemaRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewSchemaRequestPathContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def schemaName(self):
            return self.getTypedRuleContext(MRSParser.SchemaNameContext,0)


        def restSchemaOptions(self):
            return self.getTypedRuleContext(MRSParser.RestSchemaOptionsContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_alterRestSchemaStatement

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

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




    def alterRestSchemaStatement(self):

        localctx = MRSParser.AlterRestSchemaStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_alterRestSchemaStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1068
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1069
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1070
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 1072
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
            if la_ == 1:
                self.state = 1071
                self.schemaRequestPath()


            self.state = 1079
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1074
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1076
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
                if la_ == 1:
                    self.state = 1075
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1078
                self.serviceRequestPath()


            self.state = 1085
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1081
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1082
                self.match(MRSParser.REQUEST_SYMBOL)
                self.state = 1083
                self.match(MRSParser.PATH_SYMBOL)
                self.state = 1084
                self.newSchemaRequestPath()


            self.state = 1089
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1087
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1088
                self.schemaName()


            self.state = 1092
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==21 or _la==26 or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 268861699) != 0):
                self.state = 1091
                self.restSchemaOptions()


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


    class AlterRestViewStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def VIEW_SYMBOL(self):
            return self.getToken(MRSParser.VIEW_SYMBOL, 0)

        def viewRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ViewRequestPathContext,0)


        def DATA_SYMBOL(self):
            return self.getToken(MRSParser.DATA_SYMBOL, 0)

        def MAPPING_SYMBOL(self):
            return self.getToken(MRSParser.MAPPING_SYMBOL, 0)

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newViewRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewViewRequestPathContext,0)


        def CLASS_SYMBOL(self):
            return self.getToken(MRSParser.CLASS_SYMBOL, 0)

        def restObjectName(self):
            return self.getTypedRuleContext(MRSParser.RestObjectNameContext,0)


        def restObjectOptions(self):
            return self.getTypedRuleContext(MRSParser.RestObjectOptionsContext,0)


        def graphQlCrudOptions(self):
            return self.getTypedRuleContext(MRSParser.GraphQlCrudOptionsContext,0)


        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_alterRestViewStatement

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

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




    def alterRestViewStatement(self):

        localctx = MRSParser.AlterRestViewStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_alterRestViewStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1094
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1095
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1097
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==48:
                self.state = 1096
                self.match(MRSParser.DATA_SYMBOL)


            self.state = 1100
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==120:
                self.state = 1099
                self.match(MRSParser.MAPPING_SYMBOL)


            self.state = 1102
            self.match(MRSParser.VIEW_SYMBOL)
            self.state = 1103
            self.viewRequestPath()
            self.state = 1106
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1104
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1105
                self.serviceSchemaSelector()


            self.state = 1112
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1108
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1109
                self.match(MRSParser.REQUEST_SYMBOL)
                self.state = 1110
                self.match(MRSParser.PATH_SYMBOL)
                self.state = 1111
                self.newViewRequestPath()


            self.state = 1122
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==117:
                self.state = 1114
                self.match(MRSParser.CLASS_SYMBOL)
                self.state = 1115
                self.restObjectName()
                self.state = 1117
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & 31751) != 0):
                    self.state = 1116
                    self.graphQlCrudOptions()


                self.state = 1120
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==186:
                    self.state = 1119
                    self.graphQlObj()




            self.state = 1125
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0):
                self.state = 1124
                self.restObjectOptions()


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


    class AlterRestProcedureStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROCEDURE_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURE_SYMBOL, 0)

        def procedureRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ProcedureRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newProcedureRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewProcedureRequestPathContext,0)


        def PARAMETERS_SYMBOL(self):
            return self.getToken(MRSParser.PARAMETERS_SYMBOL, 0)

        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restProcedureResult(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestProcedureResultContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestProcedureResultContext,i)


        def restObjectOptions(self):
            return self.getTypedRuleContext(MRSParser.RestObjectOptionsContext,0)


        def restObjectName(self):
            return self.getTypedRuleContext(MRSParser.RestObjectNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_alterRestProcedureStatement

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

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




    def alterRestProcedureStatement(self):

        localctx = MRSParser.AlterRestProcedureStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_alterRestProcedureStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1127
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1128
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1129
            self.match(MRSParser.PROCEDURE_SYMBOL)
            self.state = 1130
            self.procedureRequestPath()
            self.state = 1133
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1131
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1132
                self.serviceSchemaSelector()


            self.state = 1139
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1135
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1136
                self.match(MRSParser.REQUEST_SYMBOL)
                self.state = 1137
                self.match(MRSParser.PATH_SYMBOL)
                self.state = 1138
                self.newProcedureRequestPath()


            self.state = 1146
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==67:
                self.state = 1141
                self.match(MRSParser.PARAMETERS_SYMBOL)
                self.state = 1143
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
                if la_ == 1:
                    self.state = 1142
                    self.restObjectName()


                self.state = 1145
                self.graphQlObj()


            self.state = 1151
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==84:
                self.state = 1148
                self.restProcedureResult()
                self.state = 1153
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1155
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0):
                self.state = 1154
                self.restObjectOptions()


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


    class AlterRestFunctionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def FUNCTION_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTION_SYMBOL, 0)

        def functionRequestPath(self):
            return self.getTypedRuleContext(MRSParser.FunctionRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newFunctionRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewFunctionRequestPathContext,0)


        def PARAMETERS_SYMBOL(self):
            return self.getToken(MRSParser.PARAMETERS_SYMBOL, 0)

        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def restFunctionResult(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestFunctionResultContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestFunctionResultContext,i)


        def restObjectOptions(self):
            return self.getTypedRuleContext(MRSParser.RestObjectOptionsContext,0)


        def restObjectName(self):
            return self.getTypedRuleContext(MRSParser.RestObjectNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_alterRestFunctionStatement

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

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




    def alterRestFunctionStatement(self):

        localctx = MRSParser.AlterRestFunctionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_alterRestFunctionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1157
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1158
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1159
            self.match(MRSParser.FUNCTION_SYMBOL)
            self.state = 1160
            self.functionRequestPath()
            self.state = 1163
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1161
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1162
                self.serviceSchemaSelector()


            self.state = 1169
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1165
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1166
                self.match(MRSParser.REQUEST_SYMBOL)
                self.state = 1167
                self.match(MRSParser.PATH_SYMBOL)
                self.state = 1168
                self.newFunctionRequestPath()


            self.state = 1176
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==67:
                self.state = 1171
                self.match(MRSParser.PARAMETERS_SYMBOL)
                self.state = 1173
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                if la_ == 1:
                    self.state = 1172
                    self.restObjectName()


                self.state = 1175
                self.graphQlObj()


            self.state = 1181
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==84:
                self.state = 1178
                self.restFunctionResult()
                self.state = 1183
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1185
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8659140608) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 2416345347) != 0):
                self.state = 1184
                self.restObjectOptions()


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


    class AlterRestContentSetStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def newContentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.NewContentSetRequestPathContext,0)


        def restContentSetOptions(self):
            return self.getTypedRuleContext(MRSParser.RestContentSetOptionsContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_alterRestContentSetStatement

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

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




    def alterRestContentSetStatement(self):

        localctx = MRSParser.AlterRestContentSetStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_alterRestContentSetStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1187
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1188
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1189
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1190
            self.match(MRSParser.SET_SYMBOL)
            self.state = 1191
            self.contentSetRequestPath()
            self.state = 1197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1192
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1194
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
                if la_ == 1:
                    self.state = 1193
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1196
                self.serviceRequestPath()


            self.state = 1203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1199
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1200
                self.match(MRSParser.REQUEST_SYMBOL)
                self.state = 1201
                self.match(MRSParser.PATH_SYMBOL)
                self.state = 1202
                self.newContentSetRequestPath()


            self.state = 1206
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 580542208671744) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 425987) != 0):
                self.state = 1205
                self.restContentSetOptions()


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


    class AlterRestAuthAppStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def NAME_SYMBOL(self):
            return self.getToken(MRSParser.NAME_SYMBOL, 0)

        def newAuthAppName(self):
            return self.getTypedRuleContext(MRSParser.NewAuthAppNameContext,0)


        def restAuthAppOptions(self):
            return self.getTypedRuleContext(MRSParser.RestAuthAppOptionsContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_alterRestAuthAppStatement

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

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




    def alterRestAuthAppStatement(self):

        localctx = MRSParser.AlterRestAuthAppStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_alterRestAuthAppStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1208
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1209
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1210
            _la = self._input.LA(1)
            if not(_la==21 or _la==106):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1211
            self.match(MRSParser.APP_SYMBOL)
            self.state = 1212
            self.authAppName()
            self.state = 1216
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 1213
                self.match(MRSParser.NEW_SYMBOL)
                self.state = 1214
                self.match(MRSParser.NAME_SYMBOL)
                self.state = 1215
                self.newAuthAppName()


            self.state = 1219
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & -4611686018410610688) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 1134696005107777) != 0):
                self.state = 1218
                self.restAuthAppOptions()


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


    class NewAuthAppNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newAuthAppName

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

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




    def newAuthAppName(self):

        localctx = MRSParser.NewAuthAppNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_newAuthAppName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1221
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AlterRestUserStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def USER_SYMBOL(self):
            return self.getToken(MRSParser.USER_SYMBOL, 0)

        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def IDENTIFIED_SYMBOL(self):
            return self.getToken(MRSParser.IDENTIFIED_SYMBOL, 0)

        def BY_SYMBOL(self):
            return self.getToken(MRSParser.BY_SYMBOL, 0)

        def userPassword(self):
            return self.getTypedRuleContext(MRSParser.UserPasswordContext,0)


        def userOptions(self):
            return self.getTypedRuleContext(MRSParser.UserOptionsContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_alterRestUserStatement

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

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




    def alterRestUserStatement(self):

        localctx = MRSParser.AlterRestUserStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_alterRestUserStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1223
            self.match(MRSParser.ALTER_SYMBOL)
            self.state = 1224
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1225
            self.match(MRSParser.USER_SYMBOL)
            self.state = 1226
            self.userName()
            self.state = 1227
            self.match(MRSParser.AT_SIGN_SYMBOL)
            self.state = 1228
            self.authAppName()
            self.state = 1232
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==40:
                self.state = 1229
                self.match(MRSParser.IDENTIFIED_SYMBOL)
                self.state = 1230
                self.match(MRSParser.BY_SYMBOL)
                self.state = 1231
                self.userPassword()


            self.state = 1235
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26 or _la==55 or _la==70 or _la==108:
                self.state = 1234
                self.userOptions()


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


    class DropRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dropRestServiceStatement

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

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




    def dropRestServiceStatement(self):

        localctx = MRSParser.DropRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_dropRestServiceStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1237
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1238
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1239
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1242
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
            if la_ == 1:
                self.state = 1240
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1241
                self.match(MRSParser.EXISTS_SYMBOL)


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


    class DropRestSchemaStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaRequestPath(self):
            return self.getTypedRuleContext(MRSParser.SchemaRequestPathContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dropRestSchemaStatement

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

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




    def dropRestSchemaStatement(self):

        localctx = MRSParser.DropRestSchemaStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_dropRestSchemaStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1246
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1247
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1248
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 1251
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
            if la_ == 1:
                self.state = 1249
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1250
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1253
            self.schemaRequestPath()
            self.state = 1259
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1254
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1256
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,143,self._ctx)
                if la_ == 1:
                    self.state = 1255
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1258
                self.serviceRequestPath()


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


    class DropRestViewStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def VIEW_SYMBOL(self):
            return self.getToken(MRSParser.VIEW_SYMBOL, 0)

        def viewRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ViewRequestPathContext,0)


        def DATA_SYMBOL(self):
            return self.getToken(MRSParser.DATA_SYMBOL, 0)

        def MAPPING_SYMBOL(self):
            return self.getToken(MRSParser.MAPPING_SYMBOL, 0)

        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_dropRestViewStatement

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

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




    def dropRestViewStatement(self):

        localctx = MRSParser.DropRestViewStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_dropRestViewStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1261
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1262
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==48:
                self.state = 1263
                self.match(MRSParser.DATA_SYMBOL)


            self.state = 1267
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==120:
                self.state = 1266
                self.match(MRSParser.MAPPING_SYMBOL)


            self.state = 1269
            self.match(MRSParser.VIEW_SYMBOL)
            self.state = 1272
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
            if la_ == 1:
                self.state = 1270
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1271
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1274
            self.viewRequestPath()
            self.state = 1277
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1275
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1276
                self.serviceSchemaSelector()


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


    class DropRestProcedureStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROCEDURE_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURE_SYMBOL, 0)

        def procedureRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ProcedureRequestPathContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_dropRestProcedureStatement

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

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




    def dropRestProcedureStatement(self):

        localctx = MRSParser.DropRestProcedureStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_dropRestProcedureStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1279
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1280
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1281
            self.match(MRSParser.PROCEDURE_SYMBOL)
            self.state = 1284
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,149,self._ctx)
            if la_ == 1:
                self.state = 1282
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1283
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1286
            self.procedureRequestPath()
            self.state = 1289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1287
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1288
                self.serviceSchemaSelector()


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


    class DropRestFunctionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def FUNCTION_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTION_SYMBOL, 0)

        def functionRequestPath(self):
            return self.getTypedRuleContext(MRSParser.FunctionRequestPathContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_dropRestFunctionStatement

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

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




    def dropRestFunctionStatement(self):

        localctx = MRSParser.DropRestFunctionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_dropRestFunctionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1291
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1292
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1293
            self.match(MRSParser.FUNCTION_SYMBOL)
            self.state = 1296
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
            if la_ == 1:
                self.state = 1294
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1295
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1298
            self.functionRequestPath()
            self.state = 1301
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1299
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1300
                self.serviceSchemaSelector()


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


    class DropRestContentSetStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dropRestContentSetStatement

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

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




    def dropRestContentSetStatement(self):

        localctx = MRSParser.DropRestContentSetStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_dropRestContentSetStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1303
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1304
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1305
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1306
            self.match(MRSParser.SET_SYMBOL)
            self.state = 1309
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
            if la_ == 1:
                self.state = 1307
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1308
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1311
            self.contentSetRequestPath()
            self.state = 1317
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1312
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1314
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
                if la_ == 1:
                    self.state = 1313
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1316
                self.serviceRequestPath()


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


    class DropRestContentFileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

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

        def FILE_SYMBOL(self):
            return self.getToken(MRSParser.FILE_SYMBOL, 0)

        def contentFileRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentFileRequestPathContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dropRestContentFileStatement

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

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




    def dropRestContentFileStatement(self):

        localctx = MRSParser.DropRestContentFileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_dropRestContentFileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1319
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1320
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1321
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1322
            self.match(MRSParser.FILE_SYMBOL)
            self.state = 1325
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
            if la_ == 1:
                self.state = 1323
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1324
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1327
            self.contentFileRequestPath()
            self.state = 1328
            self.match(MRSParser.FROM_SYMBOL)
            self.state = 1333
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
            if la_ == 1:
                self.state = 1330
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
                if la_ == 1:
                    self.state = 1329
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1332
                self.serviceRequestPath()


            self.state = 1335
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1336
            self.match(MRSParser.SET_SYMBOL)
            self.state = 1337
            self.contentSetRequestPath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DropRestAuthAppStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dropRestAuthAppStatement

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

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




    def dropRestAuthAppStatement(self):

        localctx = MRSParser.DropRestAuthAppStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_dropRestAuthAppStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1339
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1340
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1341
            _la = self._input.LA(1)
            if not(_la==21 or _la==106):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1342
            self.match(MRSParser.APP_SYMBOL)
            self.state = 1345
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
            if la_ == 1:
                self.state = 1343
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1344
                self.match(MRSParser.EXISTS_SYMBOL)


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


    class DropRestUserStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def USER_SYMBOL(self):
            return self.getToken(MRSParser.USER_SYMBOL, 0)

        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dropRestUserStatement

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

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




    def dropRestUserStatement(self):

        localctx = MRSParser.DropRestUserStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_dropRestUserStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1349
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1350
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1351
            self.match(MRSParser.USER_SYMBOL)
            self.state = 1354
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
            if la_ == 1:
                self.state = 1352
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1353
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1356
            self.userName()
            self.state = 1357
            self.match(MRSParser.AT_SIGN_SYMBOL)
            self.state = 1358
            self.authAppName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DropRestRoleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_dropRestRoleStatement

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

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




    def dropRestRoleStatement(self):

        localctx = MRSParser.DropRestRoleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_dropRestRoleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1360
            self.match(MRSParser.DROP_SYMBOL)
            self.state = 1361
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1362
            self.match(MRSParser.ROLE_SYMBOL)
            self.state = 1365
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
            if la_ == 1:
                self.state = 1363
                self.match(MRSParser.IF_SYMBOL)
                self.state = 1364
                self.match(MRSParser.EXISTS_SYMBOL)


            self.state = 1367
            self.roleName()
            self.state = 1369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1368
                self.roleService()


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


    class GrantRestPrivilegeStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GRANT_SYMBOL(self):
            return self.getToken(MRSParser.GRANT_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def privilegeList(self):
            return self.getTypedRuleContext(MRSParser.PrivilegeListContext,0)


        def TO_SYMBOL(self):
            return self.getToken(MRSParser.TO_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceRequestPathWildcard(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathWildcardContext,0)


        def serviceSchemaSelectorWildcard(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorWildcardContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def OBJECT_SYMBOL(self):
            return self.getToken(MRSParser.OBJECT_SYMBOL, 0)

        def objectRequestPathWildcard(self):
            return self.getTypedRuleContext(MRSParser.ObjectRequestPathWildcardContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_grantRestPrivilegeStatement

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

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




    def grantRestPrivilegeStatement(self):

        localctx = MRSParser.GrantRestPrivilegeStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_grantRestPrivilegeStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1371
            self.match(MRSParser.GRANT_SYMBOL)
            self.state = 1372
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1373
            self.privilegeList()
            self.state = 1385
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.state = 1374
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1376
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,163,self._ctx)
                if la_ == 1:
                    self.state = 1375
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1378
                self.serviceRequestPathWildcard()

            elif la_ == 2:
                self.state = 1379
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1380
                self.serviceSchemaSelectorWildcard()
                self.state = 1383
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==124:
                    self.state = 1381
                    self.match(MRSParser.OBJECT_SYMBOL)
                    self.state = 1382
                    self.objectRequestPathWildcard()




            self.state = 1387
            self.match(MRSParser.TO_SYMBOL)
            self.state = 1388
            self.roleName()
            self.state = 1390
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1389
                self.roleService()


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


    class PrivilegeListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def privilegeName(self):
            return self.getTypedRuleContext(MRSParser.PrivilegeNameContext,0)


        def COMMA_SYMBOL(self):
            return self.getToken(MRSParser.COMMA_SYMBOL, 0)

        def privilegeList(self):
            return self.getTypedRuleContext(MRSParser.PrivilegeListContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_privilegeList

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

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




    def privilegeList(self):

        localctx = MRSParser.PrivilegeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_privilegeList)
        try:
            self.state = 1397
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1392
                self.privilegeName()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1393
                self.privilegeName()
                self.state = 1394
                self.match(MRSParser.COMMA_SYMBOL)
                self.state = 1395
                self.privilegeList()
                pass


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


    class PrivilegeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def READ_SYMBOL(self):
            return self.getToken(MRSParser.READ_SYMBOL, 0)

        def UPDATE_SYMBOL(self):
            return self.getToken(MRSParser.UPDATE_SYMBOL, 0)

        def DELETE_SYMBOL(self):
            return self.getToken(MRSParser.DELETE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_privilegeName

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

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




    def privilegeName(self):

        localctx = MRSParser.PrivilegeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_privilegeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1399
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 6755433800794114) != 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 GrantRestRoleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GRANT_SYMBOL(self):
            return self.getToken(MRSParser.GRANT_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def TO_SYMBOL(self):
            return self.getToken(MRSParser.TO_SYMBOL, 0)

        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def comments(self):
            return self.getTypedRuleContext(MRSParser.CommentsContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_grantRestRoleStatement

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

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




    def grantRestRoleStatement(self):

        localctx = MRSParser.GrantRestRoleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_grantRestRoleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1401
            self.match(MRSParser.GRANT_SYMBOL)
            self.state = 1402
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1403
            self.match(MRSParser.ROLE_SYMBOL)
            self.state = 1404
            self.roleName()
            self.state = 1406
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1405
                self.roleService()


            self.state = 1408
            self.match(MRSParser.TO_SYMBOL)
            self.state = 1409
            self.userName()
            self.state = 1410
            self.match(MRSParser.AT_SIGN_SYMBOL)
            self.state = 1411
            self.authAppName()
            self.state = 1413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==71:
                self.state = 1412
                self.comments()


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


    class RevokeRestPrivilegeStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REVOKE_SYMBOL(self):
            return self.getToken(MRSParser.REVOKE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def privilegeList(self):
            return self.getTypedRuleContext(MRSParser.PrivilegeListContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def serviceRequestPathWildcard(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathWildcardContext,0)


        def serviceSchemaSelectorWildcard(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorWildcardContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def OBJECT_SYMBOL(self):
            return self.getToken(MRSParser.OBJECT_SYMBOL, 0)

        def objectRequestPathWildcard(self):
            return self.getTypedRuleContext(MRSParser.ObjectRequestPathWildcardContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_revokeRestPrivilegeStatement

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

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




    def revokeRestPrivilegeStatement(self):

        localctx = MRSParser.RevokeRestPrivilegeStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_revokeRestPrivilegeStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1415
            self.match(MRSParser.REVOKE_SYMBOL)
            self.state = 1416
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1417
            self.privilegeList()
            self.state = 1429
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
            if la_ == 1:
                self.state = 1418
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1420
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
                if la_ == 1:
                    self.state = 1419
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1422
                self.serviceRequestPathWildcard()

            elif la_ == 2:
                self.state = 1423
                self.match(MRSParser.ON_SYMBOL)
                self.state = 1424
                self.serviceSchemaSelectorWildcard()
                self.state = 1427
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==124:
                    self.state = 1425
                    self.match(MRSParser.OBJECT_SYMBOL)
                    self.state = 1426
                    self.objectRequestPathWildcard()




            self.state = 1431
            self.match(MRSParser.FROM_SYMBOL)
            self.state = 1432
            self.roleName()
            self.state = 1434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1433
                self.roleService()


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


    class RevokeRestRoleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REVOKE_SYMBOL(self):
            return self.getToken(MRSParser.REVOKE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_revokeRestRoleStatement

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

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




    def revokeRestRoleStatement(self):

        localctx = MRSParser.RevokeRestRoleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_revokeRestRoleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1436
            self.match(MRSParser.REVOKE_SYMBOL)
            self.state = 1437
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1438
            self.match(MRSParser.ROLE_SYMBOL)
            self.state = 1439
            self.roleName()
            self.state = 1441
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1440
                self.roleService()


            self.state = 1443
            self.match(MRSParser.FROM_SYMBOL)
            self.state = 1444
            self.userName()
            self.state = 1445
            self.match(MRSParser.AT_SIGN_SYMBOL)
            self.state = 1446
            self.authAppName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UseStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def USE_SYMBOL(self):
            return self.getToken(MRSParser.USE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def serviceAndSchemaRequestPaths(self):
            return self.getTypedRuleContext(MRSParser.ServiceAndSchemaRequestPathsContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_useStatement

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

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




    def useStatement(self):

        localctx = MRSParser.UseStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_useStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1448
            self.match(MRSParser.USE_SYMBOL)
            self.state = 1449
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1450
            self.serviceAndSchemaRequestPaths()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ServiceAndSchemaRequestPathsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_serviceAndSchemaRequestPaths

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

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




    def serviceAndSchemaRequestPaths(self):

        localctx = MRSParser.ServiceAndSchemaRequestPathsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_serviceAndSchemaRequestPaths)
        try:
            self.state = 1455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1452
                self.match(MRSParser.SERVICE_SYMBOL)
                self.state = 1453
                self.serviceRequestPath()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1454
                self.serviceSchemaSelector()
                pass


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


    class ShowRestMetadataStatusStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def STATUS_SYMBOL(self):
            return self.getToken(MRSParser.STATUS_SYMBOL, 0)

        def METADATA_SYMBOL(self):
            return self.getToken(MRSParser.METADATA_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestMetadataStatusStatement

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

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




    def showRestMetadataStatusStatement(self):

        localctx = MRSParser.ShowRestMetadataStatusStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_showRestMetadataStatusStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1457
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1458
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1460
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==78:
                self.state = 1459
                self.match(MRSParser.METADATA_SYMBOL)


            self.state = 1462
            self.match(MRSParser.STATUS_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShowRestServicesStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICES_SYMBOL(self):
            return self.getToken(MRSParser.SERVICES_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestServicesStatement

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

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




    def showRestServicesStatement(self):

        localctx = MRSParser.ShowRestServicesStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_showRestServicesStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1464
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1465
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1466
            self.match(MRSParser.SERVICES_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShowRestSchemasStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def DATABASES_SYMBOL(self):
            return self.getToken(MRSParser.DATABASES_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestSchemasStatement

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

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




    def showRestSchemasStatement(self):

        localctx = MRSParser.ShowRestSchemasStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_showRestSchemasStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1468
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1469
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1470
            self.match(MRSParser.DATABASES_SYMBOL)
            self.state = 1476
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1471
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1473
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,177,self._ctx)
                if la_ == 1:
                    self.state = 1472
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1475
                self.serviceRequestPath()


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


    class ShowRestViewsStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def VIEWS_SYMBOL(self):
            return self.getToken(MRSParser.VIEWS_SYMBOL, 0)

        def DATA_SYMBOL(self):
            return self.getToken(MRSParser.DATA_SYMBOL, 0)

        def MAPPING_SYMBOL(self):
            return self.getToken(MRSParser.MAPPING_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestViewsStatement

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

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




    def showRestViewsStatement(self):

        localctx = MRSParser.ShowRestViewsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_showRestViewsStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1478
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1479
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1481
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==48:
                self.state = 1480
                self.match(MRSParser.DATA_SYMBOL)


            self.state = 1484
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==120:
                self.state = 1483
                self.match(MRSParser.MAPPING_SYMBOL)


            self.state = 1486
            self.match(MRSParser.VIEWS_SYMBOL)
            self.state = 1489
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1487
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1488
                self.serviceSchemaSelector()


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


    class ShowRestProceduresStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROCEDURES_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURES_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestProceduresStatement

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

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




    def showRestProceduresStatement(self):

        localctx = MRSParser.ShowRestProceduresStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_showRestProceduresStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1491
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1492
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1493
            self.match(MRSParser.PROCEDURES_SYMBOL)
            self.state = 1496
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1494
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1495
                self.serviceSchemaSelector()


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


    class ShowRestFunctionsStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def FUNCTIONS_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTIONS_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestFunctionsStatement

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

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




    def showRestFunctionsStatement(self):

        localctx = MRSParser.ShowRestFunctionsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_showRestFunctionsStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1498
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1499
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1500
            self.match(MRSParser.FUNCTIONS_SYMBOL)
            self.state = 1503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1501
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1502
                self.serviceSchemaSelector()


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


    class ShowRestContentSetsStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def SETS_SYMBOL(self):
            return self.getToken(MRSParser.SETS_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestContentSetsStatement

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

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




    def showRestContentSetsStatement(self):

        localctx = MRSParser.ShowRestContentSetsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_showRestContentSetsStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1505
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1506
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1507
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1508
            self.match(MRSParser.SETS_SYMBOL)
            self.state = 1514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1509
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1511
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,184,self._ctx)
                if la_ == 1:
                    self.state = 1510
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1513
                self.serviceRequestPath()


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


    class ShowRestContentFilesStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

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

        def FILES_SYMBOL(self):
            return self.getToken(MRSParser.FILES_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestContentFilesStatement

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

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




    def showRestContentFilesStatement(self):

        localctx = MRSParser.ShowRestContentFilesStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_showRestContentFilesStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1516
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1517
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1518
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1519
            self.match(MRSParser.FILES_SYMBOL)
            self.state = 1520
            _la = self._input.LA(1)
            if not(_la==8 or _la==9):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1525
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
            if la_ == 1:
                self.state = 1522
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1521
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1524
                self.serviceRequestPath()


            self.state = 1527
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1528
            self.match(MRSParser.SET_SYMBOL)
            self.state = 1529
            self.contentSetRequestPath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShowRestAuthAppsStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def APPS_SYMBOL(self):
            return self.getToken(MRSParser.APPS_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showRestAuthAppsStatement

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

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




    def showRestAuthAppsStatement(self):

        localctx = MRSParser.ShowRestAuthAppsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_showRestAuthAppsStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1531
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1532
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1533
            self.match(MRSParser.AUTH_SYMBOL)
            self.state = 1534
            self.match(MRSParser.APPS_SYMBOL)
            self.state = 1540
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1535
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1537
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
                if la_ == 1:
                    self.state = 1536
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1539
                self.serviceRequestPath()


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


    class ShowRestRolesStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def ROLES_SYMBOL(self):
            return self.getToken(MRSParser.ROLES_SYMBOL, 0)

        def FOR_SYMBOL(self):
            return self.getToken(MRSParser.FOR_SYMBOL, 0)

        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def ANY_SYMBOL(self):
            return self.getToken(MRSParser.ANY_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_showRestRolesStatement

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

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




    def showRestRolesStatement(self):

        localctx = MRSParser.ShowRestRolesStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_showRestRolesStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1542
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1543
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1544
            self.match(MRSParser.ROLES_SYMBOL)
            self.state = 1554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1545
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1552
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
                if la_ == 1:
                    self.state = 1546
                    self.match(MRSParser.ANY_SYMBOL)
                    self.state = 1547
                    self.match(MRSParser.SERVICE_SYMBOL)
                    pass

                elif la_ == 2:
                    self.state = 1549
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
                    if la_ == 1:
                        self.state = 1548
                        self.match(MRSParser.SERVICE_SYMBOL)


                    self.state = 1551
                    self.serviceRequestPath()
                    pass




            self.state = 1562
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 1556
                self.match(MRSParser.FOR_SYMBOL)
                self.state = 1558
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
                if la_ == 1:
                    self.state = 1557
                    self.userName()


                self.state = 1560
                self.match(MRSParser.AT_SIGN_SYMBOL)
                self.state = 1561
                self.authAppName()


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


    class ShowRestGrantsStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def GRANTS_SYMBOL(self):
            return self.getToken(MRSParser.GRANTS_SYMBOL, 0)

        def FOR_SYMBOL(self):
            return self.getToken(MRSParser.FOR_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def ANY_SYMBOL(self):
            return self.getToken(MRSParser.ANY_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_showRestGrantsStatement

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

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




    def showRestGrantsStatement(self):

        localctx = MRSParser.ShowRestGrantsStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_showRestGrantsStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1564
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1565
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1566
            self.match(MRSParser.GRANTS_SYMBOL)
            self.state = 1567
            self.match(MRSParser.FOR_SYMBOL)
            self.state = 1568
            self.roleName()
            self.state = 1578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1569
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1576
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
                if la_ == 1:
                    self.state = 1570
                    self.match(MRSParser.ANY_SYMBOL)
                    self.state = 1571
                    self.match(MRSParser.SERVICE_SYMBOL)
                    pass

                elif la_ == 2:
                    self.state = 1573
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
                    if la_ == 1:
                        self.state = 1572
                        self.match(MRSParser.SERVICE_SYMBOL)


                    self.state = 1575
                    self.serviceRequestPath()
                    pass




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


    class ShowCreateRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def INCLUDING_SYMBOL(self):
            return self.getToken(MRSParser.INCLUDING_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def ENDPOINTS_SYMBOL(self):
            return self.getToken(MRSParser.ENDPOINTS_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestServiceStatement

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

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




    def showCreateRestServiceStatement(self):

        localctx = MRSParser.ShowCreateRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_showCreateRestServiceStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1580
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1581
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1582
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1583
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1585
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1584
                self.serviceRequestPath()


            self.state = 1590
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==127:
                self.state = 1587
                self.match(MRSParser.INCLUDING_SYMBOL)
                self.state = 1588
                self.match(MRSParser.DATABASE_SYMBOL)
                self.state = 1589
                self.match(MRSParser.ENDPOINTS_SYMBOL)


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


    class ShowCreateRestSchemaStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaRequestPath(self):
            return self.getTypedRuleContext(MRSParser.SchemaRequestPathContext,0)


        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestSchemaStatement

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

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




    def showCreateRestSchemaStatement(self):

        localctx = MRSParser.ShowCreateRestSchemaStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_showCreateRestSchemaStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1592
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1593
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1594
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1595
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 1597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
            if la_ == 1:
                self.state = 1596
                self.schemaRequestPath()


            self.state = 1604
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1599
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1601
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                if la_ == 1:
                    self.state = 1600
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1603
                self.serviceRequestPath()


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


    class ShowCreateRestViewStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def VIEW_SYMBOL(self):
            return self.getToken(MRSParser.VIEW_SYMBOL, 0)

        def viewRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ViewRequestPathContext,0)


        def DATA_SYMBOL(self):
            return self.getToken(MRSParser.DATA_SYMBOL, 0)

        def MAPPING_SYMBOL(self):
            return self.getToken(MRSParser.MAPPING_SYMBOL, 0)

        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestViewStatement

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

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




    def showCreateRestViewStatement(self):

        localctx = MRSParser.ShowCreateRestViewStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_showCreateRestViewStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1606
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1607
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1608
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1610
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==48:
                self.state = 1609
                self.match(MRSParser.DATA_SYMBOL)


            self.state = 1613
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==120:
                self.state = 1612
                self.match(MRSParser.MAPPING_SYMBOL)


            self.state = 1615
            self.match(MRSParser.VIEW_SYMBOL)
            self.state = 1616
            self.viewRequestPath()
            self.state = 1619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1617
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1618
                self.serviceSchemaSelector()


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


    class ShowCreateRestProcedureStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROCEDURE_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURE_SYMBOL, 0)

        def procedureRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ProcedureRequestPathContext,0)


        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestProcedureStatement

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

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




    def showCreateRestProcedureStatement(self):

        localctx = MRSParser.ShowCreateRestProcedureStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_showCreateRestProcedureStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1621
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1622
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1623
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1624
            self.match(MRSParser.PROCEDURE_SYMBOL)
            self.state = 1625
            self.procedureRequestPath()
            self.state = 1628
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1626
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1627
                self.serviceSchemaSelector()


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


    class ShowCreateRestFunctionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def FUNCTION_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTION_SYMBOL, 0)

        def functionRequestPath(self):
            return self.getTypedRuleContext(MRSParser.FunctionRequestPathContext,0)


        def serviceSchemaSelector(self):
            return self.getTypedRuleContext(MRSParser.ServiceSchemaSelectorContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestFunctionStatement

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

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




    def showCreateRestFunctionStatement(self):

        localctx = MRSParser.ShowCreateRestFunctionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_showCreateRestFunctionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1630
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1631
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1632
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1633
            self.match(MRSParser.FUNCTION_SYMBOL)
            self.state = 1634
            self.functionRequestPath()
            self.state = 1637
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1635
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1636
                self.serviceSchemaSelector()


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


    class ShowCreateRestContentSetStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestContentSetStatement

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

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




    def showCreateRestContentSetStatement(self):

        localctx = MRSParser.ShowCreateRestContentSetStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_showCreateRestContentSetStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1639
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1640
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1641
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1642
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1643
            self.match(MRSParser.SET_SYMBOL)
            self.state = 1644
            self.contentSetRequestPath()
            self.state = 1650
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8 or _la==9:
                self.state = 1645
                _la = self._input.LA(1)
                if not(_la==8 or _la==9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1647
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
                if la_ == 1:
                    self.state = 1646
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1649
                self.serviceRequestPath()


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


    class ShowCreateRestContentFileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

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

        def FILE_SYMBOL(self):
            return self.getToken(MRSParser.FILE_SYMBOL, 0)

        def contentFileRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentFileRequestPathContext,0)


        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def contentSetRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ContentSetRequestPathContext,0)


        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestContentFileStatement

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

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




    def showCreateRestContentFileStatement(self):

        localctx = MRSParser.ShowCreateRestContentFileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_showCreateRestContentFileStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1652
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1653
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1654
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1655
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1656
            self.match(MRSParser.FILE_SYMBOL)
            self.state = 1657
            self.contentFileRequestPath()
            self.state = 1658
            _la = self._input.LA(1)
            if not(_la==8 or _la==9):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
            if la_ == 1:
                self.state = 1660
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
                if la_ == 1:
                    self.state = 1659
                    self.match(MRSParser.SERVICE_SYMBOL)


                self.state = 1662
                self.serviceRequestPath()


            self.state = 1665
            self.match(MRSParser.CONTENT_SYMBOL)
            self.state = 1666
            self.match(MRSParser.SET_SYMBOL)
            self.state = 1667
            self.contentSetRequestPath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShowCreateRestAuthAppStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestAuthAppStatement

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

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




    def showCreateRestAuthAppStatement(self):

        localctx = MRSParser.ShowCreateRestAuthAppStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_showCreateRestAuthAppStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1669
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1670
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1671
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1672
            self.match(MRSParser.AUTH_SYMBOL)
            self.state = 1673
            self.match(MRSParser.APP_SYMBOL)
            self.state = 1674
            self.authAppName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ShowCreateRestRoleStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def roleName(self):
            return self.getTypedRuleContext(MRSParser.RoleNameContext,0)


        def roleService(self):
            return self.getTypedRuleContext(MRSParser.RoleServiceContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestRoleStatement

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

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




    def showCreateRestRoleStatement(self):

        localctx = MRSParser.ShowCreateRestRoleStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_showCreateRestRoleStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1676
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1677
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1678
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1679
            self.match(MRSParser.ROLE_SYMBOL)
            self.state = 1680
            self.roleName()
            self.state = 1682
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 1681
                self.roleService()


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


    class ShowCreateRestUserStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def USER_SYMBOL(self):
            return self.getToken(MRSParser.USER_SYMBOL, 0)

        def userName(self):
            return self.getTypedRuleContext(MRSParser.UserNameContext,0)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

        def authAppName(self):
            return self.getTypedRuleContext(MRSParser.AuthAppNameContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_showCreateRestUserStatement

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

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




    def showCreateRestUserStatement(self):

        localctx = MRSParser.ShowCreateRestUserStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_showCreateRestUserStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1684
            self.match(MRSParser.SHOW_SYMBOL)
            self.state = 1685
            self.match(MRSParser.CREATE_SYMBOL)
            self.state = 1686
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1687
            self.match(MRSParser.USER_SYMBOL)
            self.state = 1688
            self.userName()
            self.state = 1689
            self.match(MRSParser.AT_SIGN_SYMBOL)
            self.state = 1690
            self.authAppName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DumpRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DUMP_SYMBOL(self):
            return self.getToken(MRSParser.DUMP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def AS_SYMBOL(self):
            return self.getToken(MRSParser.AS_SYMBOL, 0)

        def SCRIPT_SYMBOL(self):
            return self.getToken(MRSParser.SCRIPT_SYMBOL, 0)

        def INCLUDING_SYMBOL(self):
            return self.getToken(MRSParser.INCLUDING_SYMBOL, 0)

        def ENDPOINTS_SYMBOL(self):
            return self.getToken(MRSParser.ENDPOINTS_SYMBOL, 0)

        def TO_SYMBOL(self):
            return self.getToken(MRSParser.TO_SYMBOL, 0)

        def directoryFilePath(self):
            return self.getTypedRuleContext(MRSParser.DirectoryFilePathContext,0)


        def ALL_SYMBOL(self):
            return self.getToken(MRSParser.ALL_SYMBOL, 0)

        def SQL_SYMBOL(self):
            return self.getToken(MRSParser.SQL_SYMBOL, 0)

        def ZIP_SYMBOL(self):
            return self.getToken(MRSParser.ZIP_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

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

        def STATIC_SYMBOL(self):
            return self.getToken(MRSParser.STATIC_SYMBOL, 0)

        def DYNAMIC_SYMBOL(self):
            return self.getToken(MRSParser.DYNAMIC_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dumpRestServiceStatement

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

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




    def dumpRestServiceStatement(self):

        localctx = MRSParser.DumpRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_dumpRestServiceStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1692
            self.match(MRSParser.DUMP_SYMBOL)
            self.state = 1693
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1694
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1695
            self.serviceRequestPath()
            self.state = 1696
            self.match(MRSParser.AS_SYMBOL)
            self.state = 1698
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==73:
                self.state = 1697
                self.match(MRSParser.SQL_SYMBOL)


            self.state = 1700
            self.match(MRSParser.SCRIPT_SYMBOL)
            self.state = 1701
            self.match(MRSParser.INCLUDING_SYMBOL)
            self.state = 1712
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [12]:
                self.state = 1702
                self.match(MRSParser.DATABASE_SYMBOL)
                self.state = 1709
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==74:
                    self.state = 1703
                    self.match(MRSParser.AND_SYMBOL)
                    self.state = 1704
                    self.match(MRSParser.STATIC_SYMBOL)
                    self.state = 1707
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==74:
                        self.state = 1705
                        self.match(MRSParser.AND_SYMBOL)
                        self.state = 1706
                        self.match(MRSParser.DYNAMIC_SYMBOL)




                pass
            elif token in [66]:
                self.state = 1711
                self.match(MRSParser.ALL_SYMBOL)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1714
            self.match(MRSParser.ENDPOINTS_SYMBOL)
            self.state = 1715
            self.match(MRSParser.TO_SYMBOL)
            self.state = 1717
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
            if la_ == 1:
                self.state = 1716
                self.match(MRSParser.ZIP_SYMBOL)


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


    class DumpRestProjectStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DUMP_SYMBOL(self):
            return self.getToken(MRSParser.DUMP_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROJECT_SYMBOL(self):
            return self.getToken(MRSParser.PROJECT_SYMBOL, 0)

        def restProjectName(self):
            return self.getTypedRuleContext(MRSParser.RestProjectNameContext,0)


        def VERSION_SYMBOL(self):
            return self.getToken(MRSParser.VERSION_SYMBOL, 0)

        def restProjectVersion(self):
            return self.getTypedRuleContext(MRSParser.RestProjectVersionContext,0)


        def TO_SYMBOL(self):
            return self.getToken(MRSParser.TO_SYMBOL, 0)

        def directoryFilePath(self):
            return self.getTypedRuleContext(MRSParser.DirectoryFilePathContext,0)


        def dumpRestProjectService(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.DumpRestProjectServiceContext)
            else:
                return self.getTypedRuleContext(MRSParser.DumpRestProjectServiceContext,i)


        def dumpRestProjectDatabaseSchema(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.DumpRestProjectDatabaseSchemaContext)
            else:
                return self.getTypedRuleContext(MRSParser.DumpRestProjectDatabaseSchemaContext,i)


        def dumpRestProjectSettings(self):
            return self.getTypedRuleContext(MRSParser.DumpRestProjectSettingsContext,0)


        def ZIP_SYMBOL(self):
            return self.getToken(MRSParser.ZIP_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dumpRestProjectStatement

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

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




    def dumpRestProjectStatement(self):

        localctx = MRSParser.DumpRestProjectStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_dumpRestProjectStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1721
            self.match(MRSParser.DUMP_SYMBOL)
            self.state = 1722
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1723
            self.match(MRSParser.PROJECT_SYMBOL)
            self.state = 1724
            self.restProjectName()
            self.state = 1725
            self.match(MRSParser.VERSION_SYMBOL)
            self.state = 1726
            self.restProjectVersion()
            self.state = 1728 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1727
                self.dumpRestProjectService()
                self.state = 1730 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==80):
                    break

            self.state = 1735
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==12:
                self.state = 1732
                self.dumpRestProjectDatabaseSchema()
                self.state = 1737
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1739
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 6917529027641081857) != 0):
                self.state = 1738
                self.dumpRestProjectSettings()


            self.state = 1741
            self.match(MRSParser.TO_SYMBOL)
            self.state = 1743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,221,self._ctx)
            if la_ == 1:
                self.state = 1742
                self.match(MRSParser.ZIP_SYMBOL)


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


    class LoadRestServiceStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOAD_SYMBOL(self):
            return self.getToken(MRSParser.LOAD_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def directoryFilePath(self):
            return self.getTypedRuleContext(MRSParser.DirectoryFilePathContext,0)


        def AS_SYMBOL(self):
            return self.getToken(MRSParser.AS_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_loadRestServiceStatement

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

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




    def loadRestServiceStatement(self):

        localctx = MRSParser.LoadRestServiceStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_loadRestServiceStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1747
            self.match(MRSParser.LOAD_SYMBOL)
            self.state = 1748
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1749
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1752
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19:
                self.state = 1750
                self.match(MRSParser.AS_SYMBOL)
                self.state = 1751
                self.serviceRequestPath()


            self.state = 1754
            self.match(MRSParser.FROM_SYMBOL)
            self.state = 1755
            self.directoryFilePath()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LoadRestProjectStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LOAD_SYMBOL(self):
            return self.getToken(MRSParser.LOAD_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def PROJECT_SYMBOL(self):
            return self.getToken(MRSParser.PROJECT_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def directoryFilePath(self):
            return self.getTypedRuleContext(MRSParser.DirectoryFilePathContext,0)


        def ZIP_SYMBOL(self):
            return self.getToken(MRSParser.ZIP_SYMBOL, 0)

        def URL_SYMBOL(self):
            return self.getToken(MRSParser.URL_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_loadRestProjectStatement

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

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




    def loadRestProjectStatement(self):

        localctx = MRSParser.LoadRestProjectStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_loadRestProjectStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1757
            self.match(MRSParser.LOAD_SYMBOL)
            self.state = 1758
            self.match(MRSParser.REST_SYMBOL)
            self.state = 1759
            self.match(MRSParser.PROJECT_SYMBOL)
            self.state = 1760
            self.match(MRSParser.FROM_SYMBOL)
            self.state = 1762
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,223,self._ctx)
            if la_ == 1:
                self.state = 1761
                _la = self._input.LA(1)
                if not(_la==63 or _la==131):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class DumpRestProjectServiceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def serviceRequestPath(self):
            return self.getTypedRuleContext(MRSParser.ServiceRequestPathContext,0)


        def INCLUDING_SYMBOL(self):
            return self.getToken(MRSParser.INCLUDING_SYMBOL, 0)

        def ENDPOINTS_SYMBOL(self):
            return self.getToken(MRSParser.ENDPOINTS_SYMBOL, 0)

        def ALL_SYMBOL(self):
            return self.getToken(MRSParser.ALL_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

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

        def STATIC_SYMBOL(self):
            return self.getToken(MRSParser.STATIC_SYMBOL, 0)

        def DYNAMIC_SYMBOL(self):
            return self.getToken(MRSParser.DYNAMIC_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_dumpRestProjectService

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

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




    def dumpRestProjectService(self):

        localctx = MRSParser.DumpRestProjectServiceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_dumpRestProjectService)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1766
            self.match(MRSParser.SERVICE_SYMBOL)
            self.state = 1767
            self.serviceRequestPath()
            self.state = 1768
            self.match(MRSParser.INCLUDING_SYMBOL)
            self.state = 1779
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [12]:
                self.state = 1769
                self.match(MRSParser.DATABASE_SYMBOL)
                self.state = 1776
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==74:
                    self.state = 1770
                    self.match(MRSParser.AND_SYMBOL)
                    self.state = 1771
                    self.match(MRSParser.STATIC_SYMBOL)
                    self.state = 1774
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==74:
                        self.state = 1772
                        self.match(MRSParser.AND_SYMBOL)
                        self.state = 1773
                        self.match(MRSParser.DYNAMIC_SYMBOL)




                pass
            elif token in [66]:
                self.state = 1778
                self.match(MRSParser.ALL_SYMBOL)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1781
            self.match(MRSParser.ENDPOINTS_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DumpRestProjectDatabaseSchemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def schemaName(self):
            return self.getTypedRuleContext(MRSParser.SchemaNameContext,0)


        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def restProjectDatabaseSchemaFilePath(self):
            return self.getTypedRuleContext(MRSParser.RestProjectDatabaseSchemaFilePathContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_dumpRestProjectDatabaseSchema

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

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




    def dumpRestProjectDatabaseSchema(self):

        localctx = MRSParser.DumpRestProjectDatabaseSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_dumpRestProjectDatabaseSchema)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1783
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 1784
            self.schemaName()
            self.state = 1787
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1785
                self.match(MRSParser.FROM_SYMBOL)
                self.state = 1786
                self.restProjectDatabaseSchemaFilePath()


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


    class DumpRestProjectSettingsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def restProjectIconFilePath(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestProjectIconFilePathContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestProjectIconFilePathContext,i)


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

        def restProjectDescription(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestProjectDescriptionContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestProjectDescriptionContext,i)


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

        def restProjectPublisher(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.RestProjectPublisherContext)
            else:
                return self.getTypedRuleContext(MRSParser.RestProjectPublisherContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_dumpRestProjectSettings

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

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




    def dumpRestProjectSettings(self):

        localctx = MRSParser.DumpRestProjectSettingsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_dumpRestProjectSettings)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1796 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1796
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [136]:
                    self.state = 1789
                    self.match(MRSParser.ICON_SYMBOL)
                    self.state = 1790
                    self.match(MRSParser.FROM_SYMBOL)
                    self.state = 1791
                    self.restProjectIconFilePath()
                    pass
                elif token in [75]:
                    self.state = 1792
                    self.match(MRSParser.DESCRIPTION_SYMBOL)
                    self.state = 1793
                    self.restProjectDescription()
                    pass
                elif token in [137]:
                    self.state = 1794
                    self.match(MRSParser.PUBLISHER_SYMBOL)
                    self.state = 1795
                    self.restProjectPublisher()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1798 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & 6917529027641081857) != 0)):
                    break

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


    class RestProjectNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProjectName

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

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




    def restProjectName(self):

        localctx = MRSParser.RestProjectNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_restProjectName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1800
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestProjectDatabaseSchemaFilePathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProjectDatabaseSchemaFilePath

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

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




    def restProjectDatabaseSchemaFilePath(self):

        localctx = MRSParser.RestProjectDatabaseSchemaFilePathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_restProjectDatabaseSchemaFilePath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1802
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestProjectIconFilePathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProjectIconFilePath

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

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




    def restProjectIconFilePath(self):

        localctx = MRSParser.RestProjectIconFilePathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_restProjectIconFilePath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1804
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestProjectDescriptionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProjectDescription

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

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




    def restProjectDescription(self):

        localctx = MRSParser.RestProjectDescriptionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_restProjectDescription)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1806
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestProjectPublisherContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProjectPublisher

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

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




    def restProjectPublisher(self):

        localctx = MRSParser.RestProjectPublisherContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_restProjectPublisher)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1808
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestProjectVersionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restProjectVersion

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

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




    def restProjectVersion(self):

        localctx = MRSParser.RestProjectVersionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_restProjectVersion)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1810
            self.textStringLiteral()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ServiceRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def serviceDevelopersIdentifier(self):
            return self.getTypedRuleContext(MRSParser.ServiceDevelopersIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_serviceRequestPath

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

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




    def serviceRequestPath(self):

        localctx = MRSParser.ServiceRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_serviceRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1813
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
            if la_ == 1:
                self.state = 1812
                self.serviceDevelopersIdentifier()


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


    class NewServiceRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def serviceDevelopersIdentifier(self):
            return self.getTypedRuleContext(MRSParser.ServiceDevelopersIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newServiceRequestPath

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

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




    def newServiceRequestPath(self):

        localctx = MRSParser.NewServiceRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_newServiceRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1818
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,231,self._ctx)
            if la_ == 1:
                self.state = 1817
                self.serviceDevelopersIdentifier()


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


    class ServiceRequestPathWildcardContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifierWithWildcard(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierWithWildcardContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_serviceRequestPathWildcard

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

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




    def serviceRequestPathWildcard(self):

        localctx = MRSParser.ServiceRequestPathWildcardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_serviceRequestPathWildcard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1822
            self.requestPathIdentifierWithWildcard()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SchemaRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_schemaRequestPath

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

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




    def schemaRequestPath(self):

        localctx = MRSParser.SchemaRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_schemaRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1824
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewSchemaRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newSchemaRequestPath

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

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




    def newSchemaRequestPath(self):

        localctx = MRSParser.NewSchemaRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_newSchemaRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1826
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SchemaRequestPathWildcardContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifierWithWildcard(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierWithWildcardContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_schemaRequestPathWildcard

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

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




    def schemaRequestPathWildcard(self):

        localctx = MRSParser.SchemaRequestPathWildcardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_schemaRequestPathWildcard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1828
            self.requestPathIdentifierWithWildcard()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ViewRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_viewRequestPath

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

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




    def viewRequestPath(self):

        localctx = MRSParser.ViewRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_viewRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1830
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewViewRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newViewRequestPath

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

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




    def newViewRequestPath(self):

        localctx = MRSParser.NewViewRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_newViewRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1832
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestObjectNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restObjectName

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

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




    def restObjectName(self):

        localctx = MRSParser.RestObjectNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_restObjectName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1834
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RestResultNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_restResultName

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

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




    def restResultName(self):

        localctx = MRSParser.RestResultNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_restResultName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1836
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_objectRequestPath

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

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




    def objectRequestPath(self):

        localctx = MRSParser.ObjectRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_objectRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1838
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ObjectRequestPathWildcardContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifierWithWildcard(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierWithWildcardContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_objectRequestPathWildcard

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

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




    def objectRequestPathWildcard(self):

        localctx = MRSParser.ObjectRequestPathWildcardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_objectRequestPathWildcard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1840
            self.requestPathIdentifierWithWildcard()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ProcedureRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_procedureRequestPath

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

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




    def procedureRequestPath(self):

        localctx = MRSParser.ProcedureRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_procedureRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1842
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_functionRequestPath

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

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




    def functionRequestPath(self):

        localctx = MRSParser.FunctionRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_functionRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1844
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewProcedureRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newProcedureRequestPath

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

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




    def newProcedureRequestPath(self):

        localctx = MRSParser.NewProcedureRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_newProcedureRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1846
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewFunctionRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newFunctionRequestPath

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

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




    def newFunctionRequestPath(self):

        localctx = MRSParser.NewFunctionRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_newFunctionRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1848
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContentSetRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_contentSetRequestPath

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

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




    def contentSetRequestPath(self):

        localctx = MRSParser.ContentSetRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_contentSetRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1850
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NewContentSetRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_newContentSetRequestPath

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

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




    def newContentSetRequestPath(self):

        localctx = MRSParser.NewContentSetRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_newContentSetRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1852
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ContentFileRequestPathContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def requestPathIdentifier(self):
            return self.getTypedRuleContext(MRSParser.RequestPathIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_contentFileRequestPath

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

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




    def contentFileRequestPath(self):

        localctx = MRSParser.ContentFileRequestPathContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_contentFileRequestPath)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1854
            self.requestPathIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ServiceDeveloperIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def textOrIdentifier(self):
            return self.getTypedRuleContext(MRSParser.TextOrIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_serviceDeveloperIdentifier

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

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




    def serviceDeveloperIdentifier(self):

        localctx = MRSParser.ServiceDeveloperIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_serviceDeveloperIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1856
            self.textOrIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ServiceDevelopersIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def serviceDeveloperIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.ServiceDeveloperIdentifierContext)
            else:
                return self.getTypedRuleContext(MRSParser.ServiceDeveloperIdentifierContext,i)


        def AT_SIGN_SYMBOL(self):
            return self.getToken(MRSParser.AT_SIGN_SYMBOL, 0)

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

        def getRuleIndex(self):
            return MRSParser.RULE_serviceDevelopersIdentifier

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

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




    def serviceDevelopersIdentifier(self):

        localctx = MRSParser.ServiceDevelopersIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_serviceDevelopersIdentifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1858
            self.serviceDeveloperIdentifier()
            self.state = 1863
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==181:
                self.state = 1859
                self.match(MRSParser.COMMA_SYMBOL)
                self.state = 1860
                self.serviceDeveloperIdentifier()
                self.state = 1865
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1866
            self.match(MRSParser.AT_SIGN_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class RequestPathIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REST_REQUEST_PATH(self):
            return self.getToken(MRSParser.REST_REQUEST_PATH, 0)

        def BACK_TICK_QUOTED_ID(self):
            return self.getToken(MRSParser.BACK_TICK_QUOTED_ID, 0)

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_requestPathIdentifier

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

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




    def requestPathIdentifier(self):

        localctx = MRSParser.RequestPathIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_requestPathIdentifier)
        try:
            self.state = 1872
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,233,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1868
                self.match(MRSParser.REST_REQUEST_PATH)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1869
                self.match(MRSParser.BACK_TICK_QUOTED_ID)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1870
                if not self.isSqlModeActive("ANSI_QUOTES"):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.isSqlModeActive(\"ANSI_QUOTES\")")
                self.state = 1871
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass


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


    class RequestPathIdentifierWithWildcardContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REST_REQUEST_PATH(self):
            return self.getToken(MRSParser.REST_REQUEST_PATH, 0)

        def BACK_TICK_QUOTED_ID(self):
            return self.getToken(MRSParser.BACK_TICK_QUOTED_ID, 0)

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_requestPathIdentifierWithWildcard

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

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




    def requestPathIdentifierWithWildcard(self):

        localctx = MRSParser.RequestPathIdentifierWithWildcardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_requestPathIdentifierWithWildcard)
        try:
            self.state = 1878
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1874
                self.match(MRSParser.REST_REQUEST_PATH)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1875
                self.match(MRSParser.BACK_TICK_QUOTED_ID)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1876
                if not self.isSqlModeActive("ANSI_QUOTES"):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.isSqlModeActive(\"ANSI_QUOTES\")")
                self.state = 1877
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass


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


    class JsonObjContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_CURLY_SYMBOL(self):
            return self.getToken(MRSParser.OPEN_CURLY_SYMBOL, 0)

        def jsonPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonPairContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonPairContext,i)


        def CLOSE_CURLY_SYMBOL(self):
            return self.getToken(MRSParser.CLOSE_CURLY_SYMBOL, 0)

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

        def getRuleIndex(self):
            return MRSParser.RULE_jsonObj

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

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




    def jsonObj(self):

        localctx = MRSParser.JsonObjContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_jsonObj)
        self._la = 0 # Token type
        try:
            self.state = 1893
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1880
                self.match(MRSParser.OPEN_CURLY_SYMBOL)
                self.state = 1881
                self.jsonPair()
                self.state = 1886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==181:
                    self.state = 1882
                    self.match(MRSParser.COMMA_SYMBOL)
                    self.state = 1883
                    self.jsonPair()
                    self.state = 1888
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1889
                self.match(MRSParser.CLOSE_CURLY_SYMBOL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1891
                self.match(MRSParser.OPEN_CURLY_SYMBOL)
                self.state = 1892
                self.match(MRSParser.CLOSE_CURLY_SYMBOL)
                pass


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


    class JsonPairContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def COLON_SYMBOL(self):
            return self.getToken(MRSParser.COLON_SYMBOL, 0)

        def jsonValue(self):
            return self.getTypedRuleContext(MRSParser.JsonValueContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_jsonPair

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

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




    def jsonPair(self):

        localctx = MRSParser.JsonPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_jsonPair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1895
            self.match(MRSParser.DOUBLE_QUOTED_TEXT)
            self.state = 1896
            self.match(MRSParser.COLON_SYMBOL)
            self.state = 1897
            self.jsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonArrContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_SQUARE_SYMBOL(self):
            return self.getToken(MRSParser.OPEN_SQUARE_SYMBOL, 0)

        def CLOSE_SQUARE_SYMBOL(self):
            return self.getToken(MRSParser.CLOSE_SQUARE_SYMBOL, 0)

        def jsonValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.JsonValueContext)
            else:
                return self.getTypedRuleContext(MRSParser.JsonValueContext,i)


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

        def getRuleIndex(self):
            return MRSParser.RULE_jsonArr

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

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




    def jsonArr(self):

        localctx = MRSParser.JsonArrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_jsonArr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1899
            self.match(MRSParser.OPEN_SQUARE_SYMBOL)
            self.state = 1908
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 481036337152) != 0) or ((((_la - 166)) & ~0x3f) == 0 and ((1 << (_la - 166)) & 4483955294211) != 0):
                self.state = 1900
                self.jsonValue()
                self.state = 1905
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==181:
                    self.state = 1901
                    self.match(MRSParser.COMMA_SYMBOL)
                    self.state = 1902
                    self.jsonValue()
                    self.state = 1907
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1910
            self.match(MRSParser.CLOSE_SQUARE_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class JsonValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def FLOAT_NUMBER(self):
            return self.getToken(MRSParser.FLOAT_NUMBER, 0)

        def MINUS_OPERATOR(self):
            return self.getToken(MRSParser.MINUS_OPERATOR, 0)

        def PLUS_OPERATOR(self):
            return self.getToken(MRSParser.PLUS_OPERATOR, 0)

        def INT_NUMBER(self):
            return self.getToken(MRSParser.INT_NUMBER, 0)

        def jsonObj(self):
            return self.getTypedRuleContext(MRSParser.JsonObjContext,0)


        def jsonArr(self):
            return self.getTypedRuleContext(MRSParser.JsonArrContext,0)


        def TRUE_SYMBOL(self):
            return self.getToken(MRSParser.TRUE_SYMBOL, 0)

        def FALSE_SYMBOL(self):
            return self.getToken(MRSParser.FALSE_SYMBOL, 0)

        def NULL_SYMBOL(self):
            return self.getToken(MRSParser.NULL_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_jsonValue

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

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




    def jsonValue(self):

        localctx = MRSParser.JsonValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_jsonValue)
        self._la = 0 # Token type
        try:
            self.state = 1923
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [208]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1912
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass
            elif token in [166, 167, 202]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1914
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==166 or _la==167:
                    self.state = 1913
                    _la = self._input.LA(1)
                    if not(_la==166 or _la==167):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1916
                self.match(MRSParser.FLOAT_NUMBER)
                pass
            elif token in [200]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1917
                self.match(MRSParser.INT_NUMBER)
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1918
                self.jsonObj()
                pass
            elif token in [189]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1919
                self.jsonArr()
                pass
            elif token in [37]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1920
                self.match(MRSParser.TRUE_SYMBOL)
                pass
            elif token in [38]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1921
                self.match(MRSParser.FALSE_SYMBOL)
                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1922
                self.match(MRSParser.NULL_SYMBOL)
                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 GraphQlObjContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_CURLY_SYMBOL(self):
            return self.getToken(MRSParser.OPEN_CURLY_SYMBOL, 0)

        def graphQlPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.GraphQlPairContext)
            else:
                return self.getTypedRuleContext(MRSParser.GraphQlPairContext,i)


        def CLOSE_CURLY_SYMBOL(self):
            return self.getToken(MRSParser.CLOSE_CURLY_SYMBOL, 0)

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

        def getRuleIndex(self):
            return MRSParser.RULE_graphQlObj

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

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




    def graphQlObj(self):

        localctx = MRSParser.GraphQlObjContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_graphQlObj)
        self._la = 0 # Token type
        try:
            self.state = 1938
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1925
                self.match(MRSParser.OPEN_CURLY_SYMBOL)
                self.state = 1926
                self.graphQlPair()
                self.state = 1931
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==181:
                    self.state = 1927
                    self.match(MRSParser.COMMA_SYMBOL)
                    self.state = 1928
                    self.graphQlPair()
                    self.state = 1933
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1934
                self.match(MRSParser.CLOSE_CURLY_SYMBOL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1936
                self.match(MRSParser.OPEN_CURLY_SYMBOL)
                self.state = 1937
                self.match(MRSParser.CLOSE_CURLY_SYMBOL)
                pass


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


    class GraphQlCrudOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return MRSParser.RULE_graphQlCrudOptions

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

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




    def graphQlCrudOptions(self):

        localctx = MRSParser.GraphQlCrudOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_graphQlCrudOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1941 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1940
                _la = self._input.LA(1)
                if not(((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & 31751) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1943 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & 31751) != 0)):
                    break

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


    class GraphQlPairContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def graphQlPairKey(self):
            return self.getTypedRuleContext(MRSParser.GraphQlPairKeyContext,0)


        def COLON_SYMBOL(self):
            return self.getToken(MRSParser.COLON_SYMBOL, 0)

        def graphQlPairValue(self):
            return self.getTypedRuleContext(MRSParser.GraphQlPairValueContext,0)


        def graphQlValueOptions(self):
            return self.getTypedRuleContext(MRSParser.GraphQlValueOptionsContext,0)


        def AT_DATATYPE_SYMBOL(self):
            return self.getToken(MRSParser.AT_DATATYPE_SYMBOL, 0)

        def OPEN_PAR_SYMBOL(self):
            return self.getToken(MRSParser.OPEN_PAR_SYMBOL, 0)

        def graphQlDatatypeValue(self):
            return self.getTypedRuleContext(MRSParser.GraphQlDatatypeValueContext,0)


        def CLOSE_PAR_SYMBOL(self):
            return self.getToken(MRSParser.CLOSE_PAR_SYMBOL, 0)

        def graphQlCrudOptions(self):
            return self.getTypedRuleContext(MRSParser.GraphQlCrudOptionsContext,0)


        def graphQlValueJsonSchema(self):
            return self.getTypedRuleContext(MRSParser.GraphQlValueJsonSchemaContext,0)


        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def AT_IN_SYMBOL(self):
            return self.getToken(MRSParser.AT_IN_SYMBOL, 0)

        def AT_OUT_SYMBOL(self):
            return self.getToken(MRSParser.AT_OUT_SYMBOL, 0)

        def AT_INOUT_SYMBOL(self):
            return self.getToken(MRSParser.AT_INOUT_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_graphQlPair

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

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




    def graphQlPair(self):

        localctx = MRSParser.GraphQlPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_graphQlPair)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1945
            self.graphQlPairKey()
            self.state = 1946
            self.match(MRSParser.COLON_SYMBOL)
            self.state = 1947
            self.graphQlPairValue()
            self.state = 1949
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 7) != 0):
                self.state = 1948
                _la = self._input.LA(1)
                if not(((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 7) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1952
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
            if la_ == 1:
                self.state = 1951
                self.graphQlValueOptions()


            self.state = 1959
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==148:
                self.state = 1954
                self.match(MRSParser.AT_DATATYPE_SYMBOL)
                self.state = 1955
                self.match(MRSParser.OPEN_PAR_SYMBOL)
                self.state = 1956
                self.graphQlDatatypeValue()
                self.state = 1957
                self.match(MRSParser.CLOSE_PAR_SYMBOL)


            self.state = 1962
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 141)) & ~0x3f) == 0 and ((1 << (_la - 141)) & 31751) != 0):
                self.state = 1961
                self.graphQlCrudOptions()


            self.state = 1965
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==13:
                self.state = 1964
                self.graphQlValueJsonSchema()


            self.state = 1968
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==186:
                self.state = 1967
                self.graphQlObj()


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


    class GraphQlValueOptionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return MRSParser.RULE_graphQlValueOptions

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

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




    def graphQlValueOptions(self):

        localctx = MRSParser.GraphQlValueOptionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_graphQlValueOptions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1971 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1970
                    _la = self._input.LA(1)
                    if not(((((_la - 142)) & ~0x3f) == 0 and ((1 << (_la - 142)) & 16445) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

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

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


    class GraphQlValueJsonSchemaContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def JSON_SYMBOL(self):
            return self.getToken(MRSParser.JSON_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def jsonValue(self):
            return self.getTypedRuleContext(MRSParser.JsonValueContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_graphQlValueJsonSchema

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

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




    def graphQlValueJsonSchema(self):

        localctx = MRSParser.GraphQlValueJsonSchemaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_graphQlValueJsonSchema)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1975
            self.match(MRSParser.JSON_SYMBOL)
            self.state = 1976
            self.match(MRSParser.DATABASE_SYMBOL)
            self.state = 1977
            self.jsonValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GraphQlAllowedKeywordContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CREATE_SYMBOL(self):
            return self.getToken(MRSParser.CREATE_SYMBOL, 0)

        def OR_SYMBOL(self):
            return self.getToken(MRSParser.OR_SYMBOL, 0)

        def REPLACE_SYMBOL(self):
            return self.getToken(MRSParser.REPLACE_SYMBOL, 0)

        def ALTER_SYMBOL(self):
            return self.getToken(MRSParser.ALTER_SYMBOL, 0)

        def SHOW_SYMBOL(self):
            return self.getToken(MRSParser.SHOW_SYMBOL, 0)

        def STATUS_SYMBOL(self):
            return self.getToken(MRSParser.STATUS_SYMBOL, 0)

        def NEW_SYMBOL(self):
            return self.getToken(MRSParser.NEW_SYMBOL, 0)

        def ON_SYMBOL(self):
            return self.getToken(MRSParser.ON_SYMBOL, 0)

        def FROM_SYMBOL(self):
            return self.getToken(MRSParser.FROM_SYMBOL, 0)

        def IN_SYMBOL(self):
            return self.getToken(MRSParser.IN_SYMBOL, 0)

        def DATABASES_SYMBOL(self):
            return self.getToken(MRSParser.DATABASES_SYMBOL, 0)

        def DATABASE_SYMBOL(self):
            return self.getToken(MRSParser.DATABASE_SYMBOL, 0)

        def JSON_SYMBOL(self):
            return self.getToken(MRSParser.JSON_SYMBOL, 0)

        def VIEW_SYMBOL(self):
            return self.getToken(MRSParser.VIEW_SYMBOL, 0)

        def PROCEDURE_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURE_SYMBOL, 0)

        def FUNCTION_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTION_SYMBOL, 0)

        def DROP_SYMBOL(self):
            return self.getToken(MRSParser.DROP_SYMBOL, 0)

        def USE_SYMBOL(self):
            return self.getToken(MRSParser.USE_SYMBOL, 0)

        def AS_SYMBOL(self):
            return self.getToken(MRSParser.AS_SYMBOL, 0)

        def FILTER_SYMBOL(self):
            return self.getToken(MRSParser.FILTER_SYMBOL, 0)

        def AUTHENTICATION_SYMBOL(self):
            return self.getToken(MRSParser.AUTHENTICATION_SYMBOL, 0)

        def PATH_SYMBOL(self):
            return self.getToken(MRSParser.PATH_SYMBOL, 0)

        def VALIDATION_SYMBOL(self):
            return self.getToken(MRSParser.VALIDATION_SYMBOL, 0)

        def DEFAULT_SYMBOL(self):
            return self.getToken(MRSParser.DEFAULT_SYMBOL, 0)

        def USER_SYMBOL(self):
            return self.getToken(MRSParser.USER_SYMBOL, 0)

        def OPTIONS_SYMBOL(self):
            return self.getToken(MRSParser.OPTIONS_SYMBOL, 0)

        def IF_SYMBOL(self):
            return self.getToken(MRSParser.IF_SYMBOL, 0)

        def NOT_SYMBOL(self):
            return self.getToken(MRSParser.NOT_SYMBOL, 0)

        def EXISTS_SYMBOL(self):
            return self.getToken(MRSParser.EXISTS_SYMBOL, 0)

        def PAGE_SYMBOL(self):
            return self.getToken(MRSParser.PAGE_SYMBOL, 0)

        def HOST_SYMBOL(self):
            return self.getToken(MRSParser.HOST_SYMBOL, 0)

        def TYPE_SYMBOL(self):
            return self.getToken(MRSParser.TYPE_SYMBOL, 0)

        def FORMAT_SYMBOL(self):
            return self.getToken(MRSParser.FORMAT_SYMBOL, 0)

        def UPDATE_SYMBOL(self):
            return self.getToken(MRSParser.UPDATE_SYMBOL, 0)

        def NULL_SYMBOL(self):
            return self.getToken(MRSParser.NULL_SYMBOL, 0)

        def TRUE_SYMBOL(self):
            return self.getToken(MRSParser.TRUE_SYMBOL, 0)

        def FALSE_SYMBOL(self):
            return self.getToken(MRSParser.FALSE_SYMBOL, 0)

        def SET_SYMBOL(self):
            return self.getToken(MRSParser.SET_SYMBOL, 0)

        def IDENTIFIED_SYMBOL(self):
            return self.getToken(MRSParser.IDENTIFIED_SYMBOL, 0)

        def BY_SYMBOL(self):
            return self.getToken(MRSParser.BY_SYMBOL, 0)

        def ROLE_SYMBOL(self):
            return self.getToken(MRSParser.ROLE_SYMBOL, 0)

        def TO_SYMBOL(self):
            return self.getToken(MRSParser.TO_SYMBOL, 0)

        def IGNORE_SYMBOL(self):
            return self.getToken(MRSParser.IGNORE_SYMBOL, 0)

        def CLONE_SYMBOL(self):
            return self.getToken(MRSParser.CLONE_SYMBOL, 0)

        def FILE_SYMBOL(self):
            return self.getToken(MRSParser.FILE_SYMBOL, 0)

        def BINARY_SYMBOL(self):
            return self.getToken(MRSParser.BINARY_SYMBOL, 0)

        def DATA_SYMBOL(self):
            return self.getToken(MRSParser.DATA_SYMBOL, 0)

        def LOAD_SYMBOL(self):
            return self.getToken(MRSParser.LOAD_SYMBOL, 0)

        def GRANT_SYMBOL(self):
            return self.getToken(MRSParser.GRANT_SYMBOL, 0)

        def READ_SYMBOL(self):
            return self.getToken(MRSParser.READ_SYMBOL, 0)

        def DELETE_SYMBOL(self):
            return self.getToken(MRSParser.DELETE_SYMBOL, 0)

        def GROUP_SYMBOL(self):
            return self.getToken(MRSParser.GROUP_SYMBOL, 0)

        def REVOKE_SYMBOL(self):
            return self.getToken(MRSParser.REVOKE_SYMBOL, 0)

        def ACCOUNT_SYMBOL(self):
            return self.getToken(MRSParser.ACCOUNT_SYMBOL, 0)

        def LOCK_SYMBOL(self):
            return self.getToken(MRSParser.LOCK_SYMBOL, 0)

        def UNLOCK_SYMBOL(self):
            return self.getToken(MRSParser.UNLOCK_SYMBOL, 0)

        def GRANTS_SYMBOL(self):
            return self.getToken(MRSParser.GRANTS_SYMBOL, 0)

        def FOR_SYMBOL(self):
            return self.getToken(MRSParser.FOR_SYMBOL, 0)

        def LEVEL_SYMBOL(self):
            return self.getToken(MRSParser.LEVEL_SYMBOL, 0)

        def ANY_SYMBOL(self):
            return self.getToken(MRSParser.ANY_SYMBOL, 0)

        def CLIENT_SYMBOL(self):
            return self.getToken(MRSParser.CLIENT_SYMBOL, 0)

        def URL_SYMBOL(self):
            return self.getToken(MRSParser.URL_SYMBOL, 0)

        def NAME_SYMBOL(self):
            return self.getToken(MRSParser.NAME_SYMBOL, 0)

        def DO_SYMBOL(self):
            return self.getToken(MRSParser.DO_SYMBOL, 0)

        def CONFIGURE_SYMBOL(self):
            return self.getToken(MRSParser.CONFIGURE_SYMBOL, 0)

        def REST_SYMBOL(self):
            return self.getToken(MRSParser.REST_SYMBOL, 0)

        def METADATA_SYMBOL(self):
            return self.getToken(MRSParser.METADATA_SYMBOL, 0)

        def SERVICES_SYMBOL(self):
            return self.getToken(MRSParser.SERVICES_SYMBOL, 0)

        def SERVICE_SYMBOL(self):
            return self.getToken(MRSParser.SERVICE_SYMBOL, 0)

        def VIEWS_SYMBOL(self):
            return self.getToken(MRSParser.VIEWS_SYMBOL, 0)

        def PROCEDURES_SYMBOL(self):
            return self.getToken(MRSParser.PROCEDURES_SYMBOL, 0)

        def PARAMETERS_SYMBOL(self):
            return self.getToken(MRSParser.PARAMETERS_SYMBOL, 0)

        def FUNCTIONS_SYMBOL(self):
            return self.getToken(MRSParser.FUNCTIONS_SYMBOL, 0)

        def RESULT_SYMBOL(self):
            return self.getToken(MRSParser.RESULT_SYMBOL, 0)

        def ENABLED_SYMBOL(self):
            return self.getToken(MRSParser.ENABLED_SYMBOL, 0)

        def PUBLISHED_SYMBOL(self):
            return self.getToken(MRSParser.PUBLISHED_SYMBOL, 0)

        def DISABLED_SYMBOL(self):
            return self.getToken(MRSParser.DISABLED_SYMBOL, 0)

        def PRIVATE_SYMBOL(self):
            return self.getToken(MRSParser.PRIVATE_SYMBOL, 0)

        def UNPUBLISHED_SYMBOL(self):
            return self.getToken(MRSParser.UNPUBLISHED_SYMBOL, 0)

        def PROTOCOL_SYMBOL(self):
            return self.getToken(MRSParser.PROTOCOL_SYMBOL, 0)

        def HTTP_SYMBOL(self):
            return self.getToken(MRSParser.HTTP_SYMBOL, 0)

        def HTTPS_SYMBOL(self):
            return self.getToken(MRSParser.HTTPS_SYMBOL, 0)

        def COMMENT_SYMBOL(self):
            return self.getToken(MRSParser.COMMENT_SYMBOL, 0)

        def REQUEST_SYMBOL(self):
            return self.getToken(MRSParser.REQUEST_SYMBOL, 0)

        def REDIRECTION_SYMBOL(self):
            return self.getToken(MRSParser.REDIRECTION_SYMBOL, 0)

        def MANAGEMENT_SYMBOL(self):
            return self.getToken(MRSParser.MANAGEMENT_SYMBOL, 0)

        def AVAILABLE_SYMBOL(self):
            return self.getToken(MRSParser.AVAILABLE_SYMBOL, 0)

        def REQUIRED_SYMBOL(self):
            return self.getToken(MRSParser.REQUIRED_SYMBOL, 0)

        def ITEMS_SYMBOL(self):
            return self.getToken(MRSParser.ITEMS_SYMBOL, 0)

        def PER_SYMBOL(self):
            return self.getToken(MRSParser.PER_SYMBOL, 0)

        def CONTENT_SYMBOL(self):
            return self.getToken(MRSParser.CONTENT_SYMBOL, 0)

        def MEDIA_SYMBOL(self):
            return self.getToken(MRSParser.MEDIA_SYMBOL, 0)

        def AUTODETECT_SYMBOL(self):
            return self.getToken(MRSParser.AUTODETECT_SYMBOL, 0)

        def FEED_SYMBOL(self):
            return self.getToken(MRSParser.FEED_SYMBOL, 0)

        def ITEM_SYMBOL(self):
            return self.getToken(MRSParser.ITEM_SYMBOL, 0)

        def SETS_SYMBOL(self):
            return self.getToken(MRSParser.SETS_SYMBOL, 0)

        def FILES_SYMBOL(self):
            return self.getToken(MRSParser.FILES_SYMBOL, 0)

        def AUTH_SYMBOL(self):
            return self.getToken(MRSParser.AUTH_SYMBOL, 0)

        def APPS_SYMBOL(self):
            return self.getToken(MRSParser.APPS_SYMBOL, 0)

        def APP_SYMBOL(self):
            return self.getToken(MRSParser.APP_SYMBOL, 0)

        def ID_SYMBOL(self):
            return self.getToken(MRSParser.ID_SYMBOL, 0)

        def SECRET_SYMBOL(self):
            return self.getToken(MRSParser.SECRET_SYMBOL, 0)

        def VENDOR_SYMBOL(self):
            return self.getToken(MRSParser.VENDOR_SYMBOL, 0)

        def MRS_SYMBOL(self):
            return self.getToken(MRSParser.MRS_SYMBOL, 0)

        def MYSQL_SYMBOL(self):
            return self.getToken(MRSParser.MYSQL_SYMBOL, 0)

        def USERS_SYMBOL(self):
            return self.getToken(MRSParser.USERS_SYMBOL, 0)

        def ALLOW_SYMBOL(self):
            return self.getToken(MRSParser.ALLOW_SYMBOL, 0)

        def REGISTER_SYMBOL(self):
            return self.getToken(MRSParser.REGISTER_SYMBOL, 0)

        def CLASS_SYMBOL(self):
            return self.getToken(MRSParser.CLASS_SYMBOL, 0)

        def DEVELOPMENT_SYMBOL(self):
            return self.getToken(MRSParser.DEVELOPMENT_SYMBOL, 0)

        def SCRIPTS_SYMBOL(self):
            return self.getToken(MRSParser.SCRIPTS_SYMBOL, 0)

        def MAPPING_SYMBOL(self):
            return self.getToken(MRSParser.MAPPING_SYMBOL, 0)

        def TYPESCRIPT_SYMBOL(self):
            return self.getToken(MRSParser.TYPESCRIPT_SYMBOL, 0)

        def ROLES_SYMBOL(self):
            return self.getToken(MRSParser.ROLES_SYMBOL, 0)

        def EXTENDS_SYMBOL(self):
            return self.getToken(MRSParser.EXTENDS_SYMBOL, 0)

        def OBJECT_SYMBOL(self):
            return self.getToken(MRSParser.OBJECT_SYMBOL, 0)

        def HIERARCHY_SYMBOL(self):
            return self.getToken(MRSParser.HIERARCHY_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_graphQlAllowedKeyword

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

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




    def graphQlAllowedKeyword(self):

        localctx = MRSParser.GraphQlAllowedKeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_graphQlAllowedKeyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1979
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & -17179869186) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 4611686018427383947) != 0) or _la==215):
                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 GraphQlPairKeyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def graphQlAllowedKeyword(self):
            return self.getTypedRuleContext(MRSParser.GraphQlAllowedKeywordContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_graphQlPairKey

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

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




    def graphQlPairKey(self):

        localctx = MRSParser.GraphQlPairKeyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_graphQlPairKey)
        try:
            self.state = 1984
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,251,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1981
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1982
                self.identifier()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1983
                self.graphQlAllowedKeyword()
                pass


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


    class GraphQlPairValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedIdentifier(self):
            return self.getTypedRuleContext(MRSParser.QualifiedIdentifierContext,0)


        def graphQlAllowedKeyword(self):
            return self.getTypedRuleContext(MRSParser.GraphQlAllowedKeywordContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_graphQlPairValue

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

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




    def graphQlPairValue(self):

        localctx = MRSParser.GraphQlPairValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_graphQlPairValue)
        try:
            self.state = 1988
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1986
                self.qualifiedIdentifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1987
                self.graphQlAllowedKeyword()
                pass


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


    class GraphQlReduceToValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_graphQlReduceToValue

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

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




    def graphQlReduceToValue(self):

        localctx = MRSParser.GraphQlReduceToValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_graphQlReduceToValue)
        try:
            self.state = 1992
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1990
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1991
                self.identifier()
                pass


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


    class GraphQlDatatypeValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_graphQlDatatypeValue

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

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




    def graphQlDatatypeValue(self):

        localctx = MRSParser.GraphQlDatatypeValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_graphQlDatatypeValue)
        try:
            self.state = 1996
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,254,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1994
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1995
                self.identifier()
                pass


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


    class GraphQlValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def qualifiedIdentifier(self):
            return self.getTypedRuleContext(MRSParser.QualifiedIdentifierContext,0)


        def graphQlObj(self):
            return self.getTypedRuleContext(MRSParser.GraphQlObjContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_graphQlValue

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

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




    def graphQlValue(self):

        localctx = MRSParser.GraphQlValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_graphQlValue)
        try:
            self.state = 2000
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,255,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1998
                self.qualifiedIdentifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1999
                self.graphQlObj()
                pass


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


    class SchemaNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_schemaName

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

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




    def schemaName(self):

        localctx = MRSParser.SchemaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_schemaName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2002
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ViewNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_viewName

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

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




    def viewName(self):

        localctx = MRSParser.ViewNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_viewName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2004
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ProcedureNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_procedureName

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

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




    def procedureName(self):

        localctx = MRSParser.ProcedureNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_procedureName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2006
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class PureIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENTIFIER(self):
            return self.getToken(MRSParser.IDENTIFIER, 0)

        def BACK_TICK_QUOTED_ID(self):
            return self.getToken(MRSParser.BACK_TICK_QUOTED_ID, 0)

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_pureIdentifier

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

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




    def pureIdentifier(self):

        localctx = MRSParser.PureIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_pureIdentifier)
        self._la = 0 # Token type
        try:
            self.state = 2011
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2008
                _la = self._input.LA(1)
                if not(_la==205 or _la==207):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2009
                if not self.isSqlModeActive("ANSI_QUOTES"):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.isSqlModeActive(\"ANSI_QUOTES\")")
                self.state = 2010
                self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass


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


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pureIdentifier(self):
            return self.getTypedRuleContext(MRSParser.PureIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_identifier

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

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




    def identifier(self):

        localctx = MRSParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_identifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2013
            self.pureIdentifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(MRSParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return MRSParser.RULE_identifierList

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

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




    def identifierList(self):

        localctx = MRSParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2015
            self.identifier()
            self.state = 2020
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==181:
                self.state = 2016
                self.match(MRSParser.COMMA_SYMBOL)
                self.state = 2017
                self.identifier()
                self.state = 2022
                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 IdentifierListWithParenthesesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_PAR_SYMBOL(self):
            return self.getToken(MRSParser.OPEN_PAR_SYMBOL, 0)

        def identifierList(self):
            return self.getTypedRuleContext(MRSParser.IdentifierListContext,0)


        def CLOSE_PAR_SYMBOL(self):
            return self.getToken(MRSParser.CLOSE_PAR_SYMBOL, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_identifierListWithParentheses

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

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




    def identifierListWithParentheses(self):

        localctx = MRSParser.IdentifierListWithParenthesesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_identifierListWithParentheses)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2023
            self.match(MRSParser.OPEN_PAR_SYMBOL)
            self.state = 2024
            self.identifierList()
            self.state = 2025
            self.match(MRSParser.CLOSE_PAR_SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class QualifiedIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def dotIdentifier(self):
            return self.getTypedRuleContext(MRSParser.DotIdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_qualifiedIdentifier

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

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




    def qualifiedIdentifier(self):

        localctx = MRSParser.QualifiedIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_qualifiedIdentifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2027
            self.identifier()
            self.state = 2029
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==180:
                self.state = 2028
                self.dotIdentifier()


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


    class SimpleIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def dotIdentifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(MRSParser.DotIdentifierContext)
            else:
                return self.getTypedRuleContext(MRSParser.DotIdentifierContext,i)


        def getRuleIndex(self):
            return MRSParser.RULE_simpleIdentifier

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

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




    def simpleIdentifier(self):

        localctx = MRSParser.SimpleIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_simpleIdentifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2031
            self.identifier()
            self.state = 2036
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==180:
                self.state = 2032
                self.dotIdentifier()
                self.state = 2034
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==180:
                    self.state = 2033
                    self.dotIdentifier()




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


    class DotIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DOT_SYMBOL(self):
            return self.getToken(MRSParser.DOT_SYMBOL, 0)

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_dotIdentifier

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

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




    def dotIdentifier(self):

        localctx = MRSParser.DotIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_dotIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2038
            self.match(MRSParser.DOT_SYMBOL)
            self.state = 2039
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TextStringLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SINGLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.SINGLE_QUOTED_TEXT, 0)

        def DOUBLE_QUOTED_TEXT(self):
            return self.getToken(MRSParser.DOUBLE_QUOTED_TEXT, 0)

        def getRuleIndex(self):
            return MRSParser.RULE_textStringLiteral

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

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




    def textStringLiteral(self):

        localctx = MRSParser.TextStringLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_textStringLiteral)
        try:
            self.state = 2044
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2041
                localctx.value = self.match(MRSParser.SINGLE_QUOTED_TEXT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2042
                if not not self.isSqlModeActive("ANSI_QUOTES"):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "not self.isSqlModeActive(\"ANSI_QUOTES\")")
                self.state = 2043
                localctx.value = self.match(MRSParser.DOUBLE_QUOTED_TEXT)
                pass


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


    class TextOrIdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(MRSParser.IdentifierContext,0)


        def textStringLiteral(self):
            return self.getTypedRuleContext(MRSParser.TextStringLiteralContext,0)


        def getRuleIndex(self):
            return MRSParser.RULE_textOrIdentifier

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

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




    def textOrIdentifier(self):

        localctx = MRSParser.TextOrIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_textOrIdentifier)
        try:
            self.state = 2048
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,262,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2046
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2047
                self.textStringLiteral()
                pass


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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[149] = self.requestPathIdentifier_sempred
        self._predicates[150] = self.requestPathIdentifierWithWildcard_sempred
        self._predicates[169] = self.pureIdentifier_sempred
        self._predicates[176] = self.textStringLiteral_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def requestPathIdentifier_sempred(self, localctx:RequestPathIdentifierContext, predIndex:int):
            if predIndex == 0:
                return self.isSqlModeActive("ANSI_QUOTES")
         

    def requestPathIdentifierWithWildcard_sempred(self, localctx:RequestPathIdentifierWithWildcardContext, predIndex:int):
            if predIndex == 1:
                return self.isSqlModeActive("ANSI_QUOTES")
         

    def pureIdentifier_sempred(self, localctx:PureIdentifierContext, predIndex:int):
            if predIndex == 2:
                return self.isSqlModeActive("ANSI_QUOTES")
         

    def textStringLiteral_sempred(self, localctx:TextStringLiteralContext, predIndex:int):
            if predIndex == 3:
                return not self.isSqlModeActive("ANSI_QUOTES")
         




