# Generated from XplorMRParser.g4 by ANTLR 4.13.0
# 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,303,3046,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,1,0,1,0,1,0,1,0,
        1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
        1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
        1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
        1,0,1,0,1,0,1,0,1,0,5,0,318,8,0,10,0,12,0,321,9,0,1,0,1,0,1,1,1,
        1,5,1,327,8,1,10,1,12,1,330,9,1,1,1,1,1,1,2,3,2,335,8,2,1,2,1,2,
        5,2,339,8,2,10,2,12,2,342,9,2,1,2,1,2,1,3,1,3,5,3,348,8,3,10,3,12,
        3,351,9,3,1,3,1,3,1,3,5,3,356,8,3,10,3,12,3,359,9,3,1,3,1,3,1,3,
        5,3,364,8,3,10,3,12,3,367,9,3,1,3,1,3,1,3,5,3,372,8,3,10,3,12,3,
        375,9,3,1,3,1,3,1,3,5,3,380,8,3,10,3,12,3,383,9,3,1,3,3,3,386,8,
        3,1,4,3,4,389,8,4,1,4,1,4,5,4,393,8,4,10,4,12,4,396,9,4,1,4,1,4,
        1,5,3,5,401,8,5,1,5,1,5,5,5,405,8,5,10,5,12,5,408,9,5,1,5,1,5,1,
        6,1,6,5,6,414,8,6,10,6,12,6,417,9,6,1,6,1,6,1,7,1,7,5,7,423,8,7,
        10,7,12,7,426,9,7,1,7,1,7,1,8,1,8,5,8,432,8,8,10,8,12,8,435,9,8,
        1,8,1,8,1,9,1,9,5,9,441,8,9,10,9,12,9,444,9,9,1,9,1,9,1,10,1,10,
        5,10,450,8,10,10,10,12,10,453,9,10,1,10,1,10,1,11,1,11,5,11,459,
        8,11,10,11,12,11,462,9,11,1,11,1,11,1,12,1,12,5,12,468,8,12,10,12,
        12,12,471,9,12,1,12,1,12,1,13,1,13,5,13,477,8,13,10,13,12,13,480,
        9,13,1,13,1,13,1,14,1,14,5,14,486,8,14,10,14,12,14,489,9,14,1,14,
        1,14,1,15,1,15,5,15,495,8,15,10,15,12,15,498,9,15,1,15,1,15,1,16,
        1,16,5,16,504,8,16,10,16,12,16,507,9,16,1,16,1,16,1,17,1,17,5,17,
        513,8,17,10,17,12,17,516,9,17,1,17,1,17,1,18,1,18,5,18,522,8,18,
        10,18,12,18,525,9,18,1,18,1,18,1,19,1,19,5,19,531,8,19,10,19,12,
        19,534,9,19,1,19,1,19,1,20,1,20,5,20,540,8,20,10,20,12,20,543,9,
        20,1,20,1,20,1,21,1,21,5,21,549,8,21,10,21,12,21,552,9,21,1,21,1,
        21,1,22,1,22,5,22,558,8,22,10,22,12,22,561,9,22,1,22,1,22,1,23,1,
        23,5,23,567,8,23,10,23,12,23,570,9,23,1,23,1,23,1,24,1,24,5,24,576,
        8,24,10,24,12,24,579,9,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,
        1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,598,8,25,1,25,
        1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,
        1,25,1,25,1,25,1,25,1,25,3,25,619,8,25,1,25,1,25,1,25,1,25,1,25,
        1,25,1,25,1,25,1,25,1,25,1,25,3,25,632,8,25,1,25,1,25,1,25,1,25,
        1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,
        1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,662,
        8,25,1,25,3,25,665,8,25,1,26,1,26,1,26,1,26,1,26,3,26,672,8,26,1,
        26,3,26,675,8,26,1,26,5,26,678,8,26,10,26,12,26,681,9,26,1,26,1,
        26,3,26,685,8,26,1,26,1,26,1,26,3,26,690,8,26,1,26,3,26,693,8,26,
        1,26,3,26,696,8,26,5,26,698,8,26,10,26,12,26,701,9,26,1,27,1,27,
        3,27,705,8,27,1,27,1,27,1,27,3,27,710,8,27,1,27,1,27,1,27,1,27,1,
        27,3,27,717,8,27,1,28,1,28,3,28,721,8,28,1,28,1,28,1,28,3,28,726,
        8,28,1,28,1,28,1,28,3,28,731,8,28,1,28,1,28,1,28,3,28,736,8,28,1,
        28,1,28,1,28,3,28,741,8,28,1,28,1,28,1,28,3,28,746,8,28,1,28,1,28,
        1,28,3,28,751,8,28,1,28,1,28,3,28,755,8,28,1,29,1,29,1,29,1,29,1,
        29,3,29,762,8,29,1,29,1,29,1,29,1,29,3,29,768,8,29,1,29,1,29,3,29,
        772,8,29,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,
        1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,794,8,31,1,31,
        1,31,1,31,3,31,799,8,31,1,31,1,31,1,31,3,31,804,8,31,1,31,1,31,1,
        31,1,31,1,31,3,31,811,8,31,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,
        32,1,32,3,32,822,8,32,1,32,3,32,825,8,32,1,33,1,33,1,33,1,33,1,33,
        1,33,3,33,833,8,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,
        1,33,1,33,1,33,3,33,847,8,33,1,33,1,33,1,33,3,33,852,8,33,1,33,1,
        33,1,33,3,33,857,8,33,1,33,1,33,1,33,1,33,1,33,3,33,864,8,33,1,34,
        1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,
        1,34,3,34,881,8,34,1,35,1,35,1,35,3,35,886,8,35,1,35,1,35,1,35,1,
        35,3,35,892,8,35,1,35,1,35,1,35,1,35,1,35,3,35,899,8,35,1,35,1,35,
        1,35,3,35,904,8,35,1,35,1,35,1,35,1,35,1,35,3,35,911,8,35,1,36,1,
        36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,36,923,8,36,1,37,1,
        37,1,37,1,37,1,37,1,37,3,37,931,8,37,1,37,1,37,1,37,3,37,936,8,37,
        1,37,1,37,1,37,1,37,1,37,3,37,943,8,37,1,38,1,38,1,38,1,38,1,38,
        3,38,950,8,38,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,
        3,39,962,8,39,1,39,1,39,1,39,3,39,967,8,39,1,39,1,39,1,39,3,39,972,
        8,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,981,8,39,1,40,1,40,
        1,40,1,40,1,40,1,40,1,40,3,40,990,8,40,1,41,1,41,1,41,1,41,1,41,
        3,41,997,8,41,1,42,1,42,5,42,1001,8,42,10,42,12,42,1004,9,42,1,42,
        1,42,1,43,1,43,3,43,1010,8,43,1,43,1,43,1,43,3,43,1015,8,43,1,43,
        3,43,1018,8,43,1,44,1,44,1,44,3,44,1023,8,44,1,44,1,44,1,44,3,44,
        1028,8,44,1,44,1,44,1,44,3,44,1033,8,44,1,44,1,44,3,44,1037,8,44,
        1,44,1,44,1,44,1,44,3,44,1043,8,44,1,44,1,44,3,44,1047,8,44,1,44,
        1,44,3,44,1051,8,44,1,44,3,44,1054,8,44,3,44,1056,8,44,1,44,1,44,
        3,44,1060,8,44,1,45,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,
        1,46,1,46,1,46,1,46,3,46,1076,8,46,1,46,1,46,1,46,3,46,1081,8,46,
        1,46,1,46,1,46,1,46,1,46,1,46,3,46,1089,8,46,1,46,1,46,1,46,1,46,
        1,46,1,46,3,46,1097,8,46,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,
        1,48,1,48,1,48,1,48,1,48,1,48,1,48,3,48,1114,8,48,1,48,1,48,1,48,
        1,48,1,48,1,48,3,48,1122,8,48,1,48,1,48,3,48,1126,8,48,1,48,1,48,
        1,48,3,48,1131,8,48,1,48,1,48,1,48,3,48,1136,8,48,1,48,1,48,1,48,
        1,48,1,48,1,48,3,48,1144,8,48,1,48,3,48,1147,8,48,1,49,1,49,1,49,
        1,49,1,49,1,49,1,49,1,49,1,49,1,49,3,49,1159,8,49,1,49,1,49,1,49,
        1,49,1,49,3,49,1166,8,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,
        1,50,1,50,1,50,3,50,1179,8,50,1,50,1,50,1,50,3,50,1184,8,50,1,50,
        1,50,1,50,1,50,1,50,1,50,1,50,3,50,1193,8,50,1,50,1,50,1,50,1,50,
        1,50,1,50,1,50,3,50,1202,8,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,
        1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,
        1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,1235,
        8,53,1,53,1,53,3,53,1239,8,53,1,53,1,53,1,53,1,53,1,53,1,53,3,53,
        1247,8,53,1,53,1,53,1,53,3,53,1252,8,53,1,54,1,54,1,54,3,54,1257,
        8,54,1,54,1,54,3,54,1261,8,54,1,55,1,55,1,55,1,55,1,56,1,56,1,56,
        1,56,1,56,1,56,3,56,1273,8,56,1,56,1,56,1,57,1,57,1,57,1,58,1,58,
        1,58,1,59,1,59,1,59,1,60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,
        1,61,1,61,3,61,1297,8,61,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,
        1,63,3,63,1308,8,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,
        3,63,1319,8,63,1,63,1,63,1,63,1,63,3,63,1325,8,63,1,63,1,63,1,63,
        1,63,3,63,1331,8,63,1,63,1,63,3,63,1335,8,63,1,63,1,63,1,63,1,63,
        1,63,1,63,1,63,1,63,1,63,3,63,1346,8,63,1,63,1,63,1,63,1,63,3,63,
        1352,8,63,1,63,1,63,1,63,1,63,3,63,1358,8,63,1,63,1,63,1,63,1,63,
        1,63,3,63,1365,8,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,3,63,
        1375,8,63,1,63,1,63,1,63,1,63,3,63,1381,8,63,1,63,1,63,1,63,1,63,
        3,63,1387,8,63,1,63,1,63,1,63,3,63,1392,8,63,1,63,1,63,1,63,1,63,
        1,63,1,63,1,63,3,63,1401,8,63,1,63,3,63,1404,8,63,1,63,3,63,1407,
        8,63,1,63,1,63,3,63,1411,8,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,
        1,64,1,64,1,64,3,64,1423,8,64,1,64,1,64,1,64,1,64,1,64,3,64,1430,
        8,64,1,64,1,64,1,64,1,64,1,64,3,64,1437,8,64,1,65,1,65,1,65,1,65,
        3,65,1443,8,65,1,65,1,65,1,65,3,65,1448,8,65,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,1,67,1,67,1,67,3,67,
        1466,8,67,1,67,1,67,1,67,3,67,1471,8,67,1,67,1,67,1,67,3,67,1476,
        8,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,1485,8,67,1,68,1,68,
        1,68,1,68,1,68,1,68,1,68,1,68,1,68,3,68,1496,8,68,1,69,1,69,1,69,
        1,69,1,69,1,69,1,69,1,69,3,69,1506,8,69,1,69,1,69,1,69,1,69,1,69,
        1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,
        1,69,1,69,1,69,1,69,1,69,1,69,3,69,1532,8,69,1,69,1,69,1,69,1,69,
        1,69,1,69,3,69,1540,8,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,
        1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,3,69,1559,8,69,1,70,
        1,70,1,70,1,70,1,70,1,70,1,71,1,71,1,71,1,71,1,71,3,71,1572,8,71,
        1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,
        1,71,1,71,3,71,1589,8,71,1,71,1,71,1,71,3,71,1594,8,71,1,71,1,71,
        1,71,3,71,1599,8,71,1,71,1,71,1,71,1,71,1,71,3,71,1606,8,71,1,72,
        1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,1,72,3,72,1618,8,72,1,72,
        3,72,1621,8,72,1,73,1,73,1,73,1,73,3,73,1627,8,73,1,73,1,73,1,73,
        1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,3,73,1643,
        8,73,1,73,1,73,1,73,3,73,1648,8,73,1,73,1,73,1,73,3,73,1653,8,73,
        1,73,1,73,1,73,1,73,1,73,3,73,1660,8,73,1,74,1,74,1,74,1,74,1,74,
        1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,3,74,1675,8,74,1,74,1,74,
        1,74,3,74,1680,8,74,1,74,1,74,1,74,3,74,1685,8,74,1,74,1,74,1,74,
        1,74,1,74,3,74,1692,8,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,
        1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
        1,76,1,76,1,76,3,76,1718,8,76,1,76,1,76,1,76,3,76,1723,8,76,1,76,
        1,76,1,76,3,76,1728,8,76,1,76,1,76,1,76,1,76,1,76,1,76,3,76,1736,
        8,76,1,76,1,76,1,76,1,76,1,76,1,76,3,76,1744,8,76,1,77,1,77,1,77,
        1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,77,3,77,1759,8,77,
        1,78,1,78,1,78,1,78,1,78,3,78,1766,8,78,1,78,1,78,1,78,1,78,1,78,
        3,78,1773,8,78,1,78,1,78,1,78,3,78,1778,8,78,1,78,1,78,1,78,1,78,
        3,78,1784,8,78,1,78,1,78,1,78,1,78,1,78,3,78,1791,8,78,1,78,1,78,
        1,78,1,78,1,78,3,78,1798,8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,
        1,78,1,78,3,78,1809,8,78,1,78,1,78,3,78,1813,8,78,1,79,1,79,1,79,
        1,79,1,79,3,79,1820,8,79,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,
        1,80,1,80,1,80,3,80,1833,8,80,1,80,1,80,1,80,3,80,1838,8,80,1,80,
        1,80,1,80,1,80,1,80,1,80,3,80,1846,8,80,1,80,1,80,1,80,1,80,1,80,
        1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,3,80,1863,8,80,
        1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,3,81,1873,8,81,1,81,3,81,
        1876,8,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,
        1888,8,82,1,82,1,82,1,82,3,82,1893,8,82,1,82,1,82,1,82,1,82,1,82,
        1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1909,8,82,1,83,
        1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1920,8,83,1,84,1,84,
        1,84,1,84,3,84,1926,8,84,1,84,1,84,1,84,3,84,1931,8,84,1,84,1,84,
        1,84,1,84,1,84,3,84,1938,8,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,
        1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1955,8,86,1,86,1,86,
        1,86,3,86,1960,8,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,1969,
        8,86,1,87,1,87,1,87,1,87,1,87,1,87,3,87,1977,8,87,1,88,1,88,1,88,
        1,88,1,88,3,88,1984,8,88,1,88,1,88,1,88,3,88,1989,8,88,1,88,1,88,
        1,88,1,88,1,88,3,88,1996,8,88,1,89,1,89,1,89,1,89,1,89,1,90,1,90,
        1,90,1,90,3,90,2007,8,90,1,90,1,90,1,90,3,90,2012,8,90,1,90,1,90,
        1,90,3,90,2017,8,90,1,90,1,90,1,90,3,90,2022,8,90,1,90,1,90,1,90,
        3,90,2027,8,90,1,90,1,90,1,90,3,90,2032,8,90,1,90,1,90,1,90,3,90,
        2037,8,90,1,90,1,90,1,90,3,90,2042,8,90,1,90,1,90,1,90,3,90,2047,
        8,90,1,90,1,90,1,90,3,90,2052,8,90,1,90,1,90,1,90,3,90,2057,8,90,
        1,90,1,90,1,90,3,90,2062,8,90,1,90,1,90,1,90,3,90,2067,8,90,1,90,
        3,90,2070,8,90,1,91,1,91,1,91,1,91,1,92,1,92,1,92,5,92,2079,8,92,
        10,92,12,92,2082,9,92,1,92,1,92,1,93,1,93,5,93,2088,8,93,10,93,12,
        93,2091,9,93,1,93,1,93,1,93,3,93,2096,8,93,1,94,1,94,3,94,2100,8,
        94,1,94,1,94,1,94,3,94,2105,8,94,1,94,1,94,1,94,3,94,2110,8,94,1,
        94,3,94,2113,8,94,1,95,1,95,1,95,1,95,1,96,1,96,1,96,5,96,2122,8,
        96,10,96,12,96,2125,9,96,1,97,1,97,1,97,5,97,2130,8,97,10,97,12,
        97,2133,9,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,
        98,1,98,3,98,2147,8,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,
        98,1,98,1,98,1,98,1,98,1,98,3,98,2163,8,98,1,98,3,98,2166,8,98,1,
        98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,3,98,2177,8,98,1,98,1,
        98,1,98,3,98,2182,8,98,1,98,3,98,2185,8,98,1,98,1,98,1,98,1,98,1,
        98,1,98,3,98,2193,8,98,1,98,1,98,3,98,2197,8,98,1,98,1,98,1,98,1,
        98,1,98,1,98,1,98,1,98,1,98,3,98,2208,8,98,1,98,1,98,3,98,2212,8,
        98,1,98,1,98,3,98,2216,8,98,1,98,3,98,2219,8,98,1,98,1,98,1,98,1,
        98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,3,98,2232,8,98,1,98,3,98,2235,
        8,98,1,98,1,98,1,98,1,98,1,98,3,98,2242,8,98,1,98,3,98,2245,8,98,
        1,98,1,98,1,98,1,98,1,98,3,98,2252,8,98,1,98,1,98,1,98,3,98,2257,
        8,98,1,98,3,98,2260,8,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,
        1,98,1,98,1,98,1,98,3,98,2274,8,98,1,98,1,98,1,98,1,98,1,98,1,98,
        5,98,2282,8,98,10,98,12,98,2285,9,98,1,99,1,99,1,100,1,100,1,101,
        1,101,1,102,1,102,1,103,1,103,3,103,2297,8,103,1,103,1,103,1,104,
        1,104,1,105,1,105,1,105,5,105,2306,8,105,10,105,12,105,2309,9,105,
        1,105,3,105,2312,8,105,3,105,2314,8,105,1,105,1,105,5,105,2318,8,
        105,10,105,12,105,2321,9,105,1,105,1,105,1,106,1,106,1,106,1,106,
        1,107,1,107,1,107,1,107,1,107,1,107,3,107,2335,8,107,1,108,1,108,
        1,108,3,108,2340,8,108,1,109,1,109,1,109,3,109,2345,8,109,1,110,
        1,110,1,110,1,110,1,110,1,110,1,110,3,110,2354,8,110,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,5,111,2416,8,111,10,111,12,111,2419,9,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        5,111,2433,8,111,10,111,12,111,2436,9,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,
        3,111,2475,8,111,1,112,1,112,1,112,1,112,1,112,1,113,1,113,1,113,
        1,113,1,113,1,113,1,114,1,114,1,114,3,114,2491,8,114,1,115,1,115,
        3,115,2495,8,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,
        1,115,1,115,3,115,2507,8,115,1,115,1,115,1,116,1,116,5,116,2513,
        8,116,10,116,12,116,2516,9,116,1,116,1,116,1,117,1,117,1,117,1,117,
        1,117,1,117,1,117,1,117,1,117,1,117,3,117,2530,8,117,1,117,1,117,
        1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,
        3,117,2545,8,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,
        1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,
        1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,3,117,2575,
        8,117,1,118,1,118,1,118,1,118,1,118,5,118,2582,8,118,10,118,12,118,
        2585,9,118,1,118,5,118,2588,8,118,10,118,12,118,2591,9,118,1,118,
        5,118,2594,8,118,10,118,12,118,2597,9,118,3,118,2599,8,118,1,118,
        1,118,1,118,1,118,1,118,1,118,5,118,2607,8,118,10,118,12,118,2610,
        9,118,1,118,1,118,1,118,1,118,1,119,1,119,1,119,1,119,1,119,5,119,
        2621,8,119,10,119,12,119,2624,9,119,1,119,5,119,2627,8,119,10,119,
        12,119,2630,9,119,1,119,5,119,2633,8,119,10,119,12,119,2636,9,119,
        3,119,2638,8,119,1,119,1,119,1,119,1,119,1,119,1,119,5,119,2646,
        8,119,10,119,12,119,2649,9,119,1,119,1,119,1,119,1,119,1,120,1,120,
        1,120,1,120,1,120,5,120,2660,8,120,10,120,12,120,2663,9,120,1,120,
        5,120,2666,8,120,10,120,12,120,2669,9,120,1,120,5,120,2672,8,120,
        10,120,12,120,2675,9,120,3,120,2677,8,120,1,120,1,120,1,120,1,120,
        1,120,1,120,5,120,2685,8,120,10,120,12,120,2688,9,120,1,120,1,120,
        1,120,1,120,1,121,1,121,1,121,1,121,1,121,5,121,2699,8,121,10,121,
        12,121,2702,9,121,1,121,5,121,2705,8,121,10,121,12,121,2708,9,121,
        1,121,5,121,2711,8,121,10,121,12,121,2714,9,121,3,121,2716,8,121,
        1,121,1,121,1,121,1,121,1,121,1,121,5,121,2724,8,121,10,121,12,121,
        2727,9,121,1,121,1,121,1,121,1,121,1,122,1,122,1,122,1,122,1,122,
        5,122,2738,8,122,10,122,12,122,2741,9,122,1,122,5,122,2744,8,122,
        10,122,12,122,2747,9,122,1,122,5,122,2750,8,122,10,122,12,122,2753,
        9,122,3,122,2755,8,122,1,122,1,122,1,122,1,122,1,122,1,122,5,122,
        2763,8,122,10,122,12,122,2766,9,122,1,122,1,122,1,122,1,122,1,123,
        1,123,1,123,1,123,1,123,5,123,2777,8,123,10,123,12,123,2780,9,123,
        1,123,5,123,2783,8,123,10,123,12,123,2786,9,123,1,123,5,123,2789,
        8,123,10,123,12,123,2792,9,123,3,123,2794,8,123,1,123,1,123,1,123,
        1,123,1,123,1,123,5,123,2802,8,123,10,123,12,123,2805,9,123,1,123,
        1,123,1,123,1,123,1,124,1,124,1,124,1,124,1,124,5,124,2816,8,124,
        10,124,12,124,2819,9,124,1,124,5,124,2822,8,124,10,124,12,124,2825,
        9,124,1,124,5,124,2828,8,124,10,124,12,124,2831,9,124,3,124,2833,
        8,124,1,124,1,124,1,124,1,124,1,124,1,124,5,124,2841,8,124,10,124,
        12,124,2844,9,124,1,124,1,124,1,124,1,124,1,125,1,125,1,125,1,125,
        1,125,5,125,2855,8,125,10,125,12,125,2858,9,125,1,125,5,125,2861,
        8,125,10,125,12,125,2864,9,125,1,125,5,125,2867,8,125,10,125,12,
        125,2870,9,125,3,125,2872,8,125,1,125,1,125,1,125,1,125,1,125,1,
        125,5,125,2880,8,125,10,125,12,125,2883,9,125,1,125,1,125,1,125,
        1,125,1,126,1,126,1,126,1,126,1,126,5,126,2894,8,126,10,126,12,126,
        2897,9,126,1,126,5,126,2900,8,126,10,126,12,126,2903,9,126,1,126,
        5,126,2906,8,126,10,126,12,126,2909,9,126,3,126,2911,8,126,1,126,
        1,126,1,126,1,126,1,126,1,126,1,126,5,126,2920,8,126,10,126,12,126,
        2923,9,126,1,126,1,126,1,126,1,126,1,127,1,127,1,127,1,127,1,127,
        5,127,2934,8,127,10,127,12,127,2937,9,127,1,127,5,127,2940,8,127,
        10,127,12,127,2943,9,127,1,127,5,127,2946,8,127,10,127,12,127,2949,
        9,127,3,127,2951,8,127,1,127,1,127,1,127,1,127,1,127,1,127,5,127,
        2959,8,127,10,127,12,127,2962,9,127,1,127,1,127,1,127,1,127,1,128,
        1,128,1,128,1,128,1,128,5,128,2973,8,128,10,128,12,128,2976,9,128,
        1,128,5,128,2979,8,128,10,128,12,128,2982,9,128,1,128,5,128,2985,
        8,128,10,128,12,128,2988,9,128,3,128,2990,8,128,1,128,1,128,1,128,
        1,128,1,128,1,128,5,128,2998,8,128,10,128,12,128,3001,9,128,1,128,
        1,128,1,128,1,128,1,129,1,129,1,129,1,129,1,129,5,129,3012,8,129,
        10,129,12,129,3015,9,129,1,129,5,129,3018,8,129,10,129,12,129,3021,
        9,129,1,129,5,129,3024,8,129,10,129,12,129,3027,9,129,3,129,3029,
        8,129,1,129,1,129,1,129,1,129,1,129,1,129,5,129,3037,8,129,10,129,
        12,129,3040,9,129,1,129,1,129,1,129,1,129,1,129,0,1,196,130,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,0,14,1,0,44,45,1,0,33,34,2,0,38,38,96,96,1,0,202,203,2,0,
        195,195,204,204,3,0,195,195,197,197,214,214,2,0,195,195,197,197,
        5,0,3,3,37,38,96,96,180,181,202,202,1,0,170,171,1,0,245,249,1,0,
        284,290,2,0,176,176,195,195,2,0,38,38,181,181,2,0,19,19,184,184,
        3669,0,319,1,0,0,0,2,324,1,0,0,0,4,334,1,0,0,0,6,385,1,0,0,0,8,388,
        1,0,0,0,10,400,1,0,0,0,12,411,1,0,0,0,14,420,1,0,0,0,16,429,1,0,
        0,0,18,438,1,0,0,0,20,447,1,0,0,0,22,456,1,0,0,0,24,465,1,0,0,0,
        26,474,1,0,0,0,28,483,1,0,0,0,30,492,1,0,0,0,32,501,1,0,0,0,34,510,
        1,0,0,0,36,519,1,0,0,0,38,528,1,0,0,0,40,537,1,0,0,0,42,546,1,0,
        0,0,44,555,1,0,0,0,46,564,1,0,0,0,48,573,1,0,0,0,50,664,1,0,0,0,
        52,666,1,0,0,0,54,716,1,0,0,0,56,754,1,0,0,0,58,771,1,0,0,0,60,773,
        1,0,0,0,62,810,1,0,0,0,64,812,1,0,0,0,66,863,1,0,0,0,68,865,1,0,
        0,0,70,910,1,0,0,0,72,912,1,0,0,0,74,942,1,0,0,0,76,944,1,0,0,0,
        78,980,1,0,0,0,80,982,1,0,0,0,82,996,1,0,0,0,84,998,1,0,0,0,86,1017,
        1,0,0,0,88,1059,1,0,0,0,90,1061,1,0,0,0,92,1096,1,0,0,0,94,1098,
        1,0,0,0,96,1146,1,0,0,0,98,1148,1,0,0,0,100,1201,1,0,0,0,102,1203,
        1,0,0,0,104,1212,1,0,0,0,106,1251,1,0,0,0,108,1253,1,0,0,0,110,1262,
        1,0,0,0,112,1266,1,0,0,0,114,1276,1,0,0,0,116,1279,1,0,0,0,118,1282,
        1,0,0,0,120,1285,1,0,0,0,122,1288,1,0,0,0,124,1298,1,0,0,0,126,1410,
        1,0,0,0,128,1412,1,0,0,0,130,1447,1,0,0,0,132,1449,1,0,0,0,134,1484,
        1,0,0,0,136,1486,1,0,0,0,138,1558,1,0,0,0,140,1560,1,0,0,0,142,1605,
        1,0,0,0,144,1607,1,0,0,0,146,1659,1,0,0,0,148,1691,1,0,0,0,150,1693,
        1,0,0,0,152,1743,1,0,0,0,154,1745,1,0,0,0,156,1812,1,0,0,0,158,1814,
        1,0,0,0,160,1862,1,0,0,0,162,1864,1,0,0,0,164,1908,1,0,0,0,166,1910,
        1,0,0,0,168,1937,1,0,0,0,170,1939,1,0,0,0,172,1968,1,0,0,0,174,1970,
        1,0,0,0,176,1995,1,0,0,0,178,1997,1,0,0,0,180,2069,1,0,0,0,182,2071,
        1,0,0,0,184,2075,1,0,0,0,186,2095,1,0,0,0,188,2112,1,0,0,0,190,2114,
        1,0,0,0,192,2118,1,0,0,0,194,2126,1,0,0,0,196,2273,1,0,0,0,198,2286,
        1,0,0,0,200,2288,1,0,0,0,202,2290,1,0,0,0,204,2292,1,0,0,0,206,2294,
        1,0,0,0,208,2300,1,0,0,0,210,2302,1,0,0,0,212,2324,1,0,0,0,214,2334,
        1,0,0,0,216,2336,1,0,0,0,218,2341,1,0,0,0,220,2353,1,0,0,0,222,2474,
        1,0,0,0,224,2476,1,0,0,0,226,2481,1,0,0,0,228,2487,1,0,0,0,230,2492,
        1,0,0,0,232,2510,1,0,0,0,234,2574,1,0,0,0,236,2576,1,0,0,0,238,2615,
        1,0,0,0,240,2654,1,0,0,0,242,2693,1,0,0,0,244,2732,1,0,0,0,246,2771,
        1,0,0,0,248,2810,1,0,0,0,250,2849,1,0,0,0,252,2888,1,0,0,0,254,2928,
        1,0,0,0,256,2967,1,0,0,0,258,3006,1,0,0,0,260,318,3,2,1,0,261,318,
        3,4,2,0,262,318,3,6,3,0,263,318,3,8,4,0,264,318,3,10,5,0,265,318,
        3,12,6,0,266,318,3,14,7,0,267,318,3,16,8,0,268,318,3,18,9,0,269,
        318,3,20,10,0,270,318,3,22,11,0,271,318,3,24,12,0,272,318,3,26,13,
        0,273,318,3,28,14,0,274,318,3,30,15,0,275,318,3,32,16,0,276,318,
        3,34,17,0,277,318,3,36,18,0,278,318,3,38,19,0,279,318,3,40,20,0,
        280,318,3,42,21,0,281,318,3,44,22,0,282,318,3,46,23,0,283,318,3,
        48,24,0,284,318,3,184,92,0,285,318,3,206,103,0,286,318,3,210,105,
        0,287,318,3,212,106,0,288,318,3,226,113,0,289,318,3,230,115,0,290,
        318,3,232,116,0,291,318,3,236,118,0,292,318,3,238,119,0,293,318,
        3,240,120,0,294,318,3,254,127,0,295,318,3,256,128,0,296,318,3,244,
        122,0,297,318,3,242,121,0,298,318,3,246,123,0,299,318,3,248,124,
        0,300,318,3,250,125,0,301,318,3,252,126,0,302,318,3,52,26,0,303,
        318,3,60,30,0,304,318,3,64,32,0,305,318,3,82,41,0,306,318,3,90,45,
        0,307,318,3,178,89,0,308,318,3,182,91,0,309,318,3,98,49,0,310,318,
        3,94,47,0,311,318,3,132,66,0,312,318,3,144,72,0,313,318,3,158,79,
        0,314,318,3,162,81,0,315,318,3,108,54,0,316,318,3,234,117,0,317,
        260,1,0,0,0,317,261,1,0,0,0,317,262,1,0,0,0,317,263,1,0,0,0,317,
        264,1,0,0,0,317,265,1,0,0,0,317,266,1,0,0,0,317,267,1,0,0,0,317,
        268,1,0,0,0,317,269,1,0,0,0,317,270,1,0,0,0,317,271,1,0,0,0,317,
        272,1,0,0,0,317,273,1,0,0,0,317,274,1,0,0,0,317,275,1,0,0,0,317,
        276,1,0,0,0,317,277,1,0,0,0,317,278,1,0,0,0,317,279,1,0,0,0,317,
        280,1,0,0,0,317,281,1,0,0,0,317,282,1,0,0,0,317,283,1,0,0,0,317,
        284,1,0,0,0,317,285,1,0,0,0,317,286,1,0,0,0,317,287,1,0,0,0,317,
        288,1,0,0,0,317,289,1,0,0,0,317,290,1,0,0,0,317,291,1,0,0,0,317,
        292,1,0,0,0,317,293,1,0,0,0,317,294,1,0,0,0,317,295,1,0,0,0,317,
        296,1,0,0,0,317,297,1,0,0,0,317,298,1,0,0,0,317,299,1,0,0,0,317,
        300,1,0,0,0,317,301,1,0,0,0,317,302,1,0,0,0,317,303,1,0,0,0,317,
        304,1,0,0,0,317,305,1,0,0,0,317,306,1,0,0,0,317,307,1,0,0,0,317,
        308,1,0,0,0,317,309,1,0,0,0,317,310,1,0,0,0,317,311,1,0,0,0,317,
        312,1,0,0,0,317,313,1,0,0,0,317,314,1,0,0,0,317,315,1,0,0,0,317,
        316,1,0,0,0,318,321,1,0,0,0,319,317,1,0,0,0,319,320,1,0,0,0,320,
        322,1,0,0,0,321,319,1,0,0,0,322,323,5,0,0,1,323,1,1,0,0,0,324,328,
        5,3,0,0,325,327,3,50,25,0,326,325,1,0,0,0,327,330,1,0,0,0,328,326,
        1,0,0,0,328,329,1,0,0,0,329,331,1,0,0,0,330,328,1,0,0,0,331,332,
        5,2,0,0,332,3,1,0,0,0,333,335,5,37,0,0,334,333,1,0,0,0,334,335,1,
        0,0,0,335,336,1,0,0,0,336,340,5,38,0,0,337,339,3,58,29,0,338,337,
        1,0,0,0,339,342,1,0,0,0,340,338,1,0,0,0,340,341,1,0,0,0,341,343,
        1,0,0,0,342,340,1,0,0,0,343,344,5,2,0,0,344,5,1,0,0,0,345,349,5,
        41,0,0,346,348,3,62,31,0,347,346,1,0,0,0,348,351,1,0,0,0,349,347,
        1,0,0,0,349,350,1,0,0,0,350,352,1,0,0,0,351,349,1,0,0,0,352,386,
        5,2,0,0,353,357,7,0,0,0,354,356,3,66,33,0,355,354,1,0,0,0,356,359,
        1,0,0,0,357,355,1,0,0,0,357,358,1,0,0,0,358,360,1,0,0,0,359,357,
        1,0,0,0,360,386,5,2,0,0,361,365,5,48,0,0,362,364,3,70,35,0,363,362,
        1,0,0,0,364,367,1,0,0,0,365,363,1,0,0,0,365,366,1,0,0,0,366,368,
        1,0,0,0,367,365,1,0,0,0,368,386,5,2,0,0,369,373,5,51,0,0,370,372,
        3,74,37,0,371,370,1,0,0,0,372,375,1,0,0,0,373,371,1,0,0,0,373,374,
        1,0,0,0,374,376,1,0,0,0,375,373,1,0,0,0,376,386,5,2,0,0,377,381,
        5,52,0,0,378,380,3,78,39,0,379,378,1,0,0,0,380,383,1,0,0,0,381,379,
        1,0,0,0,381,382,1,0,0,0,382,384,1,0,0,0,383,381,1,0,0,0,384,386,
        5,2,0,0,385,345,1,0,0,0,385,353,1,0,0,0,385,361,1,0,0,0,385,369,
        1,0,0,0,385,377,1,0,0,0,386,7,1,0,0,0,387,389,5,37,0,0,388,387,1,
        0,0,0,388,389,1,0,0,0,389,390,1,0,0,0,390,394,5,53,0,0,391,393,3,
        82,41,0,392,391,1,0,0,0,393,396,1,0,0,0,394,392,1,0,0,0,394,395,
        1,0,0,0,395,397,1,0,0,0,396,394,1,0,0,0,397,398,5,2,0,0,398,9,1,
        0,0,0,399,401,5,37,0,0,400,399,1,0,0,0,400,401,1,0,0,0,401,402,1,
        0,0,0,402,406,5,58,0,0,403,405,3,88,44,0,404,403,1,0,0,0,405,408,
        1,0,0,0,406,404,1,0,0,0,406,407,1,0,0,0,407,409,1,0,0,0,408,406,
        1,0,0,0,409,410,5,2,0,0,410,11,1,0,0,0,411,415,5,61,0,0,412,414,
        3,92,46,0,413,412,1,0,0,0,414,417,1,0,0,0,415,413,1,0,0,0,415,416,
        1,0,0,0,416,418,1,0,0,0,417,415,1,0,0,0,418,419,5,2,0,0,419,13,1,
        0,0,0,420,424,5,65,0,0,421,423,3,96,48,0,422,421,1,0,0,0,423,426,
        1,0,0,0,424,422,1,0,0,0,424,425,1,0,0,0,425,427,1,0,0,0,426,424,
        1,0,0,0,427,428,5,2,0,0,428,15,1,0,0,0,429,433,5,67,0,0,430,432,
        3,100,50,0,431,430,1,0,0,0,432,435,1,0,0,0,433,431,1,0,0,0,433,434,
        1,0,0,0,434,436,1,0,0,0,435,433,1,0,0,0,436,437,5,2,0,0,437,17,1,
        0,0,0,438,442,5,71,0,0,439,441,3,106,53,0,440,439,1,0,0,0,441,444,
        1,0,0,0,442,440,1,0,0,0,442,443,1,0,0,0,443,445,1,0,0,0,444,442,
        1,0,0,0,445,446,5,2,0,0,446,19,1,0,0,0,447,451,5,79,0,0,448,450,
        3,126,63,0,449,448,1,0,0,0,450,453,1,0,0,0,451,449,1,0,0,0,451,452,
        1,0,0,0,452,454,1,0,0,0,453,451,1,0,0,0,454,455,5,2,0,0,455,21,1,
        0,0,0,456,460,5,86,0,0,457,459,3,130,65,0,458,457,1,0,0,0,459,462,
        1,0,0,0,460,458,1,0,0,0,460,461,1,0,0,0,461,463,1,0,0,0,462,460,
        1,0,0,0,463,464,5,2,0,0,464,23,1,0,0,0,465,469,5,87,0,0,466,468,
        3,134,67,0,467,466,1,0,0,0,468,471,1,0,0,0,469,467,1,0,0,0,469,470,
        1,0,0,0,470,472,1,0,0,0,471,469,1,0,0,0,472,473,5,2,0,0,473,25,1,
        0,0,0,474,478,5,88,0,0,475,477,3,138,69,0,476,475,1,0,0,0,477,480,
        1,0,0,0,478,476,1,0,0,0,478,479,1,0,0,0,479,481,1,0,0,0,480,478,
        1,0,0,0,481,482,5,2,0,0,482,27,1,0,0,0,483,487,5,92,0,0,484,486,
        3,142,71,0,485,484,1,0,0,0,486,489,1,0,0,0,487,485,1,0,0,0,487,488,
        1,0,0,0,488,490,1,0,0,0,489,487,1,0,0,0,490,491,5,2,0,0,491,29,1,
        0,0,0,492,496,5,94,0,0,493,495,3,146,73,0,494,493,1,0,0,0,495,498,
        1,0,0,0,496,494,1,0,0,0,496,497,1,0,0,0,497,499,1,0,0,0,498,496,
        1,0,0,0,499,500,5,2,0,0,500,31,1,0,0,0,501,505,5,95,0,0,502,504,
        3,148,74,0,503,502,1,0,0,0,504,507,1,0,0,0,505,503,1,0,0,0,505,506,
        1,0,0,0,506,508,1,0,0,0,507,505,1,0,0,0,508,509,5,2,0,0,509,33,1,
        0,0,0,510,514,5,96,0,0,511,513,3,152,76,0,512,511,1,0,0,0,513,516,
        1,0,0,0,514,512,1,0,0,0,514,515,1,0,0,0,515,517,1,0,0,0,516,514,
        1,0,0,0,517,518,5,2,0,0,518,35,1,0,0,0,519,523,5,98,0,0,520,522,
        3,156,78,0,521,520,1,0,0,0,522,525,1,0,0,0,523,521,1,0,0,0,523,524,
        1,0,0,0,524,526,1,0,0,0,525,523,1,0,0,0,526,527,5,2,0,0,527,37,1,
        0,0,0,528,532,5,103,0,0,529,531,3,160,80,0,530,529,1,0,0,0,531,534,
        1,0,0,0,532,530,1,0,0,0,532,533,1,0,0,0,533,535,1,0,0,0,534,532,
        1,0,0,0,535,536,5,2,0,0,536,39,1,0,0,0,537,541,5,114,0,0,538,540,
        3,164,82,0,539,538,1,0,0,0,540,543,1,0,0,0,541,539,1,0,0,0,541,542,
        1,0,0,0,542,544,1,0,0,0,543,541,1,0,0,0,544,545,5,2,0,0,545,41,1,
        0,0,0,546,550,5,115,0,0,547,549,3,168,84,0,548,547,1,0,0,0,549,552,
        1,0,0,0,550,548,1,0,0,0,550,551,1,0,0,0,551,553,1,0,0,0,552,550,
        1,0,0,0,553,554,5,2,0,0,554,43,1,0,0,0,555,559,5,116,0,0,556,558,
        3,172,86,0,557,556,1,0,0,0,558,561,1,0,0,0,559,557,1,0,0,0,559,560,
        1,0,0,0,560,562,1,0,0,0,561,559,1,0,0,0,562,563,5,2,0,0,563,45,1,
        0,0,0,564,568,5,118,0,0,565,567,3,176,88,0,566,565,1,0,0,0,567,570,
        1,0,0,0,568,566,1,0,0,0,568,569,1,0,0,0,569,571,1,0,0,0,570,568,
        1,0,0,0,571,572,5,2,0,0,572,47,1,0,0,0,573,577,5,119,0,0,574,576,
        3,180,90,0,575,574,1,0,0,0,576,579,1,0,0,0,577,575,1,0,0,0,577,578,
        1,0,0,0,578,580,1,0,0,0,579,577,1,0,0,0,580,581,5,2,0,0,581,49,1,
        0,0,0,582,665,3,52,26,0,583,665,3,236,118,0,584,585,5,5,0,0,585,
        586,3,208,104,0,586,587,3,202,101,0,587,665,1,0,0,0,588,589,5,6,
        0,0,589,590,5,225,0,0,590,665,5,224,0,0,591,592,5,7,0,0,592,593,
        3,208,104,0,593,594,3,202,101,0,594,665,1,0,0,0,595,597,5,8,0,0,
        596,598,5,208,0,0,597,596,1,0,0,0,597,598,1,0,0,0,598,599,1,0,0,
        0,599,665,3,202,101,0,600,665,3,206,103,0,601,602,5,10,0,0,602,665,
        3,208,104,0,603,604,5,11,0,0,604,605,3,208,104,0,605,606,3,208,104,
        0,606,607,3,202,101,0,607,665,1,0,0,0,608,609,5,12,0,0,609,610,3,
        208,104,0,610,611,5,195,0,0,611,665,1,0,0,0,612,613,5,13,0,0,613,
        614,3,208,104,0,614,615,5,195,0,0,615,665,1,0,0,0,616,618,5,14,0,
        0,617,619,5,208,0,0,618,617,1,0,0,0,618,619,1,0,0,0,619,620,1,0,
        0,0,620,665,5,195,0,0,621,622,5,15,0,0,622,623,5,229,0,0,623,665,
        5,228,0,0,624,625,5,16,0,0,625,626,3,54,27,0,626,627,5,2,0,0,627,
        665,1,0,0,0,628,629,5,17,0,0,629,631,5,18,0,0,630,632,5,208,0,0,
        631,630,1,0,0,0,631,632,1,0,0,0,632,633,1,0,0,0,633,665,3,202,101,
        0,634,665,5,19,0,0,635,636,5,20,0,0,636,637,3,208,104,0,637,638,
        3,202,101,0,638,665,1,0,0,0,639,640,5,21,0,0,640,641,3,208,104,0,
        641,642,3,202,101,0,642,665,1,0,0,0,643,644,5,22,0,0,644,645,3,208,
        104,0,645,646,3,202,101,0,646,665,1,0,0,0,647,648,5,23,0,0,648,649,
        3,208,104,0,649,650,3,202,101,0,650,665,1,0,0,0,651,652,5,24,0,0,
        652,653,3,208,104,0,653,654,3,202,101,0,654,665,1,0,0,0,655,656,
        5,25,0,0,656,657,3,208,104,0,657,658,3,202,101,0,658,665,1,0,0,0,
        659,661,5,26,0,0,660,662,5,208,0,0,661,660,1,0,0,0,661,662,1,0,0,
        0,662,663,1,0,0,0,663,665,3,202,101,0,664,582,1,0,0,0,664,583,1,
        0,0,0,664,584,1,0,0,0,664,588,1,0,0,0,664,591,1,0,0,0,664,595,1,
        0,0,0,664,600,1,0,0,0,664,601,1,0,0,0,664,603,1,0,0,0,664,608,1,
        0,0,0,664,612,1,0,0,0,664,616,1,0,0,0,664,621,1,0,0,0,664,624,1,
        0,0,0,664,628,1,0,0,0,664,634,1,0,0,0,664,635,1,0,0,0,664,639,1,
        0,0,0,664,643,1,0,0,0,664,647,1,0,0,0,664,651,1,0,0,0,664,655,1,
        0,0,0,664,659,1,0,0,0,665,51,1,0,0,0,666,667,5,4,0,0,667,668,3,190,
        95,0,668,669,3,190,95,0,669,671,3,198,99,0,670,672,3,198,99,0,671,
        670,1,0,0,0,671,672,1,0,0,0,672,674,1,0,0,0,673,675,3,198,99,0,674,
        673,1,0,0,0,674,675,1,0,0,0,675,679,1,0,0,0,676,678,3,56,28,0,677,
        676,1,0,0,0,678,681,1,0,0,0,679,677,1,0,0,0,679,680,1,0,0,0,680,
        699,1,0,0,0,681,679,1,0,0,0,682,684,5,190,0,0,683,685,5,4,0,0,684,
        683,1,0,0,0,684,685,1,0,0,0,685,686,1,0,0,0,686,687,3,190,95,0,687,
        689,3,190,95,0,688,690,3,198,99,0,689,688,1,0,0,0,689,690,1,0,0,
        0,690,692,1,0,0,0,691,693,3,198,99,0,692,691,1,0,0,0,692,693,1,0,
        0,0,693,695,1,0,0,0,694,696,3,198,99,0,695,694,1,0,0,0,695,696,1,
        0,0,0,696,698,1,0,0,0,697,682,1,0,0,0,698,701,1,0,0,0,699,697,1,
        0,0,0,699,700,1,0,0,0,700,53,1,0,0,0,701,699,1,0,0,0,702,704,5,27,
        0,0,703,705,5,208,0,0,704,703,1,0,0,0,704,705,1,0,0,0,705,706,1,
        0,0,0,706,717,3,202,101,0,707,709,5,28,0,0,708,710,5,208,0,0,709,
        708,1,0,0,0,709,710,1,0,0,0,710,711,1,0,0,0,711,717,3,202,101,0,
        712,713,5,29,0,0,713,717,3,190,95,0,714,715,5,30,0,0,715,717,3,190,
        95,0,716,702,1,0,0,0,716,707,1,0,0,0,716,712,1,0,0,0,716,714,1,0,
        0,0,717,55,1,0,0,0,718,720,5,31,0,0,719,721,5,208,0,0,720,719,1,
        0,0,0,720,721,1,0,0,0,721,722,1,0,0,0,722,755,3,204,102,0,723,725,
        5,32,0,0,724,726,5,208,0,0,725,724,1,0,0,0,725,726,1,0,0,0,726,727,
        1,0,0,0,727,755,3,204,102,0,728,730,5,57,0,0,729,731,5,208,0,0,730,
        729,1,0,0,0,730,731,1,0,0,0,731,732,1,0,0,0,732,755,3,204,102,0,
        733,735,7,1,0,0,734,736,5,208,0,0,735,734,1,0,0,0,735,736,1,0,0,
        0,736,737,1,0,0,0,737,755,3,204,102,0,738,740,5,35,0,0,739,741,5,
        208,0,0,740,739,1,0,0,0,740,741,1,0,0,0,741,742,1,0,0,0,742,755,
        3,204,102,0,743,745,5,36,0,0,744,746,5,208,0,0,745,744,1,0,0,0,745,
        746,1,0,0,0,746,747,1,0,0,0,747,755,3,204,102,0,748,750,5,49,0,0,
        749,751,5,208,0,0,750,749,1,0,0,0,750,751,1,0,0,0,751,752,1,0,0,
        0,752,755,3,204,102,0,753,755,5,193,0,0,754,718,1,0,0,0,754,723,
        1,0,0,0,754,728,1,0,0,0,754,733,1,0,0,0,754,738,1,0,0,0,754,743,
        1,0,0,0,754,748,1,0,0,0,754,753,1,0,0,0,755,57,1,0,0,0,756,772,3,
        212,106,0,757,772,3,60,30,0,758,772,3,238,119,0,759,761,5,39,0,0,
        760,762,5,208,0,0,761,760,1,0,0,0,761,762,1,0,0,0,762,763,1,0,0,
        0,763,772,5,195,0,0,764,772,5,19,0,0,765,767,5,21,0,0,766,768,5,
        208,0,0,767,766,1,0,0,0,767,768,1,0,0,0,768,769,1,0,0,0,769,772,
        3,202,101,0,770,772,5,40,0,0,771,756,1,0,0,0,771,757,1,0,0,0,771,
        758,1,0,0,0,771,759,1,0,0,0,771,764,1,0,0,0,771,765,1,0,0,0,771,
        770,1,0,0,0,772,59,1,0,0,0,773,774,5,4,0,0,774,775,3,190,95,0,775,
        776,3,190,95,0,776,777,3,190,95,0,777,778,3,190,95,0,778,779,3,198,
        99,0,779,780,3,198,99,0,780,781,3,198,99,0,781,782,5,195,0,0,782,
        61,1,0,0,0,783,811,3,64,32,0,784,811,3,240,120,0,785,811,3,206,103,
        0,786,787,5,42,0,0,787,788,3,202,101,0,788,789,3,202,101,0,789,790,
        3,202,101,0,790,811,1,0,0,0,791,793,5,43,0,0,792,794,5,208,0,0,793,
        792,1,0,0,0,793,794,1,0,0,0,794,795,1,0,0,0,795,811,3,202,101,0,
        796,798,5,14,0,0,797,799,5,208,0,0,798,797,1,0,0,0,798,799,1,0,0,
        0,799,800,1,0,0,0,800,811,5,195,0,0,801,803,5,15,0,0,802,804,5,227,
        0,0,803,802,1,0,0,0,803,804,1,0,0,0,804,805,1,0,0,0,805,811,5,228,
        0,0,806,807,5,17,0,0,807,808,5,18,0,0,808,811,3,202,101,0,809,811,
        5,19,0,0,810,783,1,0,0,0,810,784,1,0,0,0,810,785,1,0,0,0,810,786,
        1,0,0,0,810,791,1,0,0,0,810,796,1,0,0,0,810,801,1,0,0,0,810,806,
        1,0,0,0,810,809,1,0,0,0,811,63,1,0,0,0,812,813,5,4,0,0,813,814,3,
        190,95,0,814,815,3,190,95,0,815,816,3,190,95,0,816,817,3,190,95,
        0,817,818,3,190,95,0,818,819,3,190,95,0,819,821,3,198,99,0,820,822,
        3,198,99,0,821,820,1,0,0,0,821,822,1,0,0,0,822,824,1,0,0,0,823,825,
        3,198,99,0,824,823,1,0,0,0,824,825,1,0,0,0,825,65,1,0,0,0,826,864,
        3,68,34,0,827,864,3,206,103,0,828,829,5,46,0,0,829,864,5,231,0,0,
        830,832,5,21,0,0,831,833,5,208,0,0,832,831,1,0,0,0,832,833,1,0,0,
        0,833,834,1,0,0,0,834,864,3,202,101,0,835,836,5,47,0,0,836,864,5,
        196,0,0,837,838,5,6,0,0,838,864,5,224,0,0,839,840,5,42,0,0,840,841,
        3,202,101,0,841,842,3,202,101,0,842,843,3,202,101,0,843,864,1,0,
        0,0,844,846,5,43,0,0,845,847,5,208,0,0,846,845,1,0,0,0,846,847,1,
        0,0,0,847,848,1,0,0,0,848,864,3,202,101,0,849,851,5,14,0,0,850,852,
        5,208,0,0,851,850,1,0,0,0,851,852,1,0,0,0,852,853,1,0,0,0,853,864,
        5,195,0,0,854,856,5,15,0,0,855,857,5,227,0,0,856,855,1,0,0,0,856,
        857,1,0,0,0,857,858,1,0,0,0,858,864,5,228,0,0,859,860,5,17,0,0,860,
        861,5,18,0,0,861,864,3,202,101,0,862,864,5,19,0,0,863,826,1,0,0,
        0,863,827,1,0,0,0,863,828,1,0,0,0,863,830,1,0,0,0,863,835,1,0,0,
        0,863,837,1,0,0,0,863,839,1,0,0,0,863,844,1,0,0,0,863,849,1,0,0,
        0,863,854,1,0,0,0,863,859,1,0,0,0,863,862,1,0,0,0,864,67,1,0,0,0,
        865,866,5,4,0,0,866,867,3,190,95,0,867,868,3,190,95,0,868,869,3,
        190,95,0,869,870,3,190,95,0,870,871,3,190,95,0,871,872,3,190,95,
        0,872,873,3,198,99,0,873,880,3,198,99,0,874,881,3,198,99,0,875,876,
        3,198,99,0,876,877,3,198,99,0,877,878,3,198,99,0,878,879,3,198,99,
        0,879,881,1,0,0,0,880,874,1,0,0,0,880,875,1,0,0,0,880,881,1,0,0,
        0,881,69,1,0,0,0,882,911,3,72,36,0,883,885,5,49,0,0,884,886,5,208,
        0,0,885,884,1,0,0,0,885,886,1,0,0,0,886,887,1,0,0,0,887,911,5,195,
        0,0,888,911,3,206,103,0,889,891,5,43,0,0,890,892,5,208,0,0,891,890,
        1,0,0,0,891,892,1,0,0,0,892,893,1,0,0,0,893,894,3,202,101,0,894,
        895,3,202,101,0,895,911,1,0,0,0,896,898,5,14,0,0,897,899,5,208,0,
        0,898,897,1,0,0,0,898,899,1,0,0,0,899,900,1,0,0,0,900,911,5,195,
        0,0,901,903,5,50,0,0,902,904,5,208,0,0,903,902,1,0,0,0,903,904,1,
        0,0,0,904,905,1,0,0,0,905,911,5,195,0,0,906,907,5,17,0,0,907,908,
        5,18,0,0,908,911,3,202,101,0,909,911,5,19,0,0,910,882,1,0,0,0,910,
        883,1,0,0,0,910,888,1,0,0,0,910,889,1,0,0,0,910,896,1,0,0,0,910,
        901,1,0,0,0,910,906,1,0,0,0,910,909,1,0,0,0,911,71,1,0,0,0,912,913,
        5,4,0,0,913,914,3,190,95,0,914,915,3,190,95,0,915,916,3,190,95,0,
        916,917,3,190,95,0,917,918,3,198,99,0,918,922,3,198,99,0,919,920,
        3,198,99,0,920,921,3,198,99,0,921,923,1,0,0,0,922,919,1,0,0,0,922,
        923,1,0,0,0,923,73,1,0,0,0,924,943,3,76,38,0,925,943,3,206,103,0,
        926,927,5,42,0,0,927,943,3,202,101,0,928,930,5,14,0,0,929,931,5,
        208,0,0,930,929,1,0,0,0,930,931,1,0,0,0,931,932,1,0,0,0,932,943,
        5,195,0,0,933,935,5,15,0,0,934,936,5,227,0,0,935,934,1,0,0,0,935,
        936,1,0,0,0,936,937,1,0,0,0,937,943,5,228,0,0,938,939,5,17,0,0,939,
        940,5,18,0,0,940,943,3,202,101,0,941,943,5,19,0,0,942,924,1,0,0,
        0,942,925,1,0,0,0,942,926,1,0,0,0,942,928,1,0,0,0,942,933,1,0,0,
        0,942,938,1,0,0,0,942,941,1,0,0,0,943,75,1,0,0,0,944,945,5,4,0,0,
        945,946,3,190,95,0,946,947,3,190,95,0,947,949,3,198,99,0,948,950,
        3,198,99,0,949,948,1,0,0,0,949,950,1,0,0,0,950,77,1,0,0,0,951,981,
        3,80,40,0,952,981,3,206,103,0,953,954,5,42,0,0,954,955,3,202,101,
        0,955,956,3,202,101,0,956,957,3,202,101,0,957,958,3,202,101,0,958,
        981,1,0,0,0,959,961,5,43,0,0,960,962,5,208,0,0,961,960,1,0,0,0,961,
        962,1,0,0,0,962,963,1,0,0,0,963,981,3,202,101,0,964,966,5,14,0,0,
        965,967,5,208,0,0,966,965,1,0,0,0,966,967,1,0,0,0,967,968,1,0,0,
        0,968,981,5,195,0,0,969,971,5,15,0,0,970,972,5,227,0,0,971,970,1,
        0,0,0,971,972,1,0,0,0,972,973,1,0,0,0,973,981,5,228,0,0,974,975,
        5,17,0,0,975,976,5,18,0,0,976,981,3,202,101,0,977,981,5,19,0,0,978,
        979,5,46,0,0,979,981,5,232,0,0,980,951,1,0,0,0,980,952,1,0,0,0,980,
        953,1,0,0,0,980,959,1,0,0,0,980,964,1,0,0,0,980,969,1,0,0,0,980,
        974,1,0,0,0,980,977,1,0,0,0,980,978,1,0,0,0,981,79,1,0,0,0,982,983,
        5,4,0,0,983,984,3,190,95,0,984,985,3,190,95,0,985,986,3,190,95,0,
        986,987,3,190,95,0,987,989,3,198,99,0,988,990,3,198,99,0,989,988,
        1,0,0,0,989,990,1,0,0,0,990,81,1,0,0,0,991,997,3,212,106,0,992,997,
        3,84,42,0,993,997,3,258,129,0,994,997,5,55,0,0,995,997,5,40,0,0,
        996,991,1,0,0,0,996,992,1,0,0,0,996,993,1,0,0,0,996,994,1,0,0,0,
        996,995,1,0,0,0,997,83,1,0,0,0,998,1002,5,54,0,0,999,1001,3,86,43,
        0,1000,999,1,0,0,0,1001,1004,1,0,0,0,1002,1000,1,0,0,0,1002,1003,
        1,0,0,0,1003,1005,1,0,0,0,1004,1002,1,0,0,0,1005,1006,5,2,0,0,1006,
        85,1,0,0,0,1007,1009,5,56,0,0,1008,1010,5,208,0,0,1009,1008,1,0,
        0,0,1009,1010,1,0,0,0,1010,1011,1,0,0,0,1011,1018,3,190,95,0,1012,
        1014,5,57,0,0,1013,1015,5,208,0,0,1014,1013,1,0,0,0,1014,1015,1,
        0,0,0,1015,1016,1,0,0,0,1016,1018,3,202,101,0,1017,1007,1,0,0,0,
        1017,1012,1,0,0,0,1018,87,1,0,0,0,1019,1060,3,212,106,0,1020,1022,
        5,59,0,0,1021,1023,5,208,0,0,1022,1021,1,0,0,0,1022,1023,1,0,0,0,
        1023,1024,1,0,0,0,1024,1060,5,195,0,0,1025,1027,5,60,0,0,1026,1028,
        5,208,0,0,1027,1026,1,0,0,0,1027,1028,1,0,0,0,1028,1029,1,0,0,0,
        1029,1055,5,205,0,0,1030,1032,3,202,101,0,1031,1033,5,193,0,0,1032,
        1031,1,0,0,0,1032,1033,1,0,0,0,1033,1034,1,0,0,0,1034,1036,3,202,
        101,0,1035,1037,5,193,0,0,1036,1035,1,0,0,0,1036,1037,1,0,0,0,1037,
        1038,1,0,0,0,1038,1039,3,202,101,0,1039,1056,1,0,0,0,1040,1042,5,
        188,0,0,1041,1043,5,208,0,0,1042,1041,1,0,0,0,1042,1043,1,0,0,0,
        1043,1044,1,0,0,0,1044,1046,3,190,95,0,1045,1047,5,193,0,0,1046,
        1045,1,0,0,0,1046,1047,1,0,0,0,1047,1053,1,0,0,0,1048,1050,5,189,
        0,0,1049,1051,5,208,0,0,1050,1049,1,0,0,0,1050,1051,1,0,0,0,1051,
        1052,1,0,0,0,1052,1054,3,190,95,0,1053,1048,1,0,0,0,1053,1054,1,
        0,0,0,1054,1056,1,0,0,0,1055,1030,1,0,0,0,1055,1040,1,0,0,0,1056,
        1057,1,0,0,0,1057,1058,5,206,0,0,1058,1060,1,0,0,0,1059,1019,1,0,
        0,0,1059,1020,1,0,0,0,1059,1025,1,0,0,0,1060,89,1,0,0,0,1061,1062,
        5,4,0,0,1062,1063,3,190,95,0,1063,1064,3,198,99,0,1064,1065,3,198,
        99,0,1065,1066,3,198,99,0,1066,91,1,0,0,0,1067,1097,3,94,47,0,1068,
        1097,3,242,121,0,1069,1097,3,206,103,0,1070,1071,5,62,0,0,1071,1072,
        5,195,0,0,1072,1097,3,202,101,0,1073,1075,5,43,0,0,1074,1076,5,208,
        0,0,1075,1074,1,0,0,0,1075,1076,1,0,0,0,1076,1077,1,0,0,0,1077,1097,
        3,202,101,0,1078,1080,5,14,0,0,1079,1081,5,208,0,0,1080,1079,1,0,
        0,0,1080,1081,1,0,0,0,1081,1082,1,0,0,0,1082,1097,5,195,0,0,1083,
        1084,5,17,0,0,1084,1085,5,18,0,0,1085,1088,3,202,101,0,1086,1089,
        5,139,0,0,1087,1089,3,206,103,0,1088,1086,1,0,0,0,1088,1087,1,0,
        0,0,1089,1097,1,0,0,0,1090,1097,5,19,0,0,1091,1092,5,63,0,0,1092,
        1093,3,202,101,0,1093,1094,5,195,0,0,1094,1097,1,0,0,0,1095,1097,
        5,64,0,0,1096,1067,1,0,0,0,1096,1068,1,0,0,0,1096,1069,1,0,0,0,1096,
        1070,1,0,0,0,1096,1073,1,0,0,0,1096,1078,1,0,0,0,1096,1083,1,0,0,
        0,1096,1090,1,0,0,0,1096,1091,1,0,0,0,1096,1095,1,0,0,0,1097,93,
        1,0,0,0,1098,1099,5,4,0,0,1099,1100,3,190,95,0,1100,1101,3,190,95,
        0,1101,95,1,0,0,0,1102,1147,3,98,49,0,1103,1147,3,244,122,0,1104,
        1147,3,206,103,0,1105,1106,5,42,0,0,1106,1107,3,202,101,0,1107,1108,
        3,202,101,0,1108,1109,3,202,101,0,1109,1110,3,202,101,0,1110,1147,
        1,0,0,0,1111,1113,5,49,0,0,1112,1114,5,208,0,0,1113,1112,1,0,0,0,
        1113,1114,1,0,0,0,1114,1115,1,0,0,0,1115,1147,5,195,0,0,1116,1117,
        5,66,0,0,1117,1147,5,195,0,0,1118,1119,5,43,0,0,1119,1121,3,202,
        101,0,1120,1122,3,202,101,0,1121,1120,1,0,0,0,1121,1122,1,0,0,0,
        1122,1147,1,0,0,0,1123,1125,5,14,0,0,1124,1126,5,208,0,0,1125,1124,
        1,0,0,0,1125,1126,1,0,0,0,1126,1127,1,0,0,0,1127,1147,5,195,0,0,
        1128,1130,5,50,0,0,1129,1131,5,208,0,0,1130,1129,1,0,0,0,1130,1131,
        1,0,0,0,1131,1132,1,0,0,0,1132,1147,5,195,0,0,1133,1135,5,15,0,0,
        1134,1136,5,227,0,0,1135,1134,1,0,0,0,1135,1136,1,0,0,0,1136,1137,
        1,0,0,0,1137,1147,5,228,0,0,1138,1139,5,17,0,0,1139,1140,5,18,0,
        0,1140,1143,3,202,101,0,1141,1144,5,139,0,0,1142,1144,3,206,103,
        0,1143,1141,1,0,0,0,1143,1142,1,0,0,0,1144,1147,1,0,0,0,1145,1147,
        5,19,0,0,1146,1102,1,0,0,0,1146,1103,1,0,0,0,1146,1104,1,0,0,0,1146,
        1105,1,0,0,0,1146,1111,1,0,0,0,1146,1116,1,0,0,0,1146,1118,1,0,0,
        0,1146,1123,1,0,0,0,1146,1128,1,0,0,0,1146,1133,1,0,0,0,1146,1138,
        1,0,0,0,1146,1145,1,0,0,0,1147,97,1,0,0,0,1148,1149,5,4,0,0,1149,
        1150,3,190,95,0,1150,1151,3,190,95,0,1151,1152,3,190,95,0,1152,1158,
        3,190,95,0,1153,1154,3,190,95,0,1154,1155,3,190,95,0,1155,1156,3,
        190,95,0,1156,1157,3,190,95,0,1157,1159,1,0,0,0,1158,1153,1,0,0,
        0,1158,1159,1,0,0,0,1159,1160,1,0,0,0,1160,1161,3,198,99,0,1161,
        1165,3,198,99,0,1162,1163,3,198,99,0,1163,1164,3,198,99,0,1164,1166,
        1,0,0,0,1165,1162,1,0,0,0,1165,1166,1,0,0,0,1166,99,1,0,0,0,1167,
        1202,3,102,51,0,1168,1202,3,206,103,0,1169,1170,5,62,0,0,1170,1171,
        5,195,0,0,1171,1172,5,195,0,0,1172,1173,3,202,101,0,1173,1174,3,
        202,101,0,1174,1175,3,202,101,0,1175,1202,1,0,0,0,1176,1178,5,43,
        0,0,1177,1179,5,208,0,0,1178,1177,1,0,0,0,1178,1179,1,0,0,0,1179,
        1180,1,0,0,0,1180,1202,3,202,101,0,1181,1183,5,14,0,0,1182,1184,
        5,208,0,0,1183,1182,1,0,0,0,1183,1184,1,0,0,0,1184,1185,1,0,0,0,
        1185,1202,5,195,0,0,1186,1187,5,68,0,0,1187,1202,3,202,101,0,1188,
        1189,5,69,0,0,1189,1202,3,202,101,0,1190,1192,5,15,0,0,1191,1193,
        5,227,0,0,1192,1191,1,0,0,0,1192,1193,1,0,0,0,1193,1194,1,0,0,0,
        1194,1202,5,228,0,0,1195,1196,5,17,0,0,1196,1197,5,18,0,0,1197,1202,
        3,202,101,0,1198,1202,3,104,52,0,1199,1202,5,19,0,0,1200,1202,5,
        64,0,0,1201,1167,1,0,0,0,1201,1168,1,0,0,0,1201,1169,1,0,0,0,1201,
        1176,1,0,0,0,1201,1181,1,0,0,0,1201,1186,1,0,0,0,1201,1188,1,0,0,
        0,1201,1190,1,0,0,0,1201,1195,1,0,0,0,1201,1198,1,0,0,0,1201,1199,
        1,0,0,0,1201,1200,1,0,0,0,1202,101,1,0,0,0,1203,1204,5,4,0,0,1204,
        1205,3,190,95,0,1205,1206,3,190,95,0,1206,1207,3,190,95,0,1207,1208,
        3,190,95,0,1208,1209,3,190,95,0,1209,1210,3,198,99,0,1210,1211,3,
        198,99,0,1211,103,1,0,0,0,1212,1213,5,70,0,0,1213,1214,3,190,95,
        0,1214,1215,3,198,99,0,1215,1216,3,198,99,0,1216,105,1,0,0,0,1217,
        1252,3,108,54,0,1218,1252,3,110,55,0,1219,1252,3,112,56,0,1220,1252,
        3,114,57,0,1221,1252,3,116,58,0,1222,1252,3,118,59,0,1223,1252,3,
        120,60,0,1224,1252,3,122,61,0,1225,1252,3,124,62,0,1226,1252,3,206,
        103,0,1227,1228,5,78,0,0,1228,1252,3,202,101,0,1229,1230,5,66,0,
        0,1230,1252,5,195,0,0,1231,1232,5,43,0,0,1232,1234,3,202,101,0,1233,
        1235,3,202,101,0,1234,1233,1,0,0,0,1234,1235,1,0,0,0,1235,1252,1,
        0,0,0,1236,1238,5,15,0,0,1237,1239,5,227,0,0,1238,1237,1,0,0,0,1238,
        1239,1,0,0,0,1239,1240,1,0,0,0,1240,1252,5,228,0,0,1241,1242,5,17,
        0,0,1242,1243,5,18,0,0,1243,1246,3,202,101,0,1244,1247,5,139,0,0,
        1245,1247,3,206,103,0,1246,1244,1,0,0,0,1246,1245,1,0,0,0,1247,1248,
        1,0,0,0,1248,1249,5,202,0,0,1249,1252,1,0,0,0,1250,1252,5,19,0,0,
        1251,1217,1,0,0,0,1251,1218,1,0,0,0,1251,1219,1,0,0,0,1251,1220,
        1,0,0,0,1251,1221,1,0,0,0,1251,1222,1,0,0,0,1251,1223,1,0,0,0,1251,
        1224,1,0,0,0,1251,1225,1,0,0,0,1251,1226,1,0,0,0,1251,1227,1,0,0,
        0,1251,1229,1,0,0,0,1251,1231,1,0,0,0,1251,1236,1,0,0,0,1251,1241,
        1,0,0,0,1251,1250,1,0,0,0,1252,107,1,0,0,0,1253,1254,5,72,0,0,1254,
        1256,3,190,95,0,1255,1257,3,190,95,0,1256,1255,1,0,0,0,1256,1257,
        1,0,0,0,1257,1258,1,0,0,0,1258,1260,3,198,99,0,1259,1261,3,198,99,
        0,1260,1259,1,0,0,0,1260,1261,1,0,0,0,1261,109,1,0,0,0,1262,1263,
        5,70,0,0,1263,1264,3,190,95,0,1264,1265,3,198,99,0,1265,111,1,0,
        0,0,1266,1267,5,52,0,0,1267,1268,3,190,95,0,1268,1269,3,190,95,0,
        1269,1270,3,190,95,0,1270,1272,5,202,0,0,1271,1273,5,196,0,0,1272,
        1271,1,0,0,0,1272,1273,1,0,0,0,1273,1274,1,0,0,0,1274,1275,5,202,
        0,0,1275,113,1,0,0,0,1276,1277,5,73,0,0,1277,1278,3,190,95,0,1278,
        115,1,0,0,0,1279,1280,5,67,0,0,1280,1281,3,190,95,0,1281,117,1,0,
        0,0,1282,1283,5,74,0,0,1283,1284,3,190,95,0,1284,119,1,0,0,0,1285,
        1286,5,75,0,0,1286,1287,3,190,95,0,1287,121,1,0,0,0,1288,1289,5,
        76,0,0,1289,1290,5,202,0,0,1290,1291,3,190,95,0,1291,1292,3,190,
        95,0,1292,1293,3,190,95,0,1293,1294,3,190,95,0,1294,1296,3,190,95,
        0,1295,1297,3,190,95,0,1296,1295,1,0,0,0,1296,1297,1,0,0,0,1297,
        123,1,0,0,0,1298,1299,5,77,0,0,1299,1300,3,190,95,0,1300,125,1,0,
        0,0,1301,1411,3,128,64,0,1302,1411,3,206,103,0,1303,1304,5,27,0,
        0,1304,1411,3,202,101,0,1305,1307,5,43,0,0,1306,1308,5,208,0,0,1307,
        1306,1,0,0,0,1307,1308,1,0,0,0,1308,1309,1,0,0,0,1309,1411,3,202,
        101,0,1310,1311,5,80,0,0,1311,1312,3,202,101,0,1312,1313,3,202,101,
        0,1313,1318,3,202,101,0,1314,1315,3,202,101,0,1315,1316,3,202,101,
        0,1316,1317,3,202,101,0,1317,1319,1,0,0,0,1318,1314,1,0,0,0,1318,
        1319,1,0,0,0,1319,1324,1,0,0,0,1320,1321,3,202,101,0,1321,1322,3,
        202,101,0,1322,1323,3,202,101,0,1323,1325,1,0,0,0,1324,1320,1,0,
        0,0,1324,1325,1,0,0,0,1325,1330,1,0,0,0,1326,1327,3,202,101,0,1327,
        1328,3,202,101,0,1328,1329,3,202,101,0,1329,1331,1,0,0,0,1330,1326,
        1,0,0,0,1330,1331,1,0,0,0,1331,1411,1,0,0,0,1332,1334,5,14,0,0,1333,
        1335,5,208,0,0,1334,1333,1,0,0,0,1334,1335,1,0,0,0,1335,1336,1,0,
        0,0,1336,1411,5,195,0,0,1337,1338,5,81,0,0,1338,1339,3,202,101,0,
        1339,1340,3,202,101,0,1340,1345,3,202,101,0,1341,1342,3,202,101,
        0,1342,1343,3,202,101,0,1343,1344,3,202,101,0,1344,1346,1,0,0,0,
        1345,1341,1,0,0,0,1345,1346,1,0,0,0,1346,1351,1,0,0,0,1347,1348,
        3,202,101,0,1348,1349,3,202,101,0,1349,1350,3,202,101,0,1350,1352,
        1,0,0,0,1351,1347,1,0,0,0,1351,1352,1,0,0,0,1352,1357,1,0,0,0,1353,
        1354,3,202,101,0,1354,1355,3,202,101,0,1355,1356,3,202,101,0,1356,
        1358,1,0,0,0,1357,1353,1,0,0,0,1357,1358,1,0,0,0,1358,1411,1,0,0,
        0,1359,1360,5,17,0,0,1360,1361,5,18,0,0,1361,1364,3,202,101,0,1362,
        1365,5,139,0,0,1363,1365,3,206,103,0,1364,1362,1,0,0,0,1364,1363,
        1,0,0,0,1365,1411,1,0,0,0,1366,1367,5,82,0,0,1367,1368,3,202,101,
        0,1368,1369,3,202,101,0,1369,1374,3,202,101,0,1370,1371,3,202,101,
        0,1371,1372,3,202,101,0,1372,1373,3,202,101,0,1373,1375,1,0,0,0,
        1374,1370,1,0,0,0,1374,1375,1,0,0,0,1375,1380,1,0,0,0,1376,1377,
        3,202,101,0,1377,1378,3,202,101,0,1378,1379,3,202,101,0,1379,1381,
        1,0,0,0,1380,1376,1,0,0,0,1380,1381,1,0,0,0,1381,1386,1,0,0,0,1382,
        1383,3,202,101,0,1383,1384,3,202,101,0,1384,1385,3,202,101,0,1385,
        1387,1,0,0,0,1386,1382,1,0,0,0,1386,1387,1,0,0,0,1387,1411,1,0,0,
        0,1388,1411,5,19,0,0,1389,1391,5,21,0,0,1390,1392,5,208,0,0,1391,
        1390,1,0,0,0,1391,1392,1,0,0,0,1392,1393,1,0,0,0,1393,1411,3,202,
        101,0,1394,1395,5,83,0,0,1395,1411,5,235,0,0,1396,1397,5,63,0,0,
        1397,1398,5,85,0,0,1398,1400,3,202,101,0,1399,1401,3,202,101,0,1400,
        1399,1,0,0,0,1400,1401,1,0,0,0,1401,1403,1,0,0,0,1402,1404,3,202,
        101,0,1403,1402,1,0,0,0,1403,1404,1,0,0,0,1404,1406,1,0,0,0,1405,
        1407,3,202,101,0,1406,1405,1,0,0,0,1406,1407,1,0,0,0,1407,1411,1,
        0,0,0,1408,1411,5,84,0,0,1409,1411,5,64,0,0,1410,1301,1,0,0,0,1410,
        1302,1,0,0,0,1410,1303,1,0,0,0,1410,1305,1,0,0,0,1410,1310,1,0,0,
        0,1410,1332,1,0,0,0,1410,1337,1,0,0,0,1410,1359,1,0,0,0,1410,1366,
        1,0,0,0,1410,1388,1,0,0,0,1410,1389,1,0,0,0,1410,1394,1,0,0,0,1410,
        1396,1,0,0,0,1410,1408,1,0,0,0,1410,1409,1,0,0,0,1411,127,1,0,0,
        0,1412,1413,5,4,0,0,1413,1414,3,190,95,0,1414,1415,3,190,95,0,1415,
        1416,3,190,95,0,1416,1422,3,190,95,0,1417,1418,3,190,95,0,1418,1419,
        3,190,95,0,1419,1420,3,190,95,0,1420,1421,3,190,95,0,1421,1423,1,
        0,0,0,1422,1417,1,0,0,0,1422,1423,1,0,0,0,1423,1429,1,0,0,0,1424,
        1425,3,190,95,0,1425,1426,3,190,95,0,1426,1427,3,190,95,0,1427,1428,
        3,190,95,0,1428,1430,1,0,0,0,1429,1424,1,0,0,0,1429,1430,1,0,0,0,
        1430,1436,1,0,0,0,1431,1432,3,190,95,0,1432,1433,3,190,95,0,1433,
        1434,3,190,95,0,1434,1435,3,190,95,0,1435,1437,1,0,0,0,1436,1431,
        1,0,0,0,1436,1437,1,0,0,0,1437,129,1,0,0,0,1438,1448,3,132,66,0,
        1439,1448,3,246,123,0,1440,1442,5,21,0,0,1441,1443,5,208,0,0,1442,
        1441,1,0,0,0,1442,1443,1,0,0,0,1443,1444,1,0,0,0,1444,1448,3,202,
        101,0,1445,1448,5,17,0,0,1446,1448,5,19,0,0,1447,1438,1,0,0,0,1447,
        1439,1,0,0,0,1447,1440,1,0,0,0,1447,1445,1,0,0,0,1447,1446,1,0,0,
        0,1448,131,1,0,0,0,1449,1450,5,4,0,0,1450,1451,3,190,95,0,1451,1452,
        3,198,99,0,1452,1453,3,198,99,0,1453,133,1,0,0,0,1454,1485,3,136,
        68,0,1455,1485,3,206,103,0,1456,1457,5,42,0,0,1457,1458,3,202,101,
        0,1458,1459,3,202,101,0,1459,1460,3,202,101,0,1460,1461,3,202,101,
        0,1461,1462,3,202,101,0,1462,1485,1,0,0,0,1463,1465,5,43,0,0,1464,
        1466,5,208,0,0,1465,1464,1,0,0,0,1465,1466,1,0,0,0,1466,1467,1,0,
        0,0,1467,1485,3,202,101,0,1468,1470,5,14,0,0,1469,1471,5,208,0,0,
        1470,1469,1,0,0,0,1470,1471,1,0,0,0,1471,1472,1,0,0,0,1472,1485,
        5,195,0,0,1473,1475,5,15,0,0,1474,1476,5,227,0,0,1475,1474,1,0,0,
        0,1475,1476,1,0,0,0,1476,1477,1,0,0,0,1477,1485,5,228,0,0,1478,1479,
        5,17,0,0,1479,1480,5,18,0,0,1480,1485,3,202,101,0,1481,1485,5,19,
        0,0,1482,1483,5,46,0,0,1483,1485,5,232,0,0,1484,1454,1,0,0,0,1484,
        1455,1,0,0,0,1484,1456,1,0,0,0,1484,1463,1,0,0,0,1484,1468,1,0,0,
        0,1484,1473,1,0,0,0,1484,1478,1,0,0,0,1484,1481,1,0,0,0,1484,1482,
        1,0,0,0,1485,135,1,0,0,0,1486,1487,5,4,0,0,1487,1488,3,190,95,0,
        1488,1489,3,190,95,0,1489,1490,3,190,95,0,1490,1491,3,190,95,0,1491,
        1492,3,190,95,0,1492,1493,3,190,95,0,1493,1495,3,198,99,0,1494,1496,
        3,198,99,0,1495,1494,1,0,0,0,1495,1496,1,0,0,0,1496,137,1,0,0,0,
        1497,1559,3,140,70,0,1498,1559,3,206,103,0,1499,1500,5,27,0,0,1500,
        1559,3,202,101,0,1501,1502,5,89,0,0,1502,1559,3,202,101,0,1503,1505,
        5,43,0,0,1504,1506,5,208,0,0,1505,1504,1,0,0,0,1505,1506,1,0,0,0,
        1506,1507,1,0,0,0,1507,1559,3,202,101,0,1508,1509,5,80,0,0,1509,
        1510,3,202,101,0,1510,1511,3,202,101,0,1511,1512,3,202,101,0,1512,
        1513,3,202,101,0,1513,1514,3,202,101,0,1514,1515,3,202,101,0,1515,
        1516,3,202,101,0,1516,1559,1,0,0,0,1517,1518,5,90,0,0,1518,1559,
        5,195,0,0,1519,1520,5,91,0,0,1520,1521,3,202,101,0,1521,1522,3,202,
        101,0,1522,1523,3,202,101,0,1523,1524,3,202,101,0,1524,1525,3,202,
        101,0,1525,1526,3,202,101,0,1526,1527,3,202,101,0,1527,1528,3,202,
        101,0,1528,1559,1,0,0,0,1529,1531,5,14,0,0,1530,1532,5,208,0,0,1531,
        1530,1,0,0,0,1531,1532,1,0,0,0,1532,1533,1,0,0,0,1533,1559,5,195,
        0,0,1534,1535,5,17,0,0,1535,1536,5,18,0,0,1536,1539,3,202,101,0,
        1537,1540,5,139,0,0,1538,1540,3,206,103,0,1539,1537,1,0,0,0,1539,
        1538,1,0,0,0,1540,1559,1,0,0,0,1541,1542,5,82,0,0,1542,1543,3,202,
        101,0,1543,1544,3,202,101,0,1544,1545,3,202,101,0,1545,1546,3,202,
        101,0,1546,1547,3,202,101,0,1547,1548,3,202,101,0,1548,1549,3,202,
        101,0,1549,1559,1,0,0,0,1550,1559,5,19,0,0,1551,1552,5,155,0,0,1552,
        1559,5,195,0,0,1553,1554,5,63,0,0,1554,1555,3,202,101,0,1555,1556,
        3,202,101,0,1556,1559,1,0,0,0,1557,1559,5,64,0,0,1558,1497,1,0,0,
        0,1558,1498,1,0,0,0,1558,1499,1,0,0,0,1558,1501,1,0,0,0,1558,1503,
        1,0,0,0,1558,1508,1,0,0,0,1558,1517,1,0,0,0,1558,1519,1,0,0,0,1558,
        1529,1,0,0,0,1558,1534,1,0,0,0,1558,1541,1,0,0,0,1558,1550,1,0,0,
        0,1558,1551,1,0,0,0,1558,1553,1,0,0,0,1558,1557,1,0,0,0,1559,139,
        1,0,0,0,1560,1561,5,4,0,0,1561,1562,3,190,95,0,1562,1563,3,190,95,
        0,1563,1564,3,190,95,0,1564,1565,3,190,95,0,1565,141,1,0,0,0,1566,
        1606,3,144,72,0,1567,1606,3,248,124,0,1568,1606,3,206,103,0,1569,
        1571,5,21,0,0,1570,1572,5,208,0,0,1571,1570,1,0,0,0,1571,1572,1,
        0,0,0,1572,1573,1,0,0,0,1573,1606,3,202,101,0,1574,1575,5,46,0,0,
        1575,1606,5,233,0,0,1576,1577,5,42,0,0,1577,1578,3,202,101,0,1578,
        1579,3,202,101,0,1579,1580,3,202,101,0,1580,1606,1,0,0,0,1581,1582,
        5,93,0,0,1582,1583,3,202,101,0,1583,1584,3,202,101,0,1584,1585,3,
        202,101,0,1585,1606,1,0,0,0,1586,1588,5,43,0,0,1587,1589,5,208,0,
        0,1588,1587,1,0,0,0,1588,1589,1,0,0,0,1589,1590,1,0,0,0,1590,1606,
        3,202,101,0,1591,1593,5,14,0,0,1592,1594,5,208,0,0,1593,1592,1,0,
        0,0,1593,1594,1,0,0,0,1594,1595,1,0,0,0,1595,1606,5,195,0,0,1596,
        1598,5,15,0,0,1597,1599,5,227,0,0,1598,1597,1,0,0,0,1598,1599,1,
        0,0,0,1599,1600,1,0,0,0,1600,1606,5,228,0,0,1601,1602,5,17,0,0,1602,
        1603,5,18,0,0,1603,1606,3,202,101,0,1604,1606,5,19,0,0,1605,1566,
        1,0,0,0,1605,1567,1,0,0,0,1605,1568,1,0,0,0,1605,1569,1,0,0,0,1605,
        1574,1,0,0,0,1605,1576,1,0,0,0,1605,1581,1,0,0,0,1605,1586,1,0,0,
        0,1605,1591,1,0,0,0,1605,1596,1,0,0,0,1605,1601,1,0,0,0,1605,1604,
        1,0,0,0,1606,143,1,0,0,0,1607,1608,5,4,0,0,1608,1609,3,190,95,0,
        1609,1610,3,190,95,0,1610,1611,3,190,95,0,1611,1612,3,190,95,0,1612,
        1613,3,190,95,0,1613,1614,3,190,95,0,1614,1615,3,190,95,0,1615,1617,
        3,198,99,0,1616,1618,3,198,99,0,1617,1616,1,0,0,0,1617,1618,1,0,
        0,0,1618,1620,1,0,0,0,1619,1621,3,198,99,0,1620,1619,1,0,0,0,1620,
        1621,1,0,0,0,1621,145,1,0,0,0,1622,1660,3,144,72,0,1623,1660,3,206,
        103,0,1624,1626,5,21,0,0,1625,1627,5,208,0,0,1626,1625,1,0,0,0,1626,
        1627,1,0,0,0,1627,1628,1,0,0,0,1628,1660,3,202,101,0,1629,1630,5,
        42,0,0,1630,1631,3,202,101,0,1631,1632,3,202,101,0,1632,1633,3,202,
        101,0,1633,1660,1,0,0,0,1634,1635,5,93,0,0,1635,1636,3,202,101,0,
        1636,1637,3,202,101,0,1637,1638,3,202,101,0,1638,1639,3,202,101,
        0,1639,1660,1,0,0,0,1640,1642,5,43,0,0,1641,1643,5,208,0,0,1642,
        1641,1,0,0,0,1642,1643,1,0,0,0,1643,1644,1,0,0,0,1644,1660,3,202,
        101,0,1645,1647,5,14,0,0,1646,1648,5,208,0,0,1647,1646,1,0,0,0,1647,
        1648,1,0,0,0,1648,1649,1,0,0,0,1649,1660,5,195,0,0,1650,1652,5,15,
        0,0,1651,1653,5,227,0,0,1652,1651,1,0,0,0,1652,1653,1,0,0,0,1653,
        1654,1,0,0,0,1654,1660,5,228,0,0,1655,1656,5,17,0,0,1656,1657,5,
        18,0,0,1657,1660,3,202,101,0,1658,1660,5,19,0,0,1659,1622,1,0,0,
        0,1659,1623,1,0,0,0,1659,1624,1,0,0,0,1659,1629,1,0,0,0,1659,1634,
        1,0,0,0,1659,1640,1,0,0,0,1659,1645,1,0,0,0,1659,1650,1,0,0,0,1659,
        1655,1,0,0,0,1659,1658,1,0,0,0,1660,147,1,0,0,0,1661,1692,3,150,
        75,0,1662,1692,3,206,103,0,1663,1664,5,42,0,0,1664,1665,3,202,101,
        0,1665,1666,3,202,101,0,1666,1667,3,202,101,0,1667,1668,3,202,101,
        0,1668,1669,3,202,101,0,1669,1670,3,202,101,0,1670,1671,3,202,101,
        0,1671,1692,1,0,0,0,1672,1674,5,43,0,0,1673,1675,5,208,0,0,1674,
        1673,1,0,0,0,1674,1675,1,0,0,0,1675,1676,1,0,0,0,1676,1692,3,202,
        101,0,1677,1679,5,14,0,0,1678,1680,5,208,0,0,1679,1678,1,0,0,0,1679,
        1680,1,0,0,0,1680,1681,1,0,0,0,1681,1692,5,195,0,0,1682,1684,5,15,
        0,0,1683,1685,5,227,0,0,1684,1683,1,0,0,0,1684,1685,1,0,0,0,1685,
        1686,1,0,0,0,1686,1692,5,228,0,0,1687,1688,5,17,0,0,1688,1689,5,
        18,0,0,1689,1692,3,202,101,0,1690,1692,5,19,0,0,1691,1661,1,0,0,
        0,1691,1662,1,0,0,0,1691,1663,1,0,0,0,1691,1672,1,0,0,0,1691,1677,
        1,0,0,0,1691,1682,1,0,0,0,1691,1687,1,0,0,0,1691,1690,1,0,0,0,1692,
        149,1,0,0,0,1693,1694,5,4,0,0,1694,1695,3,190,95,0,1695,1696,3,190,
        95,0,1696,1697,3,190,95,0,1697,1698,3,190,95,0,1698,1699,3,190,95,
        0,1699,1700,3,190,95,0,1700,1701,3,190,95,0,1701,1702,3,190,95,0,
        1702,1703,3,198,99,0,1703,1704,3,198,99,0,1704,151,1,0,0,0,1705,
        1744,3,154,77,0,1706,1744,3,206,103,0,1707,1708,5,97,0,0,1708,1744,
        5,202,0,0,1709,1710,5,62,0,0,1710,1711,5,195,0,0,1711,1712,5,195,
        0,0,1712,1744,3,202,101,0,1713,1714,5,78,0,0,1714,1744,3,202,101,
        0,1715,1717,5,43,0,0,1716,1718,5,208,0,0,1717,1716,1,0,0,0,1717,
        1718,1,0,0,0,1718,1719,1,0,0,0,1719,1744,3,202,101,0,1720,1722,5,
        14,0,0,1721,1723,5,208,0,0,1722,1721,1,0,0,0,1722,1723,1,0,0,0,1723,
        1724,1,0,0,0,1724,1744,5,195,0,0,1725,1727,5,15,0,0,1726,1728,5,
        227,0,0,1727,1726,1,0,0,0,1727,1728,1,0,0,0,1728,1729,1,0,0,0,1729,
        1744,5,228,0,0,1730,1731,5,17,0,0,1731,1732,5,18,0,0,1732,1735,3,
        202,101,0,1733,1736,5,139,0,0,1734,1736,3,206,103,0,1735,1733,1,
        0,0,0,1735,1734,1,0,0,0,1736,1744,1,0,0,0,1737,1744,5,19,0,0,1738,
        1739,5,63,0,0,1739,1740,7,2,0,0,1740,1741,5,195,0,0,1741,1744,5,
        195,0,0,1742,1744,5,64,0,0,1743,1705,1,0,0,0,1743,1706,1,0,0,0,1743,
        1707,1,0,0,0,1743,1709,1,0,0,0,1743,1713,1,0,0,0,1743,1715,1,0,0,
        0,1743,1720,1,0,0,0,1743,1725,1,0,0,0,1743,1730,1,0,0,0,1743,1737,
        1,0,0,0,1743,1738,1,0,0,0,1743,1742,1,0,0,0,1744,153,1,0,0,0,1745,
        1746,5,4,0,0,1746,1747,3,190,95,0,1747,1748,3,190,95,0,1748,1749,
        3,190,95,0,1749,1750,3,190,95,0,1750,1751,3,190,95,0,1751,1752,3,
        190,95,0,1752,1753,3,190,95,0,1753,1754,3,190,95,0,1754,1755,3,190,
        95,0,1755,1756,3,190,95,0,1756,1758,3,190,95,0,1757,1759,3,190,95,
        0,1758,1757,1,0,0,0,1758,1759,1,0,0,0,1759,155,1,0,0,0,1760,1813,
        3,158,79,0,1761,1813,3,250,125,0,1762,1813,3,206,103,0,1763,1765,
        5,43,0,0,1764,1766,5,208,0,0,1765,1764,1,0,0,0,1765,1766,1,0,0,0,
        1766,1767,1,0,0,0,1767,1768,3,208,104,0,1768,1769,3,202,101,0,1769,
        1813,1,0,0,0,1770,1772,5,14,0,0,1771,1773,5,208,0,0,1772,1771,1,
        0,0,0,1772,1773,1,0,0,0,1773,1774,1,0,0,0,1774,1813,5,195,0,0,1775,
        1777,5,15,0,0,1776,1778,5,227,0,0,1777,1776,1,0,0,0,1777,1778,1,
        0,0,0,1778,1779,1,0,0,0,1779,1780,5,229,0,0,1780,1813,5,228,0,0,
        1781,1783,5,99,0,0,1782,1784,5,208,0,0,1783,1782,1,0,0,0,1783,1784,
        1,0,0,0,1784,1785,1,0,0,0,1785,1786,3,208,104,0,1786,1787,3,202,
        101,0,1787,1813,1,0,0,0,1788,1790,5,100,0,0,1789,1791,5,208,0,0,
        1790,1789,1,0,0,0,1790,1791,1,0,0,0,1791,1792,1,0,0,0,1792,1793,
        3,208,104,0,1793,1794,3,202,101,0,1794,1813,1,0,0,0,1795,1797,5,
        101,0,0,1796,1798,5,208,0,0,1797,1796,1,0,0,0,1797,1798,1,0,0,0,
        1798,1799,1,0,0,0,1799,1800,3,208,104,0,1800,1801,3,202,101,0,1801,
        1802,3,202,101,0,1802,1813,1,0,0,0,1803,1804,5,17,0,0,1804,1805,
        5,18,0,0,1805,1808,3,202,101,0,1806,1809,5,139,0,0,1807,1809,3,206,
        103,0,1808,1806,1,0,0,0,1808,1807,1,0,0,0,1809,1813,1,0,0,0,1810,
        1813,5,19,0,0,1811,1813,5,102,0,0,1812,1760,1,0,0,0,1812,1761,1,
        0,0,0,1812,1762,1,0,0,0,1812,1763,1,0,0,0,1812,1770,1,0,0,0,1812,
        1775,1,0,0,0,1812,1781,1,0,0,0,1812,1788,1,0,0,0,1812,1795,1,0,0,
        0,1812,1803,1,0,0,0,1812,1810,1,0,0,0,1812,1811,1,0,0,0,1813,157,
        1,0,0,0,1814,1815,5,4,0,0,1815,1816,3,190,95,0,1816,1817,3,190,95,
        0,1817,1819,3,198,99,0,1818,1820,3,198,99,0,1819,1818,1,0,0,0,1819,
        1820,1,0,0,0,1820,159,1,0,0,0,1821,1863,3,162,81,0,1822,1863,3,252,
        126,0,1823,1863,3,206,103,0,1824,1825,5,104,0,0,1825,1863,5,195,
        0,0,1826,1827,5,42,0,0,1827,1828,3,202,101,0,1828,1829,3,202,101,
        0,1829,1863,1,0,0,0,1830,1832,5,43,0,0,1831,1833,5,208,0,0,1832,
        1831,1,0,0,0,1832,1833,1,0,0,0,1833,1834,1,0,0,0,1834,1863,3,202,
        101,0,1835,1837,5,14,0,0,1836,1838,5,208,0,0,1837,1836,1,0,0,0,1837,
        1838,1,0,0,0,1838,1839,1,0,0,0,1839,1863,5,195,0,0,1840,1841,5,17,
        0,0,1841,1842,5,18,0,0,1842,1845,3,202,101,0,1843,1846,5,139,0,0,
        1844,1846,3,206,103,0,1845,1843,1,0,0,0,1845,1844,1,0,0,0,1846,1863,
        1,0,0,0,1847,1863,5,19,0,0,1848,1849,5,105,0,0,1849,1863,5,202,0,
        0,1850,1851,5,106,0,0,1851,1852,3,202,101,0,1852,1853,5,195,0,0,
        1853,1863,1,0,0,0,1854,1863,5,107,0,0,1855,1863,5,108,0,0,1856,1863,
        5,109,0,0,1857,1863,5,110,0,0,1858,1863,5,111,0,0,1859,1863,5,112,
        0,0,1860,1861,5,113,0,0,1861,1863,5,195,0,0,1862,1821,1,0,0,0,1862,
        1822,1,0,0,0,1862,1823,1,0,0,0,1862,1824,1,0,0,0,1862,1826,1,0,0,
        0,1862,1830,1,0,0,0,1862,1835,1,0,0,0,1862,1840,1,0,0,0,1862,1847,
        1,0,0,0,1862,1848,1,0,0,0,1862,1850,1,0,0,0,1862,1854,1,0,0,0,1862,
        1855,1,0,0,0,1862,1856,1,0,0,0,1862,1857,1,0,0,0,1862,1858,1,0,0,
        0,1862,1859,1,0,0,0,1862,1860,1,0,0,0,1863,161,1,0,0,0,1864,1865,
        5,4,0,0,1865,1866,3,190,95,0,1866,1867,3,190,95,0,1867,1868,3,190,
        95,0,1868,1869,3,190,95,0,1869,1870,3,190,95,0,1870,1872,3,198,99,
        0,1871,1873,3,198,99,0,1872,1871,1,0,0,0,1872,1873,1,0,0,0,1873,
        1875,1,0,0,0,1874,1876,3,198,99,0,1875,1874,1,0,0,0,1875,1876,1,
        0,0,0,1876,163,1,0,0,0,1877,1909,3,166,83,0,1878,1909,3,206,103,
        0,1879,1880,5,104,0,0,1880,1909,5,195,0,0,1881,1882,5,42,0,0,1882,
        1883,3,202,101,0,1883,1884,3,202,101,0,1884,1909,1,0,0,0,1885,1887,
        5,43,0,0,1886,1888,5,208,0,0,1887,1886,1,0,0,0,1887,1888,1,0,0,0,
        1888,1889,1,0,0,0,1889,1909,3,202,101,0,1890,1892,5,14,0,0,1891,
        1893,5,208,0,0,1892,1891,1,0,0,0,1892,1893,1,0,0,0,1893,1894,1,0,
        0,0,1894,1909,5,195,0,0,1895,1909,5,107,0,0,1896,1909,5,108,0,0,
        1897,1909,5,106,0,0,1898,1909,5,109,0,0,1899,1909,5,110,0,0,1900,
        1909,5,113,0,0,1901,1902,5,17,0,0,1902,1909,5,18,0,0,1903,1909,5,
        19,0,0,1904,1905,5,105,0,0,1905,1909,5,202,0,0,1906,1909,5,111,0,
        0,1907,1909,5,112,0,0,1908,1877,1,0,0,0,1908,1878,1,0,0,0,1908,1879,
        1,0,0,0,1908,1881,1,0,0,0,1908,1885,1,0,0,0,1908,1890,1,0,0,0,1908,
        1895,1,0,0,0,1908,1896,1,0,0,0,1908,1897,1,0,0,0,1908,1898,1,0,0,
        0,1908,1899,1,0,0,0,1908,1900,1,0,0,0,1908,1901,1,0,0,0,1908,1903,
        1,0,0,0,1908,1904,1,0,0,0,1908,1906,1,0,0,0,1908,1907,1,0,0,0,1909,
        165,1,0,0,0,1910,1911,5,4,0,0,1911,1912,3,190,95,0,1912,1913,3,190,
        95,0,1913,1914,3,190,95,0,1914,1915,3,190,95,0,1915,1916,3,190,95,
        0,1916,1917,3,190,95,0,1917,1919,3,198,99,0,1918,1920,3,198,99,0,
        1919,1918,1,0,0,0,1919,1920,1,0,0,0,1920,167,1,0,0,0,1921,1938,3,
        170,85,0,1922,1938,3,206,103,0,1923,1925,5,43,0,0,1924,1926,5,208,
        0,0,1925,1924,1,0,0,0,1925,1926,1,0,0,0,1926,1927,1,0,0,0,1927,1938,
        3,202,101,0,1928,1930,5,14,0,0,1929,1931,5,208,0,0,1930,1929,1,0,
        0,0,1930,1931,1,0,0,0,1931,1932,1,0,0,0,1932,1938,5,195,0,0,1933,
        1934,5,17,0,0,1934,1935,5,18,0,0,1935,1938,3,202,101,0,1936,1938,
        5,19,0,0,1937,1921,1,0,0,0,1937,1922,1,0,0,0,1937,1923,1,0,0,0,1937,
        1928,1,0,0,0,1937,1933,1,0,0,0,1937,1936,1,0,0,0,1938,169,1,0,0,
        0,1939,1940,5,4,0,0,1940,1941,3,190,95,0,1941,1942,3,190,95,0,1942,
        1943,3,198,99,0,1943,1944,3,198,99,0,1944,1945,3,198,99,0,1945,171,
        1,0,0,0,1946,1969,3,174,87,0,1947,1969,3,206,103,0,1948,1949,5,117,
        0,0,1949,1969,5,195,0,0,1950,1951,5,42,0,0,1951,1969,3,202,101,0,
        1952,1954,5,43,0,0,1953,1955,5,208,0,0,1954,1953,1,0,0,0,1954,1955,
        1,0,0,0,1955,1956,1,0,0,0,1956,1969,3,202,101,0,1957,1959,5,14,0,
        0,1958,1960,5,208,0,0,1959,1958,1,0,0,0,1959,1960,1,0,0,0,1960,1961,
        1,0,0,0,1961,1969,5,195,0,0,1962,1963,5,17,0,0,1963,1964,5,18,0,
        0,1964,1969,3,202,101,0,1965,1969,5,19,0,0,1966,1967,5,113,0,0,1967,
        1969,5,195,0,0,1968,1946,1,0,0,0,1968,1947,1,0,0,0,1968,1948,1,0,
        0,0,1968,1950,1,0,0,0,1968,1952,1,0,0,0,1968,1957,1,0,0,0,1968,1962,
        1,0,0,0,1968,1965,1,0,0,0,1968,1966,1,0,0,0,1969,173,1,0,0,0,1970,
        1971,5,4,0,0,1971,1972,3,190,95,0,1972,1973,3,190,95,0,1973,1974,
        3,190,95,0,1974,1976,3,198,99,0,1975,1977,3,198,99,0,1976,1975,1,
        0,0,0,1976,1977,1,0,0,0,1977,175,1,0,0,0,1978,1996,3,178,89,0,1979,
        1996,3,254,127,0,1980,1996,3,206,103,0,1981,1983,5,43,0,0,1982,1984,
        5,208,0,0,1983,1982,1,0,0,0,1983,1984,1,0,0,0,1984,1985,1,0,0,0,
        1985,1996,3,202,101,0,1986,1988,5,14,0,0,1987,1989,5,208,0,0,1988,
        1987,1,0,0,0,1988,1989,1,0,0,0,1989,1990,1,0,0,0,1990,1996,5,195,
        0,0,1991,1992,5,17,0,0,1992,1993,5,18,0,0,1993,1996,3,202,101,0,
        1994,1996,5,19,0,0,1995,1978,1,0,0,0,1995,1979,1,0,0,0,1995,1980,
        1,0,0,0,1995,1981,1,0,0,0,1995,1986,1,0,0,0,1995,1991,1,0,0,0,1995,
        1994,1,0,0,0,1996,177,1,0,0,0,1997,1998,5,4,0,0,1998,1999,3,190,
        95,0,1999,2000,3,190,95,0,2000,2001,3,190,95,0,2001,179,1,0,0,0,
        2002,2070,3,182,91,0,2003,2070,3,256,128,0,2004,2006,5,120,0,0,2005,
        2007,5,208,0,0,2006,2005,1,0,0,0,2006,2007,1,0,0,0,2007,2008,1,0,
        0,0,2008,2070,3,202,101,0,2009,2011,5,121,0,0,2010,2012,5,208,0,
        0,2011,2010,1,0,0,0,2011,2012,1,0,0,0,2012,2013,1,0,0,0,2013,2070,
        3,202,101,0,2014,2016,5,122,0,0,2015,2017,5,208,0,0,2016,2015,1,
        0,0,0,2016,2017,1,0,0,0,2017,2018,1,0,0,0,2018,2070,5,195,0,0,2019,
        2021,5,123,0,0,2020,2022,5,208,0,0,2021,2020,1,0,0,0,2021,2022,1,
        0,0,0,2022,2023,1,0,0,0,2023,2070,5,195,0,0,2024,2026,5,124,0,0,
        2025,2027,5,208,0,0,2026,2025,1,0,0,0,2026,2027,1,0,0,0,2027,2028,
        1,0,0,0,2028,2070,5,195,0,0,2029,2031,5,125,0,0,2030,2032,5,208,
        0,0,2031,2030,1,0,0,0,2031,2032,1,0,0,0,2032,2033,1,0,0,0,2033,2070,
        5,202,0,0,2034,2036,5,126,0,0,2035,2037,5,208,0,0,2036,2035,1,0,
        0,0,2036,2037,1,0,0,0,2037,2038,1,0,0,0,2038,2070,3,202,101,0,2039,
        2041,5,127,0,0,2040,2042,5,208,0,0,2041,2040,1,0,0,0,2041,2042,1,
        0,0,0,2042,2043,1,0,0,0,2043,2070,3,202,101,0,2044,2046,5,128,0,
        0,2045,2047,5,208,0,0,2046,2045,1,0,0,0,2046,2047,1,0,0,0,2047,2048,
        1,0,0,0,2048,2070,3,202,101,0,2049,2051,5,129,0,0,2050,2052,5,208,
        0,0,2051,2050,1,0,0,0,2051,2052,1,0,0,0,2052,2053,1,0,0,0,2053,2070,
        3,202,101,0,2054,2056,5,130,0,0,2055,2057,5,208,0,0,2056,2055,1,
        0,0,0,2056,2057,1,0,0,0,2057,2058,1,0,0,0,2058,2070,5,195,0,0,2059,
        2061,5,131,0,0,2060,2062,5,208,0,0,2061,2060,1,0,0,0,2061,2062,1,
        0,0,0,2062,2063,1,0,0,0,2063,2070,5,195,0,0,2064,2066,5,132,0,0,
        2065,2067,5,208,0,0,2066,2065,1,0,0,0,2066,2067,1,0,0,0,2067,2068,
        1,0,0,0,2068,2070,5,195,0,0,2069,2002,1,0,0,0,2069,2003,1,0,0,0,
        2069,2004,1,0,0,0,2069,2009,1,0,0,0,2069,2014,1,0,0,0,2069,2019,
        1,0,0,0,2069,2024,1,0,0,0,2069,2029,1,0,0,0,2069,2034,1,0,0,0,2069,
        2039,1,0,0,0,2069,2044,1,0,0,0,2069,2049,1,0,0,0,2069,2054,1,0,0,
        0,2069,2059,1,0,0,0,2069,2064,1,0,0,0,2070,181,1,0,0,0,2071,2072,
        5,4,0,0,2072,2073,3,190,95,0,2073,2074,3,190,95,0,2074,183,1,0,0,
        0,2075,2076,5,135,0,0,2076,2080,5,37,0,0,2077,2079,3,186,93,0,2078,
        2077,1,0,0,0,2079,2082,1,0,0,0,2080,2078,1,0,0,0,2080,2081,1,0,0,
        0,2081,2083,1,0,0,0,2082,2080,1,0,0,0,2083,2084,5,2,0,0,2084,185,
        1,0,0,0,2085,2089,5,54,0,0,2086,2088,3,188,94,0,2087,2086,1,0,0,
        0,2088,2091,1,0,0,0,2089,2087,1,0,0,0,2089,2090,1,0,0,0,2090,2092,
        1,0,0,0,2091,2089,1,0,0,0,2092,2096,5,2,0,0,2093,2096,5,55,0,0,2094,
        2096,5,40,0,0,2095,2085,1,0,0,0,2095,2093,1,0,0,0,2095,2094,1,0,
        0,0,2096,187,1,0,0,0,2097,2099,5,136,0,0,2098,2100,5,208,0,0,2099,
        2098,1,0,0,0,2099,2100,1,0,0,0,2100,2101,1,0,0,0,2101,2113,3,190,
        95,0,2102,2104,5,137,0,0,2103,2105,5,208,0,0,2104,2103,1,0,0,0,2104,
        2105,1,0,0,0,2105,2106,1,0,0,0,2106,2113,3,202,101,0,2107,2109,5,
        57,0,0,2108,2110,5,208,0,0,2109,2108,1,0,0,0,2109,2110,1,0,0,0,2110,
        2111,1,0,0,0,2111,2113,3,202,101,0,2112,2097,1,0,0,0,2112,2102,1,
        0,0,0,2112,2107,1,0,0,0,2113,189,1,0,0,0,2114,2115,5,205,0,0,2115,
        2116,3,192,96,0,2116,2117,5,206,0,0,2117,191,1,0,0,0,2118,2123,3,
        194,97,0,2119,2120,5,190,0,0,2120,2122,3,194,97,0,2121,2119,1,0,
        0,0,2122,2125,1,0,0,0,2123,2121,1,0,0,0,2123,2124,1,0,0,0,2124,193,
        1,0,0,0,2125,2123,1,0,0,0,2126,2131,3,196,98,0,2127,2128,5,191,0,
        0,2128,2130,3,196,98,0,2129,2127,1,0,0,0,2130,2133,1,0,0,0,2131,
        2129,1,0,0,0,2131,2132,1,0,0,0,2132,195,1,0,0,0,2133,2131,1,0,0,
        0,2134,2135,6,98,-1,0,2135,2136,5,205,0,0,2136,2137,3,192,96,0,2137,
        2138,5,206,0,0,2138,2274,1,0,0,0,2139,2274,5,139,0,0,2140,2141,5,
        141,0,0,2141,2142,7,3,0,0,2142,2143,7,4,0,0,2143,2274,7,3,0,0,2144,
        2146,5,142,0,0,2145,2147,5,220,0,0,2146,2145,1,0,0,0,2146,2147,1,
        0,0,0,2147,2148,1,0,0,0,2148,2149,5,221,0,0,2149,2150,5,222,0,0,
        2150,2274,3,200,100,0,2151,2152,5,143,0,0,2152,2274,3,196,98,29,
        2153,2154,5,144,0,0,2154,2274,3,196,98,28,2155,2156,5,145,0,0,2156,
        2274,3,196,98,27,2157,2165,5,146,0,0,2158,2166,5,203,0,0,2159,2162,
        5,202,0,0,2160,2161,5,207,0,0,2161,2163,5,202,0,0,2162,2160,1,0,
        0,0,2162,2163,1,0,0,0,2163,2166,1,0,0,0,2164,2166,5,214,0,0,2165,
        2158,1,0,0,0,2165,2159,1,0,0,0,2165,2164,1,0,0,0,2166,2274,1,0,0,
        0,2167,2274,5,147,0,0,2168,2169,5,148,0,0,2169,2274,5,195,0,0,2170,
        2274,5,149,0,0,2171,2184,5,150,0,0,2172,2185,5,203,0,0,2173,2176,
        5,202,0,0,2174,2175,5,207,0,0,2175,2177,5,202,0,0,2176,2174,1,0,
        0,0,2176,2177,1,0,0,0,2177,2185,1,0,0,0,2178,2181,5,198,0,0,2179,
        2180,5,207,0,0,2180,2182,5,198,0,0,2181,2179,1,0,0,0,2181,2182,1,
        0,0,0,2182,2185,1,0,0,0,2183,2185,5,214,0,0,2184,2172,1,0,0,0,2184,
        2173,1,0,0,0,2184,2178,1,0,0,0,2184,2183,1,0,0,0,2185,2274,1,0,0,
        0,2186,2187,5,192,0,0,2187,2274,3,196,98,21,2188,2189,5,151,0,0,
        2189,2190,5,205,0,0,2190,2192,3,200,100,0,2191,2193,5,193,0,0,2192,
        2191,1,0,0,0,2192,2193,1,0,0,0,2193,2194,1,0,0,0,2194,2196,3,200,
        100,0,2195,2197,5,193,0,0,2196,2195,1,0,0,0,2196,2197,1,0,0,0,2197,
        2198,1,0,0,0,2198,2199,3,200,100,0,2199,2200,5,206,0,0,2200,2201,
        5,152,0,0,2201,2202,3,200,100,0,2202,2274,1,0,0,0,2203,2204,5,151,
        0,0,2204,2205,5,205,0,0,2205,2207,5,188,0,0,2206,2208,5,208,0,0,
        2207,2206,1,0,0,0,2207,2208,1,0,0,0,2208,2209,1,0,0,0,2209,2211,
        3,190,95,0,2210,2212,5,193,0,0,2211,2210,1,0,0,0,2211,2212,1,0,0,
        0,2212,2218,1,0,0,0,2213,2215,5,189,0,0,2214,2216,5,208,0,0,2215,
        2214,1,0,0,0,2215,2216,1,0,0,0,2216,2217,1,0,0,0,2217,2219,3,190,
        95,0,2218,2213,1,0,0,0,2218,2219,1,0,0,0,2219,2220,1,0,0,0,2220,
        2221,5,206,0,0,2221,2222,5,152,0,0,2222,2223,3,200,100,0,2223,2274,
        1,0,0,0,2224,2274,5,153,0,0,2225,2274,5,154,0,0,2226,2234,5,155,
        0,0,2227,2235,5,204,0,0,2228,2231,5,195,0,0,2229,2230,5,207,0,0,
        2230,2232,5,195,0,0,2231,2229,1,0,0,0,2231,2232,1,0,0,0,2232,2235,
        1,0,0,0,2233,2235,5,214,0,0,2234,2227,1,0,0,0,2234,2228,1,0,0,0,
        2234,2233,1,0,0,0,2235,2274,1,0,0,0,2236,2244,5,156,0,0,2237,2245,
        5,203,0,0,2238,2241,5,202,0,0,2239,2240,5,207,0,0,2240,2242,5,202,
        0,0,2241,2239,1,0,0,0,2241,2242,1,0,0,0,2242,2245,1,0,0,0,2243,2245,
        5,214,0,0,2244,2237,1,0,0,0,2244,2238,1,0,0,0,2244,2243,1,0,0,0,
        2245,2274,1,0,0,0,2246,2259,5,158,0,0,2247,2260,5,203,0,0,2248,2251,
        5,202,0,0,2249,2250,5,207,0,0,2250,2252,5,202,0,0,2251,2249,1,0,
        0,0,2251,2252,1,0,0,0,2252,2260,1,0,0,0,2253,2256,5,198,0,0,2254,
        2255,5,207,0,0,2255,2257,5,198,0,0,2256,2254,1,0,0,0,2256,2257,1,
        0,0,0,2257,2260,1,0,0,0,2258,2260,5,214,0,0,2259,2247,1,0,0,0,2259,
        2248,1,0,0,0,2259,2253,1,0,0,0,2259,2258,1,0,0,0,2260,2274,1,0,0,
        0,2261,2274,5,159,0,0,2262,2274,5,160,0,0,2263,2274,5,161,0,0,2264,
        2274,5,162,0,0,2265,2274,5,163,0,0,2266,2274,5,164,0,0,2267,2274,
        5,165,0,0,2268,2274,5,166,0,0,2269,2274,5,167,0,0,2270,2274,5,168,
        0,0,2271,2274,5,133,0,0,2272,2274,5,134,0,0,2273,2134,1,0,0,0,2273,
        2139,1,0,0,0,2273,2140,1,0,0,0,2273,2144,1,0,0,0,2273,2151,1,0,0,
        0,2273,2153,1,0,0,0,2273,2155,1,0,0,0,2273,2157,1,0,0,0,2273,2167,
        1,0,0,0,2273,2168,1,0,0,0,2273,2170,1,0,0,0,2273,2171,1,0,0,0,2273,
        2186,1,0,0,0,2273,2188,1,0,0,0,2273,2203,1,0,0,0,2273,2224,1,0,0,
        0,2273,2225,1,0,0,0,2273,2226,1,0,0,0,2273,2236,1,0,0,0,2273,2246,
        1,0,0,0,2273,2261,1,0,0,0,2273,2262,1,0,0,0,2273,2263,1,0,0,0,2273,
        2264,1,0,0,0,2273,2265,1,0,0,0,2273,2266,1,0,0,0,2273,2267,1,0,0,
        0,2273,2268,1,0,0,0,2273,2269,1,0,0,0,2273,2270,1,0,0,0,2273,2271,
        1,0,0,0,2273,2272,1,0,0,0,2274,2283,1,0,0,0,2275,2276,10,32,0,0,
        2276,2277,5,140,0,0,2277,2282,3,200,100,0,2278,2279,10,14,0,0,2279,
        2280,5,157,0,0,2280,2282,3,200,100,0,2281,2275,1,0,0,0,2281,2278,
        1,0,0,0,2282,2285,1,0,0,0,2283,2281,1,0,0,0,2283,2284,1,0,0,0,2284,
        197,1,0,0,0,2285,2283,1,0,0,0,2286,2287,7,5,0,0,2287,199,1,0,0,0,
        2288,2289,7,6,0,0,2289,201,1,0,0,0,2290,2291,7,5,0,0,2291,203,1,
        0,0,0,2292,2293,7,6,0,0,2293,205,1,0,0,0,2294,2296,5,9,0,0,2295,
        2297,5,208,0,0,2296,2295,1,0,0,0,2296,2297,1,0,0,0,2297,2298,1,0,
        0,0,2298,2299,3,208,104,0,2299,207,1,0,0,0,2300,2301,7,7,0,0,2301,
        209,1,0,0,0,2302,2313,5,138,0,0,2303,2311,5,237,0,0,2304,2306,5,
        240,0,0,2305,2304,1,0,0,0,2306,2309,1,0,0,0,2307,2305,1,0,0,0,2307,
        2308,1,0,0,0,2308,2312,1,0,0,0,2309,2307,1,0,0,0,2310,2312,5,241,
        0,0,2311,2307,1,0,0,0,2311,2310,1,0,0,0,2312,2314,1,0,0,0,2313,2303,
        1,0,0,0,2313,2314,1,0,0,0,2314,2315,1,0,0,0,2315,2319,5,238,0,0,
        2316,2318,5,240,0,0,2317,2316,1,0,0,0,2318,2321,1,0,0,0,2319,2317,
        1,0,0,0,2319,2320,1,0,0,0,2320,2322,1,0,0,0,2321,2319,1,0,0,0,2322,
        2323,5,239,0,0,2323,211,1,0,0,0,2324,2325,5,169,0,0,2325,2326,3,
        214,107,0,2326,2327,3,190,95,0,2327,213,1,0,0,0,2328,2329,7,8,0,
        0,2329,2330,3,216,108,0,2330,2331,5,243,0,0,2331,2335,1,0,0,0,2332,
        2333,5,172,0,0,2333,2335,3,224,112,0,2334,2328,1,0,0,0,2334,2332,
        1,0,0,0,2335,215,1,0,0,0,2336,2339,5,253,0,0,2337,2338,5,244,0,0,
        2338,2340,3,218,109,0,2339,2337,1,0,0,0,2339,2340,1,0,0,0,2340,217,
        1,0,0,0,2341,2344,3,220,110,0,2342,2343,7,9,0,0,2343,2345,3,218,
        109,0,2344,2342,1,0,0,0,2344,2345,1,0,0,0,2345,219,1,0,0,0,2346,
        2354,5,253,0,0,2347,2354,3,222,111,0,2348,2354,5,251,0,0,2349,2354,
        5,252,0,0,2350,2354,5,277,0,0,2351,2354,5,276,0,0,2352,2354,5,278,
        0,0,2353,2346,1,0,0,0,2353,2347,1,0,0,0,2353,2348,1,0,0,0,2353,2349,
        1,0,0,0,2353,2350,1,0,0,0,2353,2351,1,0,0,0,2353,2352,1,0,0,0,2354,
        221,1,0,0,0,2355,2356,5,254,0,0,2356,2357,5,280,0,0,2357,2358,3,
        220,110,0,2358,2359,5,243,0,0,2359,2475,1,0,0,0,2360,2361,5,255,
        0,0,2361,2362,5,280,0,0,2362,2363,3,220,110,0,2363,2364,5,243,0,
        0,2364,2475,1,0,0,0,2365,2366,5,257,0,0,2366,2367,5,280,0,0,2367,
        2368,3,220,110,0,2368,2369,5,243,0,0,2369,2475,1,0,0,0,2370,2371,
        5,258,0,0,2371,2372,5,280,0,0,2372,2373,3,220,110,0,2373,2374,5,
        243,0,0,2374,2475,1,0,0,0,2375,2376,5,259,0,0,2376,2377,5,280,0,
        0,2377,2378,3,220,110,0,2378,2379,5,243,0,0,2379,2475,1,0,0,0,2380,
        2381,5,260,0,0,2381,2382,5,280,0,0,2382,2383,3,220,110,0,2383,2384,
        5,243,0,0,2384,2475,1,0,0,0,2385,2386,5,261,0,0,2386,2387,5,280,
        0,0,2387,2388,3,220,110,0,2388,2389,5,243,0,0,2389,2475,1,0,0,0,
        2390,2391,5,262,0,0,2391,2392,5,280,0,0,2392,2393,3,220,110,0,2393,
        2394,5,243,0,0,2394,2475,1,0,0,0,2395,2396,5,263,0,0,2396,2397,5,
        280,0,0,2397,2398,3,220,110,0,2398,2399,5,243,0,0,2399,2475,1,0,
        0,0,2400,2401,5,264,0,0,2401,2402,5,280,0,0,2402,2403,3,220,110,
        0,2403,2404,5,243,0,0,2404,2475,1,0,0,0,2405,2406,5,265,0,0,2406,
        2407,5,280,0,0,2407,2408,3,220,110,0,2408,2409,5,243,0,0,2409,2475,
        1,0,0,0,2410,2411,5,266,0,0,2411,2412,5,280,0,0,2412,2417,3,220,
        110,0,2413,2414,5,250,0,0,2414,2416,3,220,110,0,2415,2413,1,0,0,
        0,2416,2419,1,0,0,0,2417,2415,1,0,0,0,2417,2418,1,0,0,0,2418,2420,
        1,0,0,0,2419,2417,1,0,0,0,2420,2421,5,243,0,0,2421,2475,1,0,0,0,
        2422,2423,5,267,0,0,2423,2424,5,280,0,0,2424,2425,3,220,110,0,2425,
        2426,5,243,0,0,2426,2475,1,0,0,0,2427,2428,5,268,0,0,2428,2429,5,
        280,0,0,2429,2434,3,220,110,0,2430,2431,5,250,0,0,2431,2433,3,220,
        110,0,2432,2430,1,0,0,0,2433,2436,1,0,0,0,2434,2432,1,0,0,0,2434,
        2435,1,0,0,0,2435,2437,1,0,0,0,2436,2434,1,0,0,0,2437,2438,5,243,
        0,0,2438,2475,1,0,0,0,2439,2440,5,269,0,0,2440,2441,5,280,0,0,2441,
        2442,3,220,110,0,2442,2443,5,250,0,0,2443,2444,3,220,110,0,2444,
        2445,5,243,0,0,2445,2475,1,0,0,0,2446,2447,5,270,0,0,2447,2448,5,
        280,0,0,2448,2449,3,220,110,0,2449,2450,5,243,0,0,2450,2475,1,0,
        0,0,2451,2452,5,271,0,0,2452,2453,5,280,0,0,2453,2475,5,243,0,0,
        2454,2455,5,272,0,0,2455,2456,5,280,0,0,2456,2457,3,220,110,0,2457,
        2458,5,243,0,0,2458,2475,1,0,0,0,2459,2460,5,273,0,0,2460,2461,5,
        280,0,0,2461,2462,3,220,110,0,2462,2463,5,243,0,0,2463,2475,1,0,
        0,0,2464,2465,5,274,0,0,2465,2466,5,280,0,0,2466,2467,3,220,110,
        0,2467,2468,5,243,0,0,2468,2475,1,0,0,0,2469,2470,5,275,0,0,2470,
        2471,5,280,0,0,2471,2472,3,220,110,0,2472,2473,5,243,0,0,2473,2475,
        1,0,0,0,2474,2355,1,0,0,0,2474,2360,1,0,0,0,2474,2365,1,0,0,0,2474,
        2370,1,0,0,0,2474,2375,1,0,0,0,2474,2380,1,0,0,0,2474,2385,1,0,0,
        0,2474,2390,1,0,0,0,2474,2395,1,0,0,0,2474,2400,1,0,0,0,2474,2405,
        1,0,0,0,2474,2410,1,0,0,0,2474,2422,1,0,0,0,2474,2427,1,0,0,0,2474,
        2439,1,0,0,0,2474,2446,1,0,0,0,2474,2451,1,0,0,0,2474,2454,1,0,0,
        0,2474,2459,1,0,0,0,2474,2464,1,0,0,0,2474,2469,1,0,0,0,2475,223,
        1,0,0,0,2476,2477,7,10,0,0,2477,2478,5,282,0,0,2478,2479,5,291,0,
        0,2479,2480,5,283,0,0,2480,225,1,0,0,0,2481,2482,5,173,0,0,2482,
        2483,5,276,0,0,2483,2484,5,244,0,0,2484,2485,3,228,114,0,2485,2486,
        5,243,0,0,2486,227,1,0,0,0,2487,2490,3,220,110,0,2488,2489,7,9,0,
        0,2489,2491,3,228,114,0,2490,2488,1,0,0,0,2490,2491,1,0,0,0,2491,
        229,1,0,0,0,2492,2494,5,174,0,0,2493,2495,3,208,104,0,2494,2493,
        1,0,0,0,2494,2495,1,0,0,0,2495,2496,1,0,0,0,2496,2497,5,175,0,0,
        2497,2498,5,208,0,0,2498,2499,7,11,0,0,2499,2500,5,208,0,0,2500,
        2506,3,190,95,0,2501,2502,5,175,0,0,2502,2503,5,208,0,0,2503,2504,
        7,11,0,0,2504,2505,5,208,0,0,2505,2507,3,190,95,0,2506,2501,1,0,
        0,0,2506,2507,1,0,0,0,2507,2508,1,0,0,0,2508,2509,5,2,0,0,2509,231,
        1,0,0,0,2510,2514,5,177,0,0,2511,2513,3,234,117,0,2512,2511,1,0,
        0,0,2513,2516,1,0,0,0,2514,2512,1,0,0,0,2514,2515,1,0,0,0,2515,2517,
        1,0,0,0,2516,2514,1,0,0,0,2517,2518,5,2,0,0,2518,233,1,0,0,0,2519,
        2520,5,96,0,0,2520,2521,5,202,0,0,2521,2522,5,202,0,0,2522,2523,
        5,202,0,0,2523,2524,3,202,101,0,2524,2529,3,202,101,0,2525,2526,
        5,178,0,0,2526,2527,3,202,101,0,2527,2528,3,202,101,0,2528,2530,
        1,0,0,0,2529,2525,1,0,0,0,2529,2530,1,0,0,0,2530,2575,1,0,0,0,2531,
        2532,5,143,0,0,2532,2533,5,202,0,0,2533,2534,5,202,0,0,2534,2535,
        3,202,101,0,2535,2536,3,202,101,0,2536,2575,1,0,0,0,2537,2538,7,
        12,0,0,2538,2539,5,202,0,0,2539,2540,5,202,0,0,2540,2541,5,202,0,
        0,2541,2544,5,202,0,0,2542,2543,5,179,0,0,2543,2545,5,195,0,0,2544,
        2542,1,0,0,0,2544,2545,1,0,0,0,2545,2546,1,0,0,0,2546,2547,3,202,
        101,0,2547,2548,5,195,0,0,2548,2549,3,202,101,0,2549,2575,1,0,0,
        0,2550,2551,5,180,0,0,2551,2552,5,203,0,0,2552,2553,5,203,0,0,2553,
        2554,3,202,101,0,2554,2555,3,202,101,0,2555,2575,1,0,0,0,2556,2557,
        5,182,0,0,2557,2558,5,202,0,0,2558,2559,5,202,0,0,2559,2560,3,202,
        101,0,2560,2561,3,202,101,0,2561,2562,3,202,101,0,2562,2563,3,202,
        101,0,2563,2575,1,0,0,0,2564,2565,5,183,0,0,2565,2566,5,202,0,0,
        2566,2567,3,202,101,0,2567,2568,3,202,101,0,2568,2569,3,202,101,
        0,2569,2570,3,202,101,0,2570,2575,1,0,0,0,2571,2572,7,13,0,0,2572,
        2575,5,202,0,0,2573,2575,5,185,0,0,2574,2519,1,0,0,0,2574,2531,1,
        0,0,0,2574,2537,1,0,0,0,2574,2550,1,0,0,0,2574,2556,1,0,0,0,2574,
        2564,1,0,0,0,2574,2571,1,0,0,0,2574,2573,1,0,0,0,2575,235,1,0,0,
        0,2576,2577,5,186,0,0,2577,2578,5,298,0,0,2578,2579,5,295,0,0,2579,
        2598,5,293,0,0,2580,2582,5,296,0,0,2581,2580,1,0,0,0,2582,2585,1,
        0,0,0,2583,2581,1,0,0,0,2583,2584,1,0,0,0,2584,2599,1,0,0,0,2585,
        2583,1,0,0,0,2586,2588,5,297,0,0,2587,2586,1,0,0,0,2588,2591,1,0,
        0,0,2589,2587,1,0,0,0,2589,2590,1,0,0,0,2590,2599,1,0,0,0,2591,2589,
        1,0,0,0,2592,2594,5,299,0,0,2593,2592,1,0,0,0,2594,2597,1,0,0,0,
        2595,2593,1,0,0,0,2595,2596,1,0,0,0,2596,2599,1,0,0,0,2597,2595,
        1,0,0,0,2598,2583,1,0,0,0,2598,2589,1,0,0,0,2598,2595,1,0,0,0,2599,
        2600,1,0,0,0,2600,2601,5,294,0,0,2601,2602,5,187,0,0,2602,2608,5,
        302,0,0,2603,2607,3,226,113,0,2604,2607,3,52,26,0,2605,2607,3,2,
        1,0,2606,2603,1,0,0,0,2606,2604,1,0,0,0,2606,2605,1,0,0,0,2607,2610,
        1,0,0,0,2608,2606,1,0,0,0,2608,2609,1,0,0,0,2609,2611,1,0,0,0,2610,
        2608,1,0,0,0,2611,2612,5,2,0,0,2612,2613,5,187,0,0,2613,2614,5,302,
        0,0,2614,237,1,0,0,0,2615,2616,5,186,0,0,2616,2617,5,298,0,0,2617,
        2618,5,295,0,0,2618,2637,5,293,0,0,2619,2621,5,296,0,0,2620,2619,
        1,0,0,0,2621,2624,1,0,0,0,2622,2620,1,0,0,0,2622,2623,1,0,0,0,2623,
        2638,1,0,0,0,2624,2622,1,0,0,0,2625,2627,5,297,0,0,2626,2625,1,0,
        0,0,2627,2630,1,0,0,0,2628,2626,1,0,0,0,2628,2629,1,0,0,0,2629,2638,
        1,0,0,0,2630,2628,1,0,0,0,2631,2633,5,299,0,0,2632,2631,1,0,0,0,
        2633,2636,1,0,0,0,2634,2632,1,0,0,0,2634,2635,1,0,0,0,2635,2638,
        1,0,0,0,2636,2634,1,0,0,0,2637,2622,1,0,0,0,2637,2628,1,0,0,0,2637,
        2634,1,0,0,0,2638,2639,1,0,0,0,2639,2640,5,294,0,0,2640,2641,5,187,
        0,0,2641,2647,5,302,0,0,2642,2646,3,226,113,0,2643,2646,3,60,30,
        0,2644,2646,3,4,2,0,2645,2642,1,0,0,0,2645,2643,1,0,0,0,2645,2644,
        1,0,0,0,2646,2649,1,0,0,0,2647,2645,1,0,0,0,2647,2648,1,0,0,0,2648,
        2650,1,0,0,0,2649,2647,1,0,0,0,2650,2651,5,2,0,0,2651,2652,5,187,
        0,0,2652,2653,5,302,0,0,2653,239,1,0,0,0,2654,2655,5,186,0,0,2655,
        2656,5,298,0,0,2656,2657,5,295,0,0,2657,2676,5,293,0,0,2658,2660,
        5,296,0,0,2659,2658,1,0,0,0,2660,2663,1,0,0,0,2661,2659,1,0,0,0,
        2661,2662,1,0,0,0,2662,2677,1,0,0,0,2663,2661,1,0,0,0,2664,2666,
        5,297,0,0,2665,2664,1,0,0,0,2666,2669,1,0,0,0,2667,2665,1,0,0,0,
        2667,2668,1,0,0,0,2668,2677,1,0,0,0,2669,2667,1,0,0,0,2670,2672,
        5,299,0,0,2671,2670,1,0,0,0,2672,2675,1,0,0,0,2673,2671,1,0,0,0,
        2673,2674,1,0,0,0,2674,2677,1,0,0,0,2675,2673,1,0,0,0,2676,2661,
        1,0,0,0,2676,2667,1,0,0,0,2676,2673,1,0,0,0,2677,2678,1,0,0,0,2678,
        2679,5,294,0,0,2679,2680,5,187,0,0,2680,2686,5,302,0,0,2681,2685,
        3,226,113,0,2682,2685,3,64,32,0,2683,2685,3,6,3,0,2684,2681,1,0,
        0,0,2684,2682,1,0,0,0,2684,2683,1,0,0,0,2685,2688,1,0,0,0,2686,2684,
        1,0,0,0,2686,2687,1,0,0,0,2687,2689,1,0,0,0,2688,2686,1,0,0,0,2689,
        2690,5,2,0,0,2690,2691,5,187,0,0,2691,2692,5,302,0,0,2692,241,1,
        0,0,0,2693,2694,5,186,0,0,2694,2695,5,298,0,0,2695,2696,5,295,0,
        0,2696,2715,5,293,0,0,2697,2699,5,296,0,0,2698,2697,1,0,0,0,2699,
        2702,1,0,0,0,2700,2698,1,0,0,0,2700,2701,1,0,0,0,2701,2716,1,0,0,
        0,2702,2700,1,0,0,0,2703,2705,5,297,0,0,2704,2703,1,0,0,0,2705,2708,
        1,0,0,0,2706,2704,1,0,0,0,2706,2707,1,0,0,0,2707,2716,1,0,0,0,2708,
        2706,1,0,0,0,2709,2711,5,299,0,0,2710,2709,1,0,0,0,2711,2714,1,0,
        0,0,2712,2710,1,0,0,0,2712,2713,1,0,0,0,2713,2716,1,0,0,0,2714,2712,
        1,0,0,0,2715,2700,1,0,0,0,2715,2706,1,0,0,0,2715,2712,1,0,0,0,2716,
        2717,1,0,0,0,2717,2718,5,294,0,0,2718,2719,5,187,0,0,2719,2725,5,
        302,0,0,2720,2724,3,226,113,0,2721,2724,3,94,47,0,2722,2724,3,12,
        6,0,2723,2720,1,0,0,0,2723,2721,1,0,0,0,2723,2722,1,0,0,0,2724,2727,
        1,0,0,0,2725,2723,1,0,0,0,2725,2726,1,0,0,0,2726,2728,1,0,0,0,2727,
        2725,1,0,0,0,2728,2729,5,2,0,0,2729,2730,5,187,0,0,2730,2731,5,302,
        0,0,2731,243,1,0,0,0,2732,2733,5,186,0,0,2733,2734,5,298,0,0,2734,
        2735,5,295,0,0,2735,2754,5,293,0,0,2736,2738,5,296,0,0,2737,2736,
        1,0,0,0,2738,2741,1,0,0,0,2739,2737,1,0,0,0,2739,2740,1,0,0,0,2740,
        2755,1,0,0,0,2741,2739,1,0,0,0,2742,2744,5,297,0,0,2743,2742,1,0,
        0,0,2744,2747,1,0,0,0,2745,2743,1,0,0,0,2745,2746,1,0,0,0,2746,2755,
        1,0,0,0,2747,2745,1,0,0,0,2748,2750,5,299,0,0,2749,2748,1,0,0,0,
        2750,2753,1,0,0,0,2751,2749,1,0,0,0,2751,2752,1,0,0,0,2752,2755,
        1,0,0,0,2753,2751,1,0,0,0,2754,2739,1,0,0,0,2754,2745,1,0,0,0,2754,
        2751,1,0,0,0,2755,2756,1,0,0,0,2756,2757,5,294,0,0,2757,2758,5,187,
        0,0,2758,2764,5,302,0,0,2759,2763,3,226,113,0,2760,2763,3,98,49,
        0,2761,2763,3,14,7,0,2762,2759,1,0,0,0,2762,2760,1,0,0,0,2762,2761,
        1,0,0,0,2763,2766,1,0,0,0,2764,2762,1,0,0,0,2764,2765,1,0,0,0,2765,
        2767,1,0,0,0,2766,2764,1,0,0,0,2767,2768,5,2,0,0,2768,2769,5,187,
        0,0,2769,2770,5,302,0,0,2770,245,1,0,0,0,2771,2772,5,186,0,0,2772,
        2773,5,298,0,0,2773,2774,5,295,0,0,2774,2793,5,293,0,0,2775,2777,
        5,296,0,0,2776,2775,1,0,0,0,2777,2780,1,0,0,0,2778,2776,1,0,0,0,
        2778,2779,1,0,0,0,2779,2794,1,0,0,0,2780,2778,1,0,0,0,2781,2783,
        5,297,0,0,2782,2781,1,0,0,0,2783,2786,1,0,0,0,2784,2782,1,0,0,0,
        2784,2785,1,0,0,0,2785,2794,1,0,0,0,2786,2784,1,0,0,0,2787,2789,
        5,299,0,0,2788,2787,1,0,0,0,2789,2792,1,0,0,0,2790,2788,1,0,0,0,
        2790,2791,1,0,0,0,2791,2794,1,0,0,0,2792,2790,1,0,0,0,2793,2778,
        1,0,0,0,2793,2784,1,0,0,0,2793,2790,1,0,0,0,2794,2795,1,0,0,0,2795,
        2796,5,294,0,0,2796,2797,5,187,0,0,2797,2803,5,302,0,0,2798,2802,
        3,226,113,0,2799,2802,3,132,66,0,2800,2802,3,22,11,0,2801,2798,1,
        0,0,0,2801,2799,1,0,0,0,2801,2800,1,0,0,0,2802,2805,1,0,0,0,2803,
        2801,1,0,0,0,2803,2804,1,0,0,0,2804,2806,1,0,0,0,2805,2803,1,0,0,
        0,2806,2807,5,2,0,0,2807,2808,5,187,0,0,2808,2809,5,302,0,0,2809,
        247,1,0,0,0,2810,2811,5,186,0,0,2811,2812,5,298,0,0,2812,2813,5,
        295,0,0,2813,2832,5,293,0,0,2814,2816,5,296,0,0,2815,2814,1,0,0,
        0,2816,2819,1,0,0,0,2817,2815,1,0,0,0,2817,2818,1,0,0,0,2818,2833,
        1,0,0,0,2819,2817,1,0,0,0,2820,2822,5,297,0,0,2821,2820,1,0,0,0,
        2822,2825,1,0,0,0,2823,2821,1,0,0,0,2823,2824,1,0,0,0,2824,2833,
        1,0,0,0,2825,2823,1,0,0,0,2826,2828,5,299,0,0,2827,2826,1,0,0,0,
        2828,2831,1,0,0,0,2829,2827,1,0,0,0,2829,2830,1,0,0,0,2830,2833,
        1,0,0,0,2831,2829,1,0,0,0,2832,2817,1,0,0,0,2832,2823,1,0,0,0,2832,
        2829,1,0,0,0,2833,2834,1,0,0,0,2834,2835,5,294,0,0,2835,2836,5,187,
        0,0,2836,2842,5,302,0,0,2837,2841,3,226,113,0,2838,2841,3,144,72,
        0,2839,2841,3,28,14,0,2840,2837,1,0,0,0,2840,2838,1,0,0,0,2840,2839,
        1,0,0,0,2841,2844,1,0,0,0,2842,2840,1,0,0,0,2842,2843,1,0,0,0,2843,
        2845,1,0,0,0,2844,2842,1,0,0,0,2845,2846,5,2,0,0,2846,2847,5,187,
        0,0,2847,2848,5,302,0,0,2848,249,1,0,0,0,2849,2850,5,186,0,0,2850,
        2851,5,298,0,0,2851,2852,5,295,0,0,2852,2871,5,293,0,0,2853,2855,
        5,296,0,0,2854,2853,1,0,0,0,2855,2858,1,0,0,0,2856,2854,1,0,0,0,
        2856,2857,1,0,0,0,2857,2872,1,0,0,0,2858,2856,1,0,0,0,2859,2861,
        5,297,0,0,2860,2859,1,0,0,0,2861,2864,1,0,0,0,2862,2860,1,0,0,0,
        2862,2863,1,0,0,0,2863,2872,1,0,0,0,2864,2862,1,0,0,0,2865,2867,
        5,299,0,0,2866,2865,1,0,0,0,2867,2870,1,0,0,0,2868,2866,1,0,0,0,
        2868,2869,1,0,0,0,2869,2872,1,0,0,0,2870,2868,1,0,0,0,2871,2856,
        1,0,0,0,2871,2862,1,0,0,0,2871,2868,1,0,0,0,2872,2873,1,0,0,0,2873,
        2874,5,294,0,0,2874,2875,5,187,0,0,2875,2881,5,302,0,0,2876,2880,
        3,226,113,0,2877,2880,3,158,79,0,2878,2880,3,36,18,0,2879,2876,1,
        0,0,0,2879,2877,1,0,0,0,2879,2878,1,0,0,0,2880,2883,1,0,0,0,2881,
        2879,1,0,0,0,2881,2882,1,0,0,0,2882,2884,1,0,0,0,2883,2881,1,0,0,
        0,2884,2885,5,2,0,0,2885,2886,5,187,0,0,2886,2887,5,302,0,0,2887,
        251,1,0,0,0,2888,2889,5,186,0,0,2889,2890,5,298,0,0,2890,2891,5,
        295,0,0,2891,2910,5,293,0,0,2892,2894,5,296,0,0,2893,2892,1,0,0,
        0,2894,2897,1,0,0,0,2895,2893,1,0,0,0,2895,2896,1,0,0,0,2896,2911,
        1,0,0,0,2897,2895,1,0,0,0,2898,2900,5,297,0,0,2899,2898,1,0,0,0,
        2900,2903,1,0,0,0,2901,2899,1,0,0,0,2901,2902,1,0,0,0,2902,2911,
        1,0,0,0,2903,2901,1,0,0,0,2904,2906,5,299,0,0,2905,2904,1,0,0,0,
        2906,2909,1,0,0,0,2907,2905,1,0,0,0,2907,2908,1,0,0,0,2908,2911,
        1,0,0,0,2909,2907,1,0,0,0,2910,2895,1,0,0,0,2910,2901,1,0,0,0,2910,
        2907,1,0,0,0,2911,2912,1,0,0,0,2912,2913,5,294,0,0,2913,2914,5,187,
        0,0,2914,2921,5,302,0,0,2915,2920,3,226,113,0,2916,2920,3,162,81,
        0,2917,2920,3,38,19,0,2918,2920,3,16,8,0,2919,2915,1,0,0,0,2919,
        2916,1,0,0,0,2919,2917,1,0,0,0,2919,2918,1,0,0,0,2920,2923,1,0,0,
        0,2921,2919,1,0,0,0,2921,2922,1,0,0,0,2922,2924,1,0,0,0,2923,2921,
        1,0,0,0,2924,2925,5,2,0,0,2925,2926,5,187,0,0,2926,2927,5,302,0,
        0,2927,253,1,0,0,0,2928,2929,5,186,0,0,2929,2930,5,298,0,0,2930,
        2931,5,295,0,0,2931,2950,5,293,0,0,2932,2934,5,296,0,0,2933,2932,
        1,0,0,0,2934,2937,1,0,0,0,2935,2933,1,0,0,0,2935,2936,1,0,0,0,2936,
        2951,1,0,0,0,2937,2935,1,0,0,0,2938,2940,5,297,0,0,2939,2938,1,0,
        0,0,2940,2943,1,0,0,0,2941,2939,1,0,0,0,2941,2942,1,0,0,0,2942,2951,
        1,0,0,0,2943,2941,1,0,0,0,2944,2946,5,299,0,0,2945,2944,1,0,0,0,
        2946,2949,1,0,0,0,2947,2945,1,0,0,0,2947,2948,1,0,0,0,2948,2951,
        1,0,0,0,2949,2947,1,0,0,0,2950,2935,1,0,0,0,2950,2941,1,0,0,0,2950,
        2947,1,0,0,0,2951,2952,1,0,0,0,2952,2953,5,294,0,0,2953,2954,5,187,
        0,0,2954,2960,5,302,0,0,2955,2959,3,226,113,0,2956,2959,3,178,89,
        0,2957,2959,3,46,23,0,2958,2955,1,0,0,0,2958,2956,1,0,0,0,2958,2957,
        1,0,0,0,2959,2962,1,0,0,0,2960,2958,1,0,0,0,2960,2961,1,0,0,0,2961,
        2963,1,0,0,0,2962,2960,1,0,0,0,2963,2964,5,2,0,0,2964,2965,5,187,
        0,0,2965,2966,5,302,0,0,2966,255,1,0,0,0,2967,2968,5,186,0,0,2968,
        2969,5,298,0,0,2969,2970,5,295,0,0,2970,2989,5,293,0,0,2971,2973,
        5,296,0,0,2972,2971,1,0,0,0,2973,2976,1,0,0,0,2974,2972,1,0,0,0,
        2974,2975,1,0,0,0,2975,2990,1,0,0,0,2976,2974,1,0,0,0,2977,2979,
        5,297,0,0,2978,2977,1,0,0,0,2979,2982,1,0,0,0,2980,2978,1,0,0,0,
        2980,2981,1,0,0,0,2981,2990,1,0,0,0,2982,2980,1,0,0,0,2983,2985,
        5,299,0,0,2984,2983,1,0,0,0,2985,2988,1,0,0,0,2986,2984,1,0,0,0,
        2986,2987,1,0,0,0,2987,2990,1,0,0,0,2988,2986,1,0,0,0,2989,2974,
        1,0,0,0,2989,2980,1,0,0,0,2989,2986,1,0,0,0,2990,2991,1,0,0,0,2991,
        2992,5,294,0,0,2992,2993,5,187,0,0,2993,2999,5,302,0,0,2994,2998,
        3,226,113,0,2995,2998,3,182,91,0,2996,2998,3,48,24,0,2997,2994,1,
        0,0,0,2997,2995,1,0,0,0,2997,2996,1,0,0,0,2998,3001,1,0,0,0,2999,
        2997,1,0,0,0,2999,3000,1,0,0,0,3000,3002,1,0,0,0,3001,2999,1,0,0,
        0,3002,3003,5,2,0,0,3003,3004,5,187,0,0,3004,3005,5,302,0,0,3005,
        257,1,0,0,0,3006,3007,5,186,0,0,3007,3008,5,298,0,0,3008,3009,5,
        295,0,0,3009,3028,5,293,0,0,3010,3012,5,296,0,0,3011,3010,1,0,0,
        0,3012,3015,1,0,0,0,3013,3011,1,0,0,0,3013,3014,1,0,0,0,3014,3029,
        1,0,0,0,3015,3013,1,0,0,0,3016,3018,5,297,0,0,3017,3016,1,0,0,0,
        3018,3021,1,0,0,0,3019,3017,1,0,0,0,3019,3020,1,0,0,0,3020,3029,
        1,0,0,0,3021,3019,1,0,0,0,3022,3024,5,299,0,0,3023,3022,1,0,0,0,
        3024,3027,1,0,0,0,3025,3023,1,0,0,0,3025,3026,1,0,0,0,3026,3029,
        1,0,0,0,3027,3025,1,0,0,0,3028,3013,1,0,0,0,3028,3019,1,0,0,0,3028,
        3025,1,0,0,0,3029,3030,1,0,0,0,3030,3031,5,294,0,0,3031,3032,5,187,
        0,0,3032,3038,5,302,0,0,3033,3037,3,226,113,0,3034,3037,3,84,42,
        0,3035,3037,3,8,4,0,3036,3033,1,0,0,0,3036,3034,1,0,0,0,3036,3035,
        1,0,0,0,3037,3040,1,0,0,0,3038,3036,1,0,0,0,3038,3039,1,0,0,0,3039,
        3041,1,0,0,0,3040,3038,1,0,0,0,3041,3042,5,2,0,0,3042,3043,5,187,
        0,0,3043,3044,5,302,0,0,3044,259,1,0,0,0,346,317,319,328,334,340,
        349,357,365,373,381,385,388,394,400,406,415,424,433,442,451,460,
        469,478,487,496,505,514,523,532,541,550,559,568,577,597,618,631,
        661,664,671,674,679,684,689,692,695,699,704,709,716,720,725,730,
        735,740,745,750,754,761,767,771,793,798,803,810,821,824,832,846,
        851,856,863,880,885,891,898,903,910,922,930,935,942,949,961,966,
        971,980,989,996,1002,1009,1014,1017,1022,1027,1032,1036,1042,1046,
        1050,1053,1055,1059,1075,1080,1088,1096,1113,1121,1125,1130,1135,
        1143,1146,1158,1165,1178,1183,1192,1201,1234,1238,1246,1251,1256,
        1260,1272,1296,1307,1318,1324,1330,1334,1345,1351,1357,1364,1374,
        1380,1386,1391,1400,1403,1406,1410,1422,1429,1436,1442,1447,1465,
        1470,1475,1484,1495,1505,1531,1539,1558,1571,1588,1593,1598,1605,
        1617,1620,1626,1642,1647,1652,1659,1674,1679,1684,1691,1717,1722,
        1727,1735,1743,1758,1765,1772,1777,1783,1790,1797,1808,1812,1819,
        1832,1837,1845,1862,1872,1875,1887,1892,1908,1919,1925,1930,1937,
        1954,1959,1968,1976,1983,1988,1995,2006,2011,2016,2021,2026,2031,
        2036,2041,2046,2051,2056,2061,2066,2069,2080,2089,2095,2099,2104,
        2109,2112,2123,2131,2146,2162,2165,2176,2181,2184,2192,2196,2207,
        2211,2215,2218,2231,2234,2241,2244,2251,2256,2259,2273,2281,2283,
        2296,2307,2311,2313,2319,2334,2339,2344,2353,2417,2434,2474,2490,
        2494,2506,2514,2529,2544,2574,2583,2589,2595,2598,2606,2608,2622,
        2628,2634,2637,2645,2647,2661,2667,2673,2676,2684,2686,2700,2706,
        2712,2715,2723,2725,2739,2745,2751,2754,2762,2764,2778,2784,2790,
        2793,2801,2803,2817,2823,2829,2832,2840,2842,2856,2862,2868,2871,
        2879,2881,2895,2901,2907,2910,2919,2921,2935,2941,2947,2950,2958,
        2960,2974,2980,2986,2989,2997,2999,3013,3019,3025,3028,3036,3038
    ]

class XplorMRParser ( Parser ):

    grammarFileName = "XplorMRParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'SET'", "<INVALID>", "'NOE'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'BHIG'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'CUTOFF'", "'CUTON'", "'FROM'", "'TO'", 
                     "'PEAK'", "'SPECTRUM'", "'VOLUME'", "'VOL'", "'PPM1'", 
                     "'PPM2'", "<INVALID>", "<INVALID>", "<INVALID>", "'?'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'TYPE'", "<INVALID>", "<INVALID>", "'CV'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'XADC'", "<INVALID>", 
                     "'SIZE'", "'ZERO'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'RAMA'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'SORT'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'DCSA'", "<INVALID>", "'PCSA'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'TAUC'", "<INVALID>", "'XPCS'", 
                     "'TOLL'", "'SAVE'", "'FMED'", "'ERRON'", "'ERROFF'", 
                     "'FON'", "'FOFF'", "'SON'", "'SOFF'", "'FRUN'", "<INVALID>", 
                     "<INVALID>", "'XCCR'", "'WEIP'", "'HBDA'", "'HBDB'", 
                     "'KDIR'", "'KLIN'", "'NSEG'", "'NMIN'", "'NMAX'", "'SEGM'", 
                     "'OHCUT'", "<INVALID>", "<INVALID>", "<INVALID>", "'UPDFRQ'", 
                     "'PRNFRQ'", "'FREEMODE'", "<INVALID>", "<INVALID>", 
                     "'NCS'", "<INVALID>", "'SIGB'", "<INVALID>", "'ALL'", 
                     "<INVALID>", "'ATOM'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'ID'", "<INVALID>", 
                     "'NAME'", "<INVALID>", "'CUT'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'STORE1'", "'STORE2'", "'STORE3'", "'STORE4'", "'STORE5'", 
                     "'STORE6'", "'STORE7'", "'STORE8'", "'STORE9'", "'TAG'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'SHOW'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'NIL'", "<INVALID>", "'UB'", 
                     "'MULT'", "<INVALID>", "<INVALID>", "<INVALID>", "'NONB'", 
                     "<INVALID>", "<INVALID>", "'FOR'", "'LOOP'", "'TAIL'", 
                     "'HEAD'", "'OR'", "'AND'", "'NOT'", "<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>", "'ACOS'", "'ASIN'", 
                     "'COS'", "'DECODE'", "'ENCODE'", "'EXP'", "'GAUSS'", 
                     "'HEAVY'", "'INT'", "'LOG10'", "'LOG'", "<INVALID>", 
                     "'MAXW'", "<INVALID>", "'MOD'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'SIN'", "'SQRT'", "'TAN'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'RMS'", "'SUM'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'IN'" ]

    symbolicNames = [ "<INVALID>", "Set", "End", "Noe", "Assign", "Asymptote", 
                      "Average", "Bhig", "Ceiling", "Classification", "CountViol", 
                      "Distribute", "Monomers", "Ncount", "Nrestraints", 
                      "Potential", "Predict", "Print", "Threshold", "Reset", 
                      "Rswitch", "Scale", "SoExponent", "SqConstant", "SqExponent", 
                      "SqOffset", "Temperature", "Cutoff", "Cuton", "From", 
                      "To", "Peak", "Spectrum", "Volume", "Vol", "Ppm1", 
                      "Ppm2", "Restraints", "Dihedral", "Nassign", "Print_any", 
                      "Sanisotropy", "Coefficients", "ForceConstant", "Xdipolar", 
                      "Dipolar", "Type", "Sign", "VeAngle", "Cv", "Partition", 
                      "Tensor", "Anisotropy", "Planar", "Group", "Initialize", 
                      "Selection", "Weight", "Harmonic", "Exponent", "Normal", 
                      "Xadc", "Expectation", "Size", "Zero", "Coupling", 
                      "Degeneracy", "Carbon", "PhiStep", "PsiStep", "Rcoil", 
                      "Proton", "Observed", "Amides", "Nitrogens", "Oxygens", 
                      "RingAtoms", "AlphasAndAmides", "Error", "Ramachandran", 
                      "Gaussian", "Phase", "Quartic", "Shape", "Sort", "Dimensions", 
                      "Collapse", "Danisotropy", "Orient", "Height", "MaxGaussians", 
                      "NewGaussian", "Dcsa", "Sigma", "Pcsa", "OneBond", 
                      "AngleDb", "DerivFlag", "PMagnetic", "Kconst", "Omega", 
                      "Tauc", "Debug", "Xpcs", "Tolerance", "Save", "Fmed", 
                      "ErrOn", "ErrOff", "Fon", "Foff", "Son", "Soff", "Frun", 
                      "Xrdcoupling", "Xangle", "Xccr", "Weip", "Hbda", "Hbdb", 
                      "Kdir", "Klin", "Nseg", "Nmin", "Nmax", "Segm", "Ohcut", 
                      "Coh1cut", "Coh2cut", "Ohncut", "Updfrq", "Prnfrq", 
                      "Freemode", "Donor", "Acceptor", "Ncs", "Equivalence", 
                      "Sigb", "Flags", "All", "Around", "Atom", "Attribute", 
                      "BondedTo", "ByGroup", "ByRes", "Chemical", "Hydrogen", 
                      "Id", "Known", "Name", "Point", "Cut", "Previous", 
                      "Pseudo", "Residue", "Resname", "Saround", "SegIdentifier", 
                      "Store1", "Store2", "Store3", "Store4", "Store5", 
                      "Store6", "Store7", "Store8", "Store9", "Tag", "Vector", 
                      "Do_Lp", "Identity_Lp", "Show", "Evaluate_Lp", "Patch", 
                      "Reference", "Nil", "Parameter", "UB", "Mult", "HBonded", 
                      "Improper", "NBFix", "NonB", "VDWOff", "Verbose", 
                      "For", "Loop", "Tail", "Head", "Or_op", "And_op", 
                      "Not_op", "Comma", "Complex", "Integer", "Logical", 
                      "Real", "Double_quote_string", "SHARP_COMMENT", "EXCLM_COMMENT", 
                      "SMCLN_COMMENT", "Simple_name", "Simple_names", "Integers", 
                      "L_paren", "R_paren", "Colon", "Equ_op", "Lt_op", 
                      "Gt_op", "Leq_op", "Geq_op", "Neq_op", "Symbol_name", 
                      "SPACE", "ENCLOSE_COMMENT", "SECTION_COMMENT", "LINE_COMMENT", 
                      "SET_VARIABLE", "Abs", "Attr_properties", "Comparison_ops", 
                      "SPACE_AP", "Averaging_methods", "Class_name_AM", 
                      "SPACE_AM", "Equ_op_PT", "Potential_types", "Class_name_PT", 
                      "SPACE_PT", "Rdc_dist_fix_types", "Rdc_or_Diff_anis_types", 
                      "Csa_types", "SPACE_TY", "Gauss_or_Quart", "SPACE_SH", 
                      "Exclude", "Include", "End_FL", "Class_name", "Any_class", 
                      "SPACE_FL", "R_paren_VE", "Equ_op_VE", "Add_op_VE", 
                      "Sub_op_VE", "Mul_op_VE", "Div_op_VE", "Exp_op_VE", 
                      "Comma_VE", "Integer_VE", "Real_VE", "Atom_properties_VE", 
                      "Abs_VE", "Acos_VE", "Asin_VE", "Cos_VE", "Decode_VE", 
                      "Encode_VE", "Exp_VE", "Gauss_VE", "Heavy_VE", "Int_VE", 
                      "Log10_VE", "Log_VE", "Max_VE", "Maxw_VE", "Min_VE", 
                      "Mod_VE", "Norm_VE", "Random_VE", "Sign_VE", "Sin_VE", 
                      "Sqrt_VE", "Tan_VE", "Symbol_name_VE", "Simple_name_VE", 
                      "Double_quote_string_VE", "SPACE_VE", "L_paren_VF", 
                      "SPACE_VF", "L_paren_VS", "R_paren_VS", "Average_VS", 
                      "Element_VS", "Max_VS", "Min_VS", "Norm_VS", "Rms_VS", 
                      "Sum_VS", "Atom_properties_VS", "SPACE_VS", "L_paren_CF", 
                      "R_paren_CF", "In_CF", "Integer_CF", "Real_CF", "Symbol_name_CF", 
                      "Simple_name_CF", "SPACE_CF", "COMMENT_CF", "Simple_name_LL", 
                      "SPACE_LL" ]

    RULE_xplor_nih_mr = 0
    RULE_distance_restraint = 1
    RULE_dihedral_angle_restraint = 2
    RULE_rdc_restraint = 3
    RULE_planar_restraint = 4
    RULE_harmonic_restraint = 5
    RULE_antidistance_restraint = 6
    RULE_coupling_restraint = 7
    RULE_carbon_shift_restraint = 8
    RULE_proton_shift_restraint = 9
    RULE_dihedral_angle_db_restraint = 10
    RULE_radius_of_gyration_restraint = 11
    RULE_diffusion_anisotropy_restraint = 12
    RULE_orientation_db_restraint = 13
    RULE_csa_restraint = 14
    RULE_pcsa_restraint = 15
    RULE_one_bond_coupling_restraint = 16
    RULE_angle_db_restraint = 17
    RULE_pre_restraint = 18
    RULE_pcs_restraint = 19
    RULE_prdc_restraint = 20
    RULE_porientation_restraint = 21
    RULE_pccr_restraint = 22
    RULE_hbond_restraint = 23
    RULE_hbond_db_restraint = 24
    RULE_noe_statement = 25
    RULE_noe_assign = 26
    RULE_predict_statement = 27
    RULE_noe_annotation = 28
    RULE_dihedral_statement = 29
    RULE_dihedral_assign = 30
    RULE_sani_statement = 31
    RULE_sani_assign = 32
    RULE_xdip_statement = 33
    RULE_xdip_assign = 34
    RULE_vean_statement = 35
    RULE_vean_assign = 36
    RULE_tenso_statement = 37
    RULE_tenso_assign = 38
    RULE_anis_statement = 39
    RULE_anis_assign = 40
    RULE_planar_statement = 41
    RULE_planar_group = 42
    RULE_group_statement = 43
    RULE_harmonic_statement = 44
    RULE_harmonic_assign = 45
    RULE_antidistance_statement = 46
    RULE_xadc_assign = 47
    RULE_coupling_statement = 48
    RULE_coup_assign = 49
    RULE_carbon_shift_statement = 50
    RULE_carbon_shift_assign = 51
    RULE_carbon_shift_rcoil = 52
    RULE_proton_shift_statement = 53
    RULE_observed = 54
    RULE_proton_shift_rcoil = 55
    RULE_proton_shift_anisotropy = 56
    RULE_proton_shift_amides = 57
    RULE_proton_shift_carbons = 58
    RULE_proton_shift_nitrogens = 59
    RULE_proton_shift_oxygens = 60
    RULE_proton_shift_ring_atoms = 61
    RULE_proton_shift_alphas_and_amides = 62
    RULE_ramachandran_statement = 63
    RULE_rama_assign = 64
    RULE_collapse_statement = 65
    RULE_coll_assign = 66
    RULE_diffusion_statement = 67
    RULE_dani_assign = 68
    RULE_orientation_statement = 69
    RULE_orie_assign = 70
    RULE_csa_statement = 71
    RULE_csa_assign = 72
    RULE_pcsa_statement = 73
    RULE_one_bond_coupling_statement = 74
    RULE_one_bond_assign = 75
    RULE_angle_db_statement = 76
    RULE_angle_db_assign = 77
    RULE_pre_statement = 78
    RULE_pre_assign = 79
    RULE_pcs_statement = 80
    RULE_pcs_assign = 81
    RULE_prdc_statement = 82
    RULE_prdc_assign = 83
    RULE_porientation_statement = 84
    RULE_porientation_assign = 85
    RULE_pccr_statement = 86
    RULE_pccr_assign = 87
    RULE_hbond_statement = 88
    RULE_hbond_assign = 89
    RULE_hbond_db_statement = 90
    RULE_hbond_db_assign = 91
    RULE_ncs_restraint = 92
    RULE_ncs_statement = 93
    RULE_ncs_group_statement = 94
    RULE_selection = 95
    RULE_selection_expression = 96
    RULE_term = 97
    RULE_factor = 98
    RULE_number = 99
    RULE_number_f = 100
    RULE_number_s = 101
    RULE_number_a = 102
    RULE_classification = 103
    RULE_class_name = 104
    RULE_flag_statement = 105
    RULE_vector_statement = 106
    RULE_vector_mode = 107
    RULE_vector_expression = 108
    RULE_vector_operation = 109
    RULE_vflc = 110
    RULE_vector_func_call = 111
    RULE_vector_show_property = 112
    RULE_evaluate_statement = 113
    RULE_evaluate_operation = 114
    RULE_patch_statement = 115
    RULE_parameter_setting = 116
    RULE_parameter_statement = 117
    RULE_noe_assign_loop = 118
    RULE_dihedral_assign_loop = 119
    RULE_sani_assign_loop = 120
    RULE_xadc_assign_loop = 121
    RULE_coup_assign_loop = 122
    RULE_coll_assign_loop = 123
    RULE_csa_assign_loop = 124
    RULE_pre_assign_loop = 125
    RULE_pcs_assign_loop = 126
    RULE_hbond_assign_loop = 127
    RULE_hbond_db_assign_loop = 128
    RULE_planar_group_loop = 129

    ruleNames =  [ "xplor_nih_mr", "distance_restraint", "dihedral_angle_restraint", 
                   "rdc_restraint", "planar_restraint", "harmonic_restraint", 
                   "antidistance_restraint", "coupling_restraint", "carbon_shift_restraint", 
                   "proton_shift_restraint", "dihedral_angle_db_restraint", 
                   "radius_of_gyration_restraint", "diffusion_anisotropy_restraint", 
                   "orientation_db_restraint", "csa_restraint", "pcsa_restraint", 
                   "one_bond_coupling_restraint", "angle_db_restraint", 
                   "pre_restraint", "pcs_restraint", "prdc_restraint", "porientation_restraint", 
                   "pccr_restraint", "hbond_restraint", "hbond_db_restraint", 
                   "noe_statement", "noe_assign", "predict_statement", "noe_annotation", 
                   "dihedral_statement", "dihedral_assign", "sani_statement", 
                   "sani_assign", "xdip_statement", "xdip_assign", "vean_statement", 
                   "vean_assign", "tenso_statement", "tenso_assign", "anis_statement", 
                   "anis_assign", "planar_statement", "planar_group", "group_statement", 
                   "harmonic_statement", "harmonic_assign", "antidistance_statement", 
                   "xadc_assign", "coupling_statement", "coup_assign", "carbon_shift_statement", 
                   "carbon_shift_assign", "carbon_shift_rcoil", "proton_shift_statement", 
                   "observed", "proton_shift_rcoil", "proton_shift_anisotropy", 
                   "proton_shift_amides", "proton_shift_carbons", "proton_shift_nitrogens", 
                   "proton_shift_oxygens", "proton_shift_ring_atoms", "proton_shift_alphas_and_amides", 
                   "ramachandran_statement", "rama_assign", "collapse_statement", 
                   "coll_assign", "diffusion_statement", "dani_assign", 
                   "orientation_statement", "orie_assign", "csa_statement", 
                   "csa_assign", "pcsa_statement", "one_bond_coupling_statement", 
                   "one_bond_assign", "angle_db_statement", "angle_db_assign", 
                   "pre_statement", "pre_assign", "pcs_statement", "pcs_assign", 
                   "prdc_statement", "prdc_assign", "porientation_statement", 
                   "porientation_assign", "pccr_statement", "pccr_assign", 
                   "hbond_statement", "hbond_assign", "hbond_db_statement", 
                   "hbond_db_assign", "ncs_restraint", "ncs_statement", 
                   "ncs_group_statement", "selection", "selection_expression", 
                   "term", "factor", "number", "number_f", "number_s", "number_a", 
                   "classification", "class_name", "flag_statement", "vector_statement", 
                   "vector_mode", "vector_expression", "vector_operation", 
                   "vflc", "vector_func_call", "vector_show_property", "evaluate_statement", 
                   "evaluate_operation", "patch_statement", "parameter_setting", 
                   "parameter_statement", "noe_assign_loop", "dihedral_assign_loop", 
                   "sani_assign_loop", "xadc_assign_loop", "coup_assign_loop", 
                   "coll_assign_loop", "csa_assign_loop", "pre_assign_loop", 
                   "pcs_assign_loop", "hbond_assign_loop", "hbond_db_assign_loop", 
                   "planar_group_loop" ]

    EOF = Token.EOF
    Set=1
    End=2
    Noe=3
    Assign=4
    Asymptote=5
    Average=6
    Bhig=7
    Ceiling=8
    Classification=9
    CountViol=10
    Distribute=11
    Monomers=12
    Ncount=13
    Nrestraints=14
    Potential=15
    Predict=16
    Print=17
    Threshold=18
    Reset=19
    Rswitch=20
    Scale=21
    SoExponent=22
    SqConstant=23
    SqExponent=24
    SqOffset=25
    Temperature=26
    Cutoff=27
    Cuton=28
    From=29
    To=30
    Peak=31
    Spectrum=32
    Volume=33
    Vol=34
    Ppm1=35
    Ppm2=36
    Restraints=37
    Dihedral=38
    Nassign=39
    Print_any=40
    Sanisotropy=41
    Coefficients=42
    ForceConstant=43
    Xdipolar=44
    Dipolar=45
    Type=46
    Sign=47
    VeAngle=48
    Cv=49
    Partition=50
    Tensor=51
    Anisotropy=52
    Planar=53
    Group=54
    Initialize=55
    Selection=56
    Weight=57
    Harmonic=58
    Exponent=59
    Normal=60
    Xadc=61
    Expectation=62
    Size=63
    Zero=64
    Coupling=65
    Degeneracy=66
    Carbon=67
    PhiStep=68
    PsiStep=69
    Rcoil=70
    Proton=71
    Observed=72
    Amides=73
    Nitrogens=74
    Oxygens=75
    RingAtoms=76
    AlphasAndAmides=77
    Error=78
    Ramachandran=79
    Gaussian=80
    Phase=81
    Quartic=82
    Shape=83
    Sort=84
    Dimensions=85
    Collapse=86
    Danisotropy=87
    Orient=88
    Height=89
    MaxGaussians=90
    NewGaussian=91
    Dcsa=92
    Sigma=93
    Pcsa=94
    OneBond=95
    AngleDb=96
    DerivFlag=97
    PMagnetic=98
    Kconst=99
    Omega=100
    Tauc=101
    Debug=102
    Xpcs=103
    Tolerance=104
    Save=105
    Fmed=106
    ErrOn=107
    ErrOff=108
    Fon=109
    Foff=110
    Son=111
    Soff=112
    Frun=113
    Xrdcoupling=114
    Xangle=115
    Xccr=116
    Weip=117
    Hbda=118
    Hbdb=119
    Kdir=120
    Klin=121
    Nseg=122
    Nmin=123
    Nmax=124
    Segm=125
    Ohcut=126
    Coh1cut=127
    Coh2cut=128
    Ohncut=129
    Updfrq=130
    Prnfrq=131
    Freemode=132
    Donor=133
    Acceptor=134
    Ncs=135
    Equivalence=136
    Sigb=137
    Flags=138
    All=139
    Around=140
    Atom=141
    Attribute=142
    BondedTo=143
    ByGroup=144
    ByRes=145
    Chemical=146
    Hydrogen=147
    Id=148
    Known=149
    Name=150
    Point=151
    Cut=152
    Previous=153
    Pseudo=154
    Residue=155
    Resname=156
    Saround=157
    SegIdentifier=158
    Store1=159
    Store2=160
    Store3=161
    Store4=162
    Store5=163
    Store6=164
    Store7=165
    Store8=166
    Store9=167
    Tag=168
    Vector=169
    Do_Lp=170
    Identity_Lp=171
    Show=172
    Evaluate_Lp=173
    Patch=174
    Reference=175
    Nil=176
    Parameter=177
    UB=178
    Mult=179
    HBonded=180
    Improper=181
    NBFix=182
    NonB=183
    VDWOff=184
    Verbose=185
    For=186
    Loop=187
    Tail=188
    Head=189
    Or_op=190
    And_op=191
    Not_op=192
    Comma=193
    Complex=194
    Integer=195
    Logical=196
    Real=197
    Double_quote_string=198
    SHARP_COMMENT=199
    EXCLM_COMMENT=200
    SMCLN_COMMENT=201
    Simple_name=202
    Simple_names=203
    Integers=204
    L_paren=205
    R_paren=206
    Colon=207
    Equ_op=208
    Lt_op=209
    Gt_op=210
    Leq_op=211
    Geq_op=212
    Neq_op=213
    Symbol_name=214
    SPACE=215
    ENCLOSE_COMMENT=216
    SECTION_COMMENT=217
    LINE_COMMENT=218
    SET_VARIABLE=219
    Abs=220
    Attr_properties=221
    Comparison_ops=222
    SPACE_AP=223
    Averaging_methods=224
    Class_name_AM=225
    SPACE_AM=226
    Equ_op_PT=227
    Potential_types=228
    Class_name_PT=229
    SPACE_PT=230
    Rdc_dist_fix_types=231
    Rdc_or_Diff_anis_types=232
    Csa_types=233
    SPACE_TY=234
    Gauss_or_Quart=235
    SPACE_SH=236
    Exclude=237
    Include=238
    End_FL=239
    Class_name=240
    Any_class=241
    SPACE_FL=242
    R_paren_VE=243
    Equ_op_VE=244
    Add_op_VE=245
    Sub_op_VE=246
    Mul_op_VE=247
    Div_op_VE=248
    Exp_op_VE=249
    Comma_VE=250
    Integer_VE=251
    Real_VE=252
    Atom_properties_VE=253
    Abs_VE=254
    Acos_VE=255
    Asin_VE=256
    Cos_VE=257
    Decode_VE=258
    Encode_VE=259
    Exp_VE=260
    Gauss_VE=261
    Heavy_VE=262
    Int_VE=263
    Log10_VE=264
    Log_VE=265
    Max_VE=266
    Maxw_VE=267
    Min_VE=268
    Mod_VE=269
    Norm_VE=270
    Random_VE=271
    Sign_VE=272
    Sin_VE=273
    Sqrt_VE=274
    Tan_VE=275
    Symbol_name_VE=276
    Simple_name_VE=277
    Double_quote_string_VE=278
    SPACE_VE=279
    L_paren_VF=280
    SPACE_VF=281
    L_paren_VS=282
    R_paren_VS=283
    Average_VS=284
    Element_VS=285
    Max_VS=286
    Min_VS=287
    Norm_VS=288
    Rms_VS=289
    Sum_VS=290
    Atom_properties_VS=291
    SPACE_VS=292
    L_paren_CF=293
    R_paren_CF=294
    In_CF=295
    Integer_CF=296
    Real_CF=297
    Symbol_name_CF=298
    Simple_name_CF=299
    SPACE_CF=300
    COMMENT_CF=301
    Simple_name_LL=302
    SPACE_LL=303

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




    class Xplor_nih_mrContext(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(XplorMRParser.EOF, 0)

        def distance_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Distance_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Distance_restraintContext,i)


        def dihedral_angle_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_angle_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_angle_restraintContext,i)


        def rdc_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Rdc_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Rdc_restraintContext,i)


        def planar_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Planar_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Planar_restraintContext,i)


        def harmonic_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Harmonic_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Harmonic_restraintContext,i)


        def antidistance_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Antidistance_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Antidistance_restraintContext,i)


        def coupling_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coupling_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coupling_restraintContext,i)


        def carbon_shift_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Carbon_shift_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Carbon_shift_restraintContext,i)


        def proton_shift_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Proton_shift_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Proton_shift_restraintContext,i)


        def dihedral_angle_db_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_angle_db_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_angle_db_restraintContext,i)


        def radius_of_gyration_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Radius_of_gyration_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Radius_of_gyration_restraintContext,i)


        def diffusion_anisotropy_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Diffusion_anisotropy_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Diffusion_anisotropy_restraintContext,i)


        def orientation_db_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Orientation_db_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Orientation_db_restraintContext,i)


        def csa_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_restraintContext,i)


        def pcsa_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcsa_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcsa_restraintContext,i)


        def one_bond_coupling_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.One_bond_coupling_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.One_bond_coupling_restraintContext,i)


        def angle_db_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Angle_db_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Angle_db_restraintContext,i)


        def pre_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_restraintContext,i)


        def pcs_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_restraintContext,i)


        def prdc_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Prdc_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Prdc_restraintContext,i)


        def porientation_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Porientation_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Porientation_restraintContext,i)


        def pccr_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pccr_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pccr_restraintContext,i)


        def hbond_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_restraintContext,i)


        def hbond_db_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_db_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_db_restraintContext,i)


        def ncs_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Ncs_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Ncs_restraintContext,i)


        def classification(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.ClassificationContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.ClassificationContext,i)


        def flag_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Flag_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Flag_statementContext,i)


        def vector_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Vector_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Vector_statementContext,i)


        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def patch_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Patch_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Patch_statementContext,i)


        def parameter_setting(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Parameter_settingContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Parameter_settingContext,i)


        def noe_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Noe_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Noe_assign_loopContext,i)


        def dihedral_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_assign_loopContext,i)


        def sani_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Sani_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Sani_assign_loopContext,i)


        def hbond_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_assign_loopContext,i)


        def hbond_db_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_db_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_db_assign_loopContext,i)


        def coup_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coup_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coup_assign_loopContext,i)


        def xadc_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Xadc_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Xadc_assign_loopContext,i)


        def coll_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coll_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coll_assign_loopContext,i)


        def csa_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_assign_loopContext,i)


        def pre_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_assign_loopContext,i)


        def pcs_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_assign_loopContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_assign_loopContext,i)


        def noe_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Noe_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Noe_assignContext,i)


        def dihedral_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_assignContext,i)


        def sani_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Sani_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Sani_assignContext,i)


        def planar_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Planar_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Planar_statementContext,i)


        def harmonic_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Harmonic_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Harmonic_assignContext,i)


        def hbond_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_assignContext,i)


        def hbond_db_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_db_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_db_assignContext,i)


        def coup_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coup_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coup_assignContext,i)


        def xadc_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Xadc_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Xadc_assignContext,i)


        def coll_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coll_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coll_assignContext,i)


        def csa_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,i)


        def pre_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_assignContext,i)


        def pcs_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_assignContext,i)


        def observed(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.ObservedContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.ObservedContext,i)


        def parameter_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Parameter_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Parameter_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_xplor_nih_mr

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

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




    def xplor_nih_mr(self):

        localctx = XplorMRParser.Xplor_nih_mrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_xplor_nih_mr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2664217141976760856) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 30962534813024453) != 0) or ((((_la - 135)) & ~0x3f) == 0 and ((1 << (_la - 135)) & 4473655115383049) != 0):
                self.state = 317
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 260
                    self.distance_restraint()
                    pass

                elif la_ == 2:
                    self.state = 261
                    self.dihedral_angle_restraint()
                    pass

                elif la_ == 3:
                    self.state = 262
                    self.rdc_restraint()
                    pass

                elif la_ == 4:
                    self.state = 263
                    self.planar_restraint()
                    pass

                elif la_ == 5:
                    self.state = 264
                    self.harmonic_restraint()
                    pass

                elif la_ == 6:
                    self.state = 265
                    self.antidistance_restraint()
                    pass

                elif la_ == 7:
                    self.state = 266
                    self.coupling_restraint()
                    pass

                elif la_ == 8:
                    self.state = 267
                    self.carbon_shift_restraint()
                    pass

                elif la_ == 9:
                    self.state = 268
                    self.proton_shift_restraint()
                    pass

                elif la_ == 10:
                    self.state = 269
                    self.dihedral_angle_db_restraint()
                    pass

                elif la_ == 11:
                    self.state = 270
                    self.radius_of_gyration_restraint()
                    pass

                elif la_ == 12:
                    self.state = 271
                    self.diffusion_anisotropy_restraint()
                    pass

                elif la_ == 13:
                    self.state = 272
                    self.orientation_db_restraint()
                    pass

                elif la_ == 14:
                    self.state = 273
                    self.csa_restraint()
                    pass

                elif la_ == 15:
                    self.state = 274
                    self.pcsa_restraint()
                    pass

                elif la_ == 16:
                    self.state = 275
                    self.one_bond_coupling_restraint()
                    pass

                elif la_ == 17:
                    self.state = 276
                    self.angle_db_restraint()
                    pass

                elif la_ == 18:
                    self.state = 277
                    self.pre_restraint()
                    pass

                elif la_ == 19:
                    self.state = 278
                    self.pcs_restraint()
                    pass

                elif la_ == 20:
                    self.state = 279
                    self.prdc_restraint()
                    pass

                elif la_ == 21:
                    self.state = 280
                    self.porientation_restraint()
                    pass

                elif la_ == 22:
                    self.state = 281
                    self.pccr_restraint()
                    pass

                elif la_ == 23:
                    self.state = 282
                    self.hbond_restraint()
                    pass

                elif la_ == 24:
                    self.state = 283
                    self.hbond_db_restraint()
                    pass

                elif la_ == 25:
                    self.state = 284
                    self.ncs_restraint()
                    pass

                elif la_ == 26:
                    self.state = 285
                    self.classification()
                    pass

                elif la_ == 27:
                    self.state = 286
                    self.flag_statement()
                    pass

                elif la_ == 28:
                    self.state = 287
                    self.vector_statement()
                    pass

                elif la_ == 29:
                    self.state = 288
                    self.evaluate_statement()
                    pass

                elif la_ == 30:
                    self.state = 289
                    self.patch_statement()
                    pass

                elif la_ == 31:
                    self.state = 290
                    self.parameter_setting()
                    pass

                elif la_ == 32:
                    self.state = 291
                    self.noe_assign_loop()
                    pass

                elif la_ == 33:
                    self.state = 292
                    self.dihedral_assign_loop()
                    pass

                elif la_ == 34:
                    self.state = 293
                    self.sani_assign_loop()
                    pass

                elif la_ == 35:
                    self.state = 294
                    self.hbond_assign_loop()
                    pass

                elif la_ == 36:
                    self.state = 295
                    self.hbond_db_assign_loop()
                    pass

                elif la_ == 37:
                    self.state = 296
                    self.coup_assign_loop()
                    pass

                elif la_ == 38:
                    self.state = 297
                    self.xadc_assign_loop()
                    pass

                elif la_ == 39:
                    self.state = 298
                    self.coll_assign_loop()
                    pass

                elif la_ == 40:
                    self.state = 299
                    self.csa_assign_loop()
                    pass

                elif la_ == 41:
                    self.state = 300
                    self.pre_assign_loop()
                    pass

                elif la_ == 42:
                    self.state = 301
                    self.pcs_assign_loop()
                    pass

                elif la_ == 43:
                    self.state = 302
                    self.noe_assign()
                    pass

                elif la_ == 44:
                    self.state = 303
                    self.dihedral_assign()
                    pass

                elif la_ == 45:
                    self.state = 304
                    self.sani_assign()
                    pass

                elif la_ == 46:
                    self.state = 305
                    self.planar_statement()
                    pass

                elif la_ == 47:
                    self.state = 306
                    self.harmonic_assign()
                    pass

                elif la_ == 48:
                    self.state = 307
                    self.hbond_assign()
                    pass

                elif la_ == 49:
                    self.state = 308
                    self.hbond_db_assign()
                    pass

                elif la_ == 50:
                    self.state = 309
                    self.coup_assign()
                    pass

                elif la_ == 51:
                    self.state = 310
                    self.xadc_assign()
                    pass

                elif la_ == 52:
                    self.state = 311
                    self.coll_assign()
                    pass

                elif la_ == 53:
                    self.state = 312
                    self.csa_assign()
                    pass

                elif la_ == 54:
                    self.state = 313
                    self.pre_assign()
                    pass

                elif la_ == 55:
                    self.state = 314
                    self.pcs_assign()
                    pass

                elif la_ == 56:
                    self.state = 315
                    self.observed()
                    pass

                elif la_ == 57:
                    self.state = 316
                    self.parameter_statement()
                    pass


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

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


    class Distance_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Noe(self):
            return self.getToken(XplorMRParser.Noe, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def noe_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Noe_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Noe_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_distance_restraint

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

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




    def distance_restraint(self):

        localctx = XplorMRParser.Distance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_distance_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 324
            self.match(XplorMRParser.Noe)
            self.state = 328
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 133955568) != 0) or _la==186:
                self.state = 325
                self.noe_statement()
                self.state = 330
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 331
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedral_angle_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Dihedral(self):
            return self.getToken(XplorMRParser.Dihedral, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

        def dihedral_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_angle_restraint

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

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




    def dihedral_angle_restraint(self):

        localctx = XplorMRParser.Dihedral_angle_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_dihedral_angle_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 334
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==37:
                self.state = 333
                self.match(XplorMRParser.Restraints)


            self.state = 336
            self.match(XplorMRParser.Dihedral)
            self.state = 340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 1649270063120) != 0) or _la==169 or _la==186:
                self.state = 337
                self.dihedral_statement()
                self.state = 342
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 343
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Rdc_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Sanisotropy(self):
            return self.getToken(XplorMRParser.Sanisotropy, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def sani_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Sani_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Sani_statementContext,i)


        def Xdipolar(self):
            return self.getToken(XplorMRParser.Xdipolar, 0)

        def Dipolar(self):
            return self.getToken(XplorMRParser.Dipolar, 0)

        def xdip_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Xdip_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Xdip_statementContext,i)


        def VeAngle(self):
            return self.getToken(XplorMRParser.VeAngle, 0)

        def vean_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Vean_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Vean_statementContext,i)


        def Tensor(self):
            return self.getToken(XplorMRParser.Tensor, 0)

        def tenso_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Tenso_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Tenso_statementContext,i)


        def Anisotropy(self):
            return self.getToken(XplorMRParser.Anisotropy, 0)

        def anis_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Anis_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Anis_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_rdc_restraint

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

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




    def rdc_restraint(self):

        localctx = XplorMRParser.Rdc_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_rdc_restraint)
        self._la = 0 # Token type
        try:
            self.state = 385
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [41]:
                self.enterOuterAlt(localctx, 1)
                self.state = 345
                self.match(XplorMRParser.Sanisotropy)
                self.state = 349
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13194140238352) != 0) or _la==186:
                    self.state = 346
                    self.sani_statement()
                    self.state = 351
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 352
                self.match(XplorMRParser.End)
                pass
            elif token in [44, 45]:
                self.enterOuterAlt(localctx, 2)
                self.state = 353
                _la = self._input.LA(1)
                if not(_la==44 or _la==45):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 224300374868560) != 0):
                    self.state = 354
                    self.xdip_statement()
                    self.state = 359
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 360
                self.match(XplorMRParser.End)
                pass
            elif token in [48]:
                self.enterOuterAlt(localctx, 3)
                self.state = 361
                self.match(XplorMRParser.VeAngle)
                self.state = 365
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 1697645953958416) != 0):
                    self.state = 362
                    self.vean_statement()
                    self.state = 367
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 368
                self.match(XplorMRParser.End)
                pass
            elif token in [51]:
                self.enterOuterAlt(localctx, 4)
                self.state = 369
                self.match(XplorMRParser.Tensor)
                self.state = 373
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4398047216144) != 0):
                    self.state = 370
                    self.tenso_statement()
                    self.state = 375
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 376
                self.match(XplorMRParser.End)
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 5)
                self.state = 377
                self.match(XplorMRParser.Anisotropy)
                self.state = 381
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 83562884416016) != 0):
                    self.state = 378
                    self.anis_statement()
                    self.state = 383
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 384
                self.match(XplorMRParser.End)
                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 Planar_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Planar(self):
            return self.getToken(XplorMRParser.Planar, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

        def planar_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Planar_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Planar_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_restraint

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

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




    def planar_restraint(self):

        localctx = XplorMRParser.Planar_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_planar_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==37:
                self.state = 387
                self.match(XplorMRParser.Restraints)


            self.state = 390
            self.match(XplorMRParser.Planar)
            self.state = 394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 54044295040073728) != 0) or _la==169 or _la==186:
                self.state = 391
                self.planar_statement()
                self.state = 396
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 397
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Harmonic_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Harmonic(self):
            return self.getToken(XplorMRParser.Harmonic, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

        def harmonic_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Harmonic_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Harmonic_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_harmonic_restraint

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

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




    def harmonic_restraint(self):

        localctx = XplorMRParser.Harmonic_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_harmonic_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 400
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==37:
                self.state = 399
                self.match(XplorMRParser.Restraints)


            self.state = 402
            self.match(XplorMRParser.Harmonic)
            self.state = 406
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==59 or _la==60 or _la==169:
                self.state = 403
                self.harmonic_statement()
                self.state = 408
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 409
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Antidistance_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Xadc(self):
            return self.getToken(XplorMRParser.Xadc, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def antidistance_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Antidistance_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Antidistance_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_antidistance_restraint

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

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




    def antidistance_restraint(self):

        localctx = XplorMRParser.Antidistance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_antidistance_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 411
            self.match(XplorMRParser.Xadc)
            self.state = 415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & 2017613182817838113) != 0) or _la==186:
                self.state = 412
                self.antidistance_statement()
                self.state = 417
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 418
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Coupling_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Coupling(self):
            return self.getToken(XplorMRParser.Coupling, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def coupling_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coupling_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coupling_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_coupling_restraint

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

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




    def coupling_restraint(self):

        localctx = XplorMRParser.Coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_coupling_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 420
            self.match(XplorMRParser.Coupling)
            self.state = 424
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & 4611792396177419297) != 0) or _la==186:
                self.state = 421
                self.coupling_statement()
                self.state = 426
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 427
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Carbon_shift_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Carbon(self):
            return self.getToken(XplorMRParser.Carbon, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def carbon_shift_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Carbon_shift_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Carbon_shift_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_restraint

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

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




    def carbon_shift_restraint(self):

        localctx = XplorMRParser.Carbon_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_carbon_shift_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429
            self.match(XplorMRParser.Carbon)
            self.state = 433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4611694814521115152) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 113) != 0):
                self.state = 430
                self.carbon_shift_statement()
                self.state = 435
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 436
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Proton(self):
            return self.getToken(XplorMRParser.Proton, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def proton_shift_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Proton_shift_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Proton_shift_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_restraint

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

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




    def proton_shift_restraint(self):

        localctx = XplorMRParser.Proton_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_proton_shift_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 438
            self.match(XplorMRParser.Proton)
            self.state = 442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4512395721081344) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 8147) != 0):
                self.state = 439
                self.proton_shift_statement()
                self.state = 444
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 445
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedral_angle_db_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Ramachandran(self):
            return self.getToken(XplorMRParser.Ramachandran, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def ramachandran_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Ramachandran_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Ramachandran_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_angle_db_restraint

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

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




    def dihedral_angle_db_restraint(self):

        localctx = XplorMRParser.Dihedral_angle_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_dihedral_angle_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 447
            self.match(XplorMRParser.Ramachandran)
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -9223363240624766448) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 2031617) != 0):
                self.state = 448
                self.ramachandran_statement()
                self.state = 453
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 454
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Radius_of_gyration_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Collapse(self):
            return self.getToken(XplorMRParser.Collapse, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def collapse_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Collapse_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Collapse_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_radius_of_gyration_restraint

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

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




    def radius_of_gyration_restraint(self):

        localctx = XplorMRParser.Radius_of_gyration_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_radius_of_gyration_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 456
            self.match(XplorMRParser.Collapse)
            self.state = 460
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2752528) != 0) or _la==186:
                self.state = 457
                self.collapse_statement()
                self.state = 462
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 463
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Diffusion_anisotropy_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Danisotropy(self):
            return self.getToken(XplorMRParser.Danisotropy, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def diffusion_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Diffusion_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Diffusion_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_diffusion_anisotropy_restraint

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

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




    def diffusion_anisotropy_restraint(self):

        localctx = XplorMRParser.Diffusion_anisotropy_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_diffusion_anisotropy_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.match(XplorMRParser.Danisotropy)
            self.state = 469
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 83562884416016) != 0):
                self.state = 466
                self.diffusion_statement()
                self.state = 471
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 472
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Orientation_db_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Orient(self):
            return self.getToken(XplorMRParser.Orient, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def orientation_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Orientation_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Orientation_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_orientation_db_restraint

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

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




    def orientation_db_restraint(self):

        localctx = XplorMRParser.Orientation_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_orientation_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 474
            self.match(XplorMRParser.Orient)
            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -9223363240626863600) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 235208705) != 0) or _la==155:
                self.state = 475
                self.orientation_statement()
                self.state = 480
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 481
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Csa_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Dcsa(self):
            return self.getToken(XplorMRParser.Dcsa, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def csa_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_restraint

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

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




    def csa_restraint(self):

        localctx = XplorMRParser.Csa_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_csa_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 483
            self.match(XplorMRParser.Dcsa)
            self.state = 487
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 83562886513168) != 0) or _la==93 or _la==186:
                self.state = 484
                self.csa_statement()
                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 490
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcsa_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Pcsa(self):
            return self.getToken(XplorMRParser.Pcsa, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def pcsa_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcsa_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcsa_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcsa_restraint

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

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




    def pcsa_restraint(self):

        localctx = XplorMRParser.Pcsa_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_pcsa_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self.match(XplorMRParser.Pcsa)
            self.state = 496
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13194142335504) != 0) or _la==93:
                self.state = 493
                self.pcsa_statement()
                self.state = 498
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 499
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class One_bond_coupling_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OneBond(self):
            return self.getToken(XplorMRParser.OneBond, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def one_bond_coupling_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.One_bond_coupling_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.One_bond_coupling_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_coupling_restraint

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

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




    def one_bond_coupling_restraint(self):

        localctx = XplorMRParser.One_bond_coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_one_bond_coupling_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 501
            self.match(XplorMRParser.OneBond)
            self.state = 505
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13194140238352) != 0):
                self.state = 502
                self.one_bond_coupling_statement()
                self.state = 507
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 508
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angle_db_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AngleDb(self):
            return self.getToken(XplorMRParser.AngleDb, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def angle_db_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Angle_db_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Angle_db_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_restraint

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

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




    def angle_db_restraint(self):

        localctx = XplorMRParser.Angle_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_angle_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 510
            self.match(XplorMRParser.AngleDb)
            self.state = 514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -4611677222333660656) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 8589950977) != 0):
                self.state = 511
                self.angle_db_statement()
                self.state = 516
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 517
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pre_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PMagnetic(self):
            return self.getToken(XplorMRParser.PMagnetic, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def pre_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_restraint

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

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




    def pre_restraint(self):

        localctx = XplorMRParser.Pre_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_pre_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 519
            self.match(XplorMRParser.PMagnetic)
            self.state = 523
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8796093727248) != 0) or ((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 15) != 0) or _la==186:
                self.state = 520
                self.pre_statement()
                self.state = 525
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 526
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcs_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Xpcs(self):
            return self.getToken(XplorMRParser.Xpcs, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def pcs_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_restraint

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

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




    def pcs_restraint(self):

        localctx = XplorMRParser.Pcs_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_pcs_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 528
            self.match(XplorMRParser.Xpcs)
            self.state = 532
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13194140205584) != 0) or ((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & 1023) != 0) or _la==186:
                self.state = 529
                self.pcs_statement()
                self.state = 534
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 535
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Prdc_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Xrdcoupling(self):
            return self.getToken(XplorMRParser.Xrdcoupling, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def prdc_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Prdc_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Prdc_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_restraint

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

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




    def prdc_restraint(self):

        localctx = XplorMRParser.Prdc_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_prdc_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 537
            self.match(XplorMRParser.Xrdcoupling)
            self.state = 541
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13194140205584) != 0) or ((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & 1023) != 0):
                self.state = 538
                self.prdc_statement()
                self.state = 543
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 544
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Porientation_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Xangle(self):
            return self.getToken(XplorMRParser.Xangle, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def porientation_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Porientation_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Porientation_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_restraint

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

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




    def porientation_restraint(self):

        localctx = XplorMRParser.Porientation_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_porientation_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(XplorMRParser.Xangle)
            self.state = 550
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8796093694480) != 0):
                self.state = 547
                self.porientation_statement()
                self.state = 552
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 553
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pccr_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Xccr(self):
            return self.getToken(XplorMRParser.Xccr, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def pccr_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pccr_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pccr_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_restraint

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

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




    def pccr_restraint(self):

        localctx = XplorMRParser.Pccr_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_pccr_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 555
            self.match(XplorMRParser.Xccr)
            self.state = 559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13194140205584) != 0) or _la==113 or _la==117:
                self.state = 556
                self.pccr_statement()
                self.state = 561
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 562
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Hbda(self):
            return self.getToken(XplorMRParser.Hbda, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def hbond_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_restraint

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

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




    def hbond_restraint(self):

        localctx = XplorMRParser.Hbond_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_hbond_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 564
            self.match(XplorMRParser.Hbda)
            self.state = 568
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8796093694480) != 0) or _la==186:
                self.state = 565
                self.hbond_statement()
                self.state = 570
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 571
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_db_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Hbdb(self):
            return self.getToken(XplorMRParser.Hbdb, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def hbond_db_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_db_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_db_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_db_restraint

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

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




    def hbond_db_restraint(self):

        localctx = XplorMRParser.Hbond_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_hbond_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 573
            self.match(XplorMRParser.Hbdb)
            self.state = 577
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or ((((_la - 120)) & ~0x3f) == 0 and ((1 << (_la - 120)) & 8191) != 0) or _la==186:
                self.state = 574
                self.hbond_db_statement()
                self.state = 579
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 580
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Noe_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def noe_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Noe_assignContext,0)


        def noe_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Noe_assign_loopContext,0)


        def Asymptote(self):
            return self.getToken(XplorMRParser.Asymptote, 0)

        def class_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Class_nameContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Class_nameContext,i)


        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Average(self):
            return self.getToken(XplorMRParser.Average, 0)

        def Class_name_AM(self):
            return self.getToken(XplorMRParser.Class_name_AM, 0)

        def Averaging_methods(self):
            return self.getToken(XplorMRParser.Averaging_methods, 0)

        def Bhig(self):
            return self.getToken(XplorMRParser.Bhig, 0)

        def Ceiling(self):
            return self.getToken(XplorMRParser.Ceiling, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def CountViol(self):
            return self.getToken(XplorMRParser.CountViol, 0)

        def Distribute(self):
            return self.getToken(XplorMRParser.Distribute, 0)

        def Monomers(self):
            return self.getToken(XplorMRParser.Monomers, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Ncount(self):
            return self.getToken(XplorMRParser.Ncount, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Class_name_PT(self):
            return self.getToken(XplorMRParser.Class_name_PT, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Predict(self):
            return self.getToken(XplorMRParser.Predict, 0)

        def predict_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Predict_statementContext,0)


        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Rswitch(self):
            return self.getToken(XplorMRParser.Rswitch, 0)

        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def SoExponent(self):
            return self.getToken(XplorMRParser.SoExponent, 0)

        def SqConstant(self):
            return self.getToken(XplorMRParser.SqConstant, 0)

        def SqExponent(self):
            return self.getToken(XplorMRParser.SqExponent, 0)

        def SqOffset(self):
            return self.getToken(XplorMRParser.SqOffset, 0)

        def Temperature(self):
            return self.getToken(XplorMRParser.Temperature, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_statement

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

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




    def noe_statement(self):

        localctx = XplorMRParser.Noe_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_noe_statement)
        self._la = 0 # Token type
        try:
            self.state = 664
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 582
                self.noe_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 583
                self.noe_assign_loop()
                pass
            elif token in [5]:
                self.enterOuterAlt(localctx, 3)
                self.state = 584
                self.match(XplorMRParser.Asymptote)
                self.state = 585
                self.class_name()
                self.state = 586
                self.number_s()
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 4)
                self.state = 588
                self.match(XplorMRParser.Average)
                self.state = 589
                self.match(XplorMRParser.Class_name_AM)
                self.state = 590
                self.match(XplorMRParser.Averaging_methods)
                pass
            elif token in [7]:
                self.enterOuterAlt(localctx, 5)
                self.state = 591
                self.match(XplorMRParser.Bhig)
                self.state = 592
                self.class_name()
                self.state = 593
                self.number_s()
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 6)
                self.state = 595
                self.match(XplorMRParser.Ceiling)
                self.state = 597
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 596
                    self.match(XplorMRParser.Equ_op)


                self.state = 599
                self.number_s()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 7)
                self.state = 600
                self.classification()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 8)
                self.state = 601
                self.match(XplorMRParser.CountViol)
                self.state = 602
                self.class_name()
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 9)
                self.state = 603
                self.match(XplorMRParser.Distribute)
                self.state = 604
                self.class_name()
                self.state = 605
                self.class_name()
                self.state = 606
                self.number_s()
                pass
            elif token in [12]:
                self.enterOuterAlt(localctx, 10)
                self.state = 608
                self.match(XplorMRParser.Monomers)
                self.state = 609
                self.class_name()
                self.state = 610
                self.match(XplorMRParser.Integer)
                pass
            elif token in [13]:
                self.enterOuterAlt(localctx, 11)
                self.state = 612
                self.match(XplorMRParser.Ncount)
                self.state = 613
                self.class_name()
                self.state = 614
                self.match(XplorMRParser.Integer)
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 12)
                self.state = 616
                self.match(XplorMRParser.Nrestraints)
                self.state = 618
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 617
                    self.match(XplorMRParser.Equ_op)


                self.state = 620
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 13)
                self.state = 621
                self.match(XplorMRParser.Potential)
                self.state = 622
                self.match(XplorMRParser.Class_name_PT)
                self.state = 623
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [16]:
                self.enterOuterAlt(localctx, 14)
                self.state = 624
                self.match(XplorMRParser.Predict)
                self.state = 625
                self.predict_statement()
                self.state = 626
                self.match(XplorMRParser.End)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 15)
                self.state = 628
                self.match(XplorMRParser.Print)
                self.state = 629
                self.match(XplorMRParser.Threshold)
                self.state = 631
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 630
                    self.match(XplorMRParser.Equ_op)


                self.state = 633
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 16)
                self.state = 634
                self.match(XplorMRParser.Reset)
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 17)
                self.state = 635
                self.match(XplorMRParser.Rswitch)
                self.state = 636
                self.class_name()
                self.state = 637
                self.number_s()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 18)
                self.state = 639
                self.match(XplorMRParser.Scale)
                self.state = 640
                self.class_name()
                self.state = 641
                self.number_s()
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 19)
                self.state = 643
                self.match(XplorMRParser.SoExponent)
                self.state = 644
                self.class_name()
                self.state = 645
                self.number_s()
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 20)
                self.state = 647
                self.match(XplorMRParser.SqConstant)
                self.state = 648
                self.class_name()
                self.state = 649
                self.number_s()
                pass
            elif token in [24]:
                self.enterOuterAlt(localctx, 21)
                self.state = 651
                self.match(XplorMRParser.SqExponent)
                self.state = 652
                self.class_name()
                self.state = 653
                self.number_s()
                pass
            elif token in [25]:
                self.enterOuterAlt(localctx, 22)
                self.state = 655
                self.match(XplorMRParser.SqOffset)
                self.state = 656
                self.class_name()
                self.state = 657
                self.number_s()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 23)
                self.state = 659
                self.match(XplorMRParser.Temperature)
                self.state = 661
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 660
                    self.match(XplorMRParser.Equ_op)


                self.state = 663
                self.number_s()
                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 Noe_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def noe_annotation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Noe_annotationContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Noe_annotationContext,i)


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_assign

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

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




    def noe_assign(self):

        localctx = XplorMRParser.Noe_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_noe_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 666
            self.match(XplorMRParser.Assign)
            self.state = 667
            self.selection()
            self.state = 668
            self.selection()
            self.state = 669
            self.number()
            self.state = 671
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.state = 670
                self.number()


            self.state = 674
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 673
                self.number()


            self.state = 679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 144678273320747008) != 0) or _la==193:
                self.state = 676
                self.noe_annotation()
                self.state = 681
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 699
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==190:
                self.state = 682
                self.match(XplorMRParser.Or_op)
                self.state = 684
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==4:
                    self.state = 683
                    self.match(XplorMRParser.Assign)


                self.state = 686
                self.selection()
                self.state = 687
                self.selection()
                self.state = 689
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                if la_ == 1:
                    self.state = 688
                    self.number()


                self.state = 692
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
                if la_ == 1:
                    self.state = 691
                    self.number()


                self.state = 695
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 694
                    self.number()


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

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

        def Cutoff(self):
            return self.getToken(XplorMRParser.Cutoff, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Cuton(self):
            return self.getToken(XplorMRParser.Cuton, 0)

        def From(self):
            return self.getToken(XplorMRParser.From, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def To(self):
            return self.getToken(XplorMRParser.To, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_predict_statement

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

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




    def predict_statement(self):

        localctx = XplorMRParser.Predict_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_predict_statement)
        self._la = 0 # Token type
        try:
            self.state = 716
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [27]:
                self.enterOuterAlt(localctx, 1)
                self.state = 702
                self.match(XplorMRParser.Cutoff)
                self.state = 704
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 703
                    self.match(XplorMRParser.Equ_op)


                self.state = 706
                self.number_s()
                pass
            elif token in [28]:
                self.enterOuterAlt(localctx, 2)
                self.state = 707
                self.match(XplorMRParser.Cuton)
                self.state = 709
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 708
                    self.match(XplorMRParser.Equ_op)


                self.state = 711
                self.number_s()
                pass
            elif token in [29]:
                self.enterOuterAlt(localctx, 3)
                self.state = 712
                self.match(XplorMRParser.From)
                self.state = 713
                self.selection()
                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 4)
                self.state = 714
                self.match(XplorMRParser.To)
                self.state = 715
                self.selection()
                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 Noe_annotationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Peak(self):
            return self.getToken(XplorMRParser.Peak, 0)

        def number_a(self):
            return self.getTypedRuleContext(XplorMRParser.Number_aContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Spectrum(self):
            return self.getToken(XplorMRParser.Spectrum, 0)

        def Weight(self):
            return self.getToken(XplorMRParser.Weight, 0)

        def Volume(self):
            return self.getToken(XplorMRParser.Volume, 0)

        def Vol(self):
            return self.getToken(XplorMRParser.Vol, 0)

        def Ppm1(self):
            return self.getToken(XplorMRParser.Ppm1, 0)

        def Ppm2(self):
            return self.getToken(XplorMRParser.Ppm2, 0)

        def Cv(self):
            return self.getToken(XplorMRParser.Cv, 0)

        def Comma(self):
            return self.getToken(XplorMRParser.Comma, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_annotation

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

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




    def noe_annotation(self):

        localctx = XplorMRParser.Noe_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_noe_annotation)
        self._la = 0 # Token type
        try:
            self.state = 754
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [31]:
                self.enterOuterAlt(localctx, 1)
                self.state = 718
                self.match(XplorMRParser.Peak)
                self.state = 720
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 719
                    self.match(XplorMRParser.Equ_op)


                self.state = 722
                self.number_a()
                pass
            elif token in [32]:
                self.enterOuterAlt(localctx, 2)
                self.state = 723
                self.match(XplorMRParser.Spectrum)
                self.state = 725
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 724
                    self.match(XplorMRParser.Equ_op)


                self.state = 727
                self.number_a()
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 3)
                self.state = 728
                self.match(XplorMRParser.Weight)
                self.state = 730
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 729
                    self.match(XplorMRParser.Equ_op)


                self.state = 732
                self.number_a()
                pass
            elif token in [33, 34]:
                self.enterOuterAlt(localctx, 4)
                self.state = 733
                _la = self._input.LA(1)
                if not(_la==33 or _la==34):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 735
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 734
                    self.match(XplorMRParser.Equ_op)


                self.state = 737
                self.number_a()
                pass
            elif token in [35]:
                self.enterOuterAlt(localctx, 5)
                self.state = 738
                self.match(XplorMRParser.Ppm1)
                self.state = 740
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 739
                    self.match(XplorMRParser.Equ_op)


                self.state = 742
                self.number_a()
                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 6)
                self.state = 743
                self.match(XplorMRParser.Ppm2)
                self.state = 745
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 744
                    self.match(XplorMRParser.Equ_op)


                self.state = 747
                self.number_a()
                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 7)
                self.state = 748
                self.match(XplorMRParser.Cv)
                self.state = 750
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 749
                    self.match(XplorMRParser.Equ_op)


                self.state = 752
                self.number_a()
                pass
            elif token in [193]:
                self.enterOuterAlt(localctx, 8)
                self.state = 753
                self.match(XplorMRParser.Comma)
                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 Dihedral_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vector_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_statementContext,0)


        def dihedral_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Dihedral_assignContext,0)


        def dihedral_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Dihedral_assign_loopContext,0)


        def Nassign(self):
            return self.getToken(XplorMRParser.Nassign, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Print_any(self):
            return self.getToken(XplorMRParser.Print_any, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_statement

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

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




    def dihedral_statement(self):

        localctx = XplorMRParser.Dihedral_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_dihedral_statement)
        self._la = 0 # Token type
        try:
            self.state = 771
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [169]:
                self.enterOuterAlt(localctx, 1)
                self.state = 756
                self.vector_statement()
                pass
            elif token in [4]:
                self.enterOuterAlt(localctx, 2)
                self.state = 757
                self.dihedral_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 3)
                self.state = 758
                self.dihedral_assign_loop()
                pass
            elif token in [39]:
                self.enterOuterAlt(localctx, 4)
                self.state = 759
                self.match(XplorMRParser.Nassign)
                self.state = 761
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 760
                    self.match(XplorMRParser.Equ_op)


                self.state = 763
                self.match(XplorMRParser.Integer)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 5)
                self.state = 764
                self.match(XplorMRParser.Reset)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 6)
                self.state = 765
                self.match(XplorMRParser.Scale)
                self.state = 767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 766
                    self.match(XplorMRParser.Equ_op)


                self.state = 769
                self.number_s()
                pass
            elif token in [40]:
                self.enterOuterAlt(localctx, 7)
                self.state = 770
                self.match(XplorMRParser.Print_any)
                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 Dihedral_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_assign

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

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




    def dihedral_assign(self):

        localctx = XplorMRParser.Dihedral_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_dihedral_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 773
            self.match(XplorMRParser.Assign)
            self.state = 774
            self.selection()
            self.state = 775
            self.selection()
            self.state = 776
            self.selection()
            self.state = 777
            self.selection()
            self.state = 778
            self.number()
            self.state = 779
            self.number()
            self.state = 780
            self.number()
            self.state = 781
            self.match(XplorMRParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sani_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sani_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Sani_assignContext,0)


        def sani_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Sani_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_sani_statement

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

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




    def sani_statement(self):

        localctx = XplorMRParser.Sani_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_sani_statement)
        self._la = 0 # Token type
        try:
            self.state = 810
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 783
                self.sani_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 784
                self.sani_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 785
                self.classification()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 4)
                self.state = 786
                self.match(XplorMRParser.Coefficients)
                self.state = 787
                self.number_s()
                self.state = 788
                self.number_s()
                self.state = 789
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 791
                self.match(XplorMRParser.ForceConstant)
                self.state = 793
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 792
                    self.match(XplorMRParser.Equ_op)


                self.state = 795
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 6)
                self.state = 796
                self.match(XplorMRParser.Nrestraints)
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 797
                    self.match(XplorMRParser.Equ_op)


                self.state = 800
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 7)
                self.state = 801
                self.match(XplorMRParser.Potential)
                self.state = 803
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 802
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 805
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 8)
                self.state = 806
                self.match(XplorMRParser.Print)
                self.state = 807
                self.match(XplorMRParser.Threshold)
                self.state = 808
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 9)
                self.state = 809
                self.match(XplorMRParser.Reset)
                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 Sani_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_sani_assign

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

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




    def sani_assign(self):

        localctx = XplorMRParser.Sani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_sani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 812
            self.match(XplorMRParser.Assign)
            self.state = 813
            self.selection()
            self.state = 814
            self.selection()
            self.state = 815
            self.selection()
            self.state = 816
            self.selection()
            self.state = 817
            self.selection()
            self.state = 818
            self.selection()
            self.state = 819
            self.number()
            self.state = 821
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.state = 820
                self.number()


            self.state = 824
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 823
                self.number()


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


    class Xdip_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def xdip_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Xdip_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Type(self):
            return self.getToken(XplorMRParser.Type, 0)

        def Rdc_dist_fix_types(self):
            return self.getToken(XplorMRParser.Rdc_dist_fix_types, 0)

        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Sign(self):
            return self.getToken(XplorMRParser.Sign, 0)

        def Logical(self):
            return self.getToken(XplorMRParser.Logical, 0)

        def Average(self):
            return self.getToken(XplorMRParser.Average, 0)

        def Averaging_methods(self):
            return self.getToken(XplorMRParser.Averaging_methods, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_xdip_statement

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

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




    def xdip_statement(self):

        localctx = XplorMRParser.Xdip_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_xdip_statement)
        self._la = 0 # Token type
        try:
            self.state = 863
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 826
                self.xdip_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 827
                self.classification()
                pass
            elif token in [46]:
                self.enterOuterAlt(localctx, 3)
                self.state = 828
                self.match(XplorMRParser.Type)
                self.state = 829
                self.match(XplorMRParser.Rdc_dist_fix_types)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 4)
                self.state = 830
                self.match(XplorMRParser.Scale)
                self.state = 832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 831
                    self.match(XplorMRParser.Equ_op)


                self.state = 834
                self.number_s()
                pass
            elif token in [47]:
                self.enterOuterAlt(localctx, 5)
                self.state = 835
                self.match(XplorMRParser.Sign)
                self.state = 836
                self.match(XplorMRParser.Logical)
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 6)
                self.state = 837
                self.match(XplorMRParser.Average)
                self.state = 838
                self.match(XplorMRParser.Averaging_methods)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 7)
                self.state = 839
                self.match(XplorMRParser.Coefficients)
                self.state = 840
                self.number_s()
                self.state = 841
                self.number_s()
                self.state = 842
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 8)
                self.state = 844
                self.match(XplorMRParser.ForceConstant)
                self.state = 846
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 845
                    self.match(XplorMRParser.Equ_op)


                self.state = 848
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 9)
                self.state = 849
                self.match(XplorMRParser.Nrestraints)
                self.state = 851
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 850
                    self.match(XplorMRParser.Equ_op)


                self.state = 853
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 10)
                self.state = 854
                self.match(XplorMRParser.Potential)
                self.state = 856
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 855
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 858
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 11)
                self.state = 859
                self.match(XplorMRParser.Print)
                self.state = 860
                self.match(XplorMRParser.Threshold)
                self.state = 861
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 12)
                self.state = 862
                self.match(XplorMRParser.Reset)
                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 Xdip_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_xdip_assign

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

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




    def xdip_assign(self):

        localctx = XplorMRParser.Xdip_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_xdip_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 865
            self.match(XplorMRParser.Assign)
            self.state = 866
            self.selection()
            self.state = 867
            self.selection()
            self.state = 868
            self.selection()
            self.state = 869
            self.selection()
            self.state = 870
            self.selection()
            self.state = 871
            self.selection()
            self.state = 872
            self.number()
            self.state = 873
            self.number()
            self.state = 880
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 874
                self.number()

            elif la_ == 2:
                self.state = 875
                self.number()
                self.state = 876
                self.number()
                self.state = 877
                self.number()
                self.state = 878
                self.number()


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


    class Vean_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vean_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Vean_assignContext,0)


        def Cv(self):
            return self.getToken(XplorMRParser.Cv, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Partition(self):
            return self.getToken(XplorMRParser.Partition, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vean_statement

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

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




    def vean_statement(self):

        localctx = XplorMRParser.Vean_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_vean_statement)
        self._la = 0 # Token type
        try:
            self.state = 910
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 882
                self.vean_assign()
                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 2)
                self.state = 883
                self.match(XplorMRParser.Cv)
                self.state = 885
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 884
                    self.match(XplorMRParser.Equ_op)


                self.state = 887
                self.match(XplorMRParser.Integer)
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 888
                self.classification()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 889
                self.match(XplorMRParser.ForceConstant)
                self.state = 891
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 890
                    self.match(XplorMRParser.Equ_op)


                self.state = 893
                self.number_s()
                self.state = 894
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 896
                self.match(XplorMRParser.Nrestraints)
                self.state = 898
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 897
                    self.match(XplorMRParser.Equ_op)


                self.state = 900
                self.match(XplorMRParser.Integer)
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 6)
                self.state = 901
                self.match(XplorMRParser.Partition)
                self.state = 903
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 902
                    self.match(XplorMRParser.Equ_op)


                self.state = 905
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 906
                self.match(XplorMRParser.Print)
                self.state = 907
                self.match(XplorMRParser.Threshold)
                self.state = 908
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 8)
                self.state = 909
                self.match(XplorMRParser.Reset)
                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 Vean_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vean_assign

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

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




    def vean_assign(self):

        localctx = XplorMRParser.Vean_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_vean_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 912
            self.match(XplorMRParser.Assign)
            self.state = 913
            self.selection()
            self.state = 914
            self.selection()
            self.state = 915
            self.selection()
            self.state = 916
            self.selection()
            self.state = 917
            self.number()
            self.state = 918
            self.number()
            self.state = 922
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 919
                self.number()
                self.state = 920
                self.number()


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


    class Tenso_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def tenso_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Tenso_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_tenso_statement

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

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




    def tenso_statement(self):

        localctx = XplorMRParser.Tenso_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_tenso_statement)
        self._la = 0 # Token type
        try:
            self.state = 942
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 924
                self.tenso_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 925
                self.classification()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 3)
                self.state = 926
                self.match(XplorMRParser.Coefficients)
                self.state = 927
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 4)
                self.state = 928
                self.match(XplorMRParser.Nrestraints)
                self.state = 930
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 929
                    self.match(XplorMRParser.Equ_op)


                self.state = 932
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 5)
                self.state = 933
                self.match(XplorMRParser.Potential)
                self.state = 935
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 934
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 937
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 6)
                self.state = 938
                self.match(XplorMRParser.Print)
                self.state = 939
                self.match(XplorMRParser.Threshold)
                self.state = 940
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 7)
                self.state = 941
                self.match(XplorMRParser.Reset)
                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 Tenso_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_tenso_assign

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

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




    def tenso_assign(self):

        localctx = XplorMRParser.Tenso_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_tenso_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 944
            self.match(XplorMRParser.Assign)
            self.state = 945
            self.selection()
            self.state = 946
            self.selection()
            self.state = 947
            self.number()
            self.state = 949
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 948
                self.number()


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


    class Anis_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def anis_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Anis_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Type(self):
            return self.getToken(XplorMRParser.Type, 0)

        def Rdc_or_Diff_anis_types(self):
            return self.getToken(XplorMRParser.Rdc_or_Diff_anis_types, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_anis_statement

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

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




    def anis_statement(self):

        localctx = XplorMRParser.Anis_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_anis_statement)
        self._la = 0 # Token type
        try:
            self.state = 980
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 951
                self.anis_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 952
                self.classification()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 3)
                self.state = 953
                self.match(XplorMRParser.Coefficients)
                self.state = 954
                self.number_s()
                self.state = 955
                self.number_s()
                self.state = 956
                self.number_s()
                self.state = 957
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 959
                self.match(XplorMRParser.ForceConstant)
                self.state = 961
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 960
                    self.match(XplorMRParser.Equ_op)


                self.state = 963
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 964
                self.match(XplorMRParser.Nrestraints)
                self.state = 966
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 965
                    self.match(XplorMRParser.Equ_op)


                self.state = 968
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 6)
                self.state = 969
                self.match(XplorMRParser.Potential)
                self.state = 971
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 970
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 973
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 974
                self.match(XplorMRParser.Print)
                self.state = 975
                self.match(XplorMRParser.Threshold)
                self.state = 976
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 8)
                self.state = 977
                self.match(XplorMRParser.Reset)
                pass
            elif token in [46]:
                self.enterOuterAlt(localctx, 9)
                self.state = 978
                self.match(XplorMRParser.Type)
                self.state = 979
                self.match(XplorMRParser.Rdc_or_Diff_anis_types)
                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 Anis_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_anis_assign

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

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




    def anis_assign(self):

        localctx = XplorMRParser.Anis_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_anis_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 982
            self.match(XplorMRParser.Assign)
            self.state = 983
            self.selection()
            self.state = 984
            self.selection()
            self.state = 985
            self.selection()
            self.state = 986
            self.selection()
            self.state = 987
            self.number()
            self.state = 989
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 988
                self.number()


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


    class Planar_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vector_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_statementContext,0)


        def planar_group(self):
            return self.getTypedRuleContext(XplorMRParser.Planar_groupContext,0)


        def planar_group_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Planar_group_loopContext,0)


        def Initialize(self):
            return self.getToken(XplorMRParser.Initialize, 0)

        def Print_any(self):
            return self.getToken(XplorMRParser.Print_any, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_statement

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

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




    def planar_statement(self):

        localctx = XplorMRParser.Planar_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_planar_statement)
        try:
            self.state = 996
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [169]:
                self.enterOuterAlt(localctx, 1)
                self.state = 991
                self.vector_statement()
                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 992
                self.planar_group()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 3)
                self.state = 993
                self.planar_group_loop()
                pass
            elif token in [55]:
                self.enterOuterAlt(localctx, 4)
                self.state = 994
                self.match(XplorMRParser.Initialize)
                pass
            elif token in [40]:
                self.enterOuterAlt(localctx, 5)
                self.state = 995
                self.match(XplorMRParser.Print_any)
                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 Planar_groupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Group(self):
            return self.getToken(XplorMRParser.Group, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def group_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Group_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Group_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_group

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

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




    def planar_group(self):

        localctx = XplorMRParser.Planar_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_planar_group)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 998
            self.match(XplorMRParser.Group)
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==56 or _la==57:
                self.state = 999
                self.group_statement()
                self.state = 1004
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1005
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Group_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Selection(self):
            return self.getToken(XplorMRParser.Selection, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Weight(self):
            return self.getToken(XplorMRParser.Weight, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_group_statement

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

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




    def group_statement(self):

        localctx = XplorMRParser.Group_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 1017
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1007
                self.match(XplorMRParser.Selection)
                self.state = 1009
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1008
                    self.match(XplorMRParser.Equ_op)


                self.state = 1011
                self.selection()
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1012
                self.match(XplorMRParser.Weight)
                self.state = 1014
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1013
                    self.match(XplorMRParser.Equ_op)


                self.state = 1016
                self.number_s()
                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 Harmonic_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vector_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_statementContext,0)


        def Exponent(self):
            return self.getToken(XplorMRParser.Exponent, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

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

        def Normal(self):
            return self.getToken(XplorMRParser.Normal, 0)

        def L_paren(self):
            return self.getToken(XplorMRParser.L_paren, 0)

        def R_paren(self):
            return self.getToken(XplorMRParser.R_paren, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Tail(self):
            return self.getToken(XplorMRParser.Tail, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


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

        def Head(self):
            return self.getToken(XplorMRParser.Head, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_harmonic_statement

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

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




    def harmonic_statement(self):

        localctx = XplorMRParser.Harmonic_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_harmonic_statement)
        self._la = 0 # Token type
        try:
            self.state = 1059
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [169]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1019
                self.vector_statement()
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1020
                self.match(XplorMRParser.Exponent)
                self.state = 1022
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1021
                    self.match(XplorMRParser.Equ_op)


                self.state = 1024
                self.match(XplorMRParser.Integer)
                pass
            elif token in [60]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1025
                self.match(XplorMRParser.Normal)
                self.state = 1027
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1026
                    self.match(XplorMRParser.Equ_op)


                self.state = 1029
                self.match(XplorMRParser.L_paren)
                self.state = 1055
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [195, 197, 214]:
                    self.state = 1030
                    self.number_s()
                    self.state = 1032
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==193:
                        self.state = 1031
                        self.match(XplorMRParser.Comma)


                    self.state = 1034
                    self.number_s()
                    self.state = 1036
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==193:
                        self.state = 1035
                        self.match(XplorMRParser.Comma)


                    self.state = 1038
                    self.number_s()
                    pass
                elif token in [188]:
                    self.state = 1040
                    self.match(XplorMRParser.Tail)
                    self.state = 1042
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==208:
                        self.state = 1041
                        self.match(XplorMRParser.Equ_op)


                    self.state = 1044
                    self.selection()
                    self.state = 1046
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==193:
                        self.state = 1045
                        self.match(XplorMRParser.Comma)


                    self.state = 1053
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==189:
                        self.state = 1048
                        self.match(XplorMRParser.Head)
                        self.state = 1050
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==208:
                            self.state = 1049
                            self.match(XplorMRParser.Equ_op)


                        self.state = 1052
                        self.selection()


                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1057
                self.match(XplorMRParser.R_paren)
                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 Harmonic_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_harmonic_assign

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

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




    def harmonic_assign(self):

        localctx = XplorMRParser.Harmonic_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_harmonic_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1061
            self.match(XplorMRParser.Assign)
            self.state = 1062
            self.selection()
            self.state = 1063
            self.number()
            self.state = 1064
            self.number()
            self.state = 1065
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Antidistance_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def xadc_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Xadc_assignContext,0)


        def xadc_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Xadc_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Expectation(self):
            return self.getToken(XplorMRParser.Expectation, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Size(self):
            return self.getToken(XplorMRParser.Size, 0)

        def Zero(self):
            return self.getToken(XplorMRParser.Zero, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_antidistance_statement

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

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




    def antidistance_statement(self):

        localctx = XplorMRParser.Antidistance_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_antidistance_statement)
        self._la = 0 # Token type
        try:
            self.state = 1096
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1067
                self.xadc_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1068
                self.xadc_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1069
                self.classification()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1070
                self.match(XplorMRParser.Expectation)
                self.state = 1071
                self.match(XplorMRParser.Integer)
                self.state = 1072
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1073
                self.match(XplorMRParser.ForceConstant)
                self.state = 1075
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1074
                    self.match(XplorMRParser.Equ_op)


                self.state = 1077
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1078
                self.match(XplorMRParser.Nrestraints)
                self.state = 1080
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1079
                    self.match(XplorMRParser.Equ_op)


                self.state = 1082
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1083
                self.match(XplorMRParser.Print)
                self.state = 1084
                self.match(XplorMRParser.Threshold)
                self.state = 1085
                self.number_s()
                self.state = 1088
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1086
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1087
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1090
                self.match(XplorMRParser.Reset)
                pass
            elif token in [63]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1091
                self.match(XplorMRParser.Size)
                self.state = 1092
                self.number_s()
                self.state = 1093
                self.match(XplorMRParser.Integer)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1095
                self.match(XplorMRParser.Zero)
                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 Xadc_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_xadc_assign

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

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




    def xadc_assign(self):

        localctx = XplorMRParser.Xadc_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_xadc_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1098
            self.match(XplorMRParser.Assign)
            self.state = 1099
            self.selection()
            self.state = 1100
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Coupling_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def coup_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Coup_assignContext,0)


        def coup_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Coup_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Cv(self):
            return self.getToken(XplorMRParser.Cv, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Degeneracy(self):
            return self.getToken(XplorMRParser.Degeneracy, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Partition(self):
            return self.getToken(XplorMRParser.Partition, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_coupling_statement

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

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




    def coupling_statement(self):

        localctx = XplorMRParser.Coupling_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 1146
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1102
                self.coup_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1103
                self.coup_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1104
                self.classification()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1105
                self.match(XplorMRParser.Coefficients)
                self.state = 1106
                self.number_s()
                self.state = 1107
                self.number_s()
                self.state = 1108
                self.number_s()
                self.state = 1109
                self.number_s()
                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1111
                self.match(XplorMRParser.Cv)
                self.state = 1113
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1112
                    self.match(XplorMRParser.Equ_op)


                self.state = 1115
                self.match(XplorMRParser.Integer)
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1116
                self.match(XplorMRParser.Degeneracy)
                self.state = 1117
                self.match(XplorMRParser.Integer)
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1118
                self.match(XplorMRParser.ForceConstant)
                self.state = 1119
                self.number_s()
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 1120
                    self.number_s()


                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1123
                self.match(XplorMRParser.Nrestraints)
                self.state = 1125
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1124
                    self.match(XplorMRParser.Equ_op)


                self.state = 1127
                self.match(XplorMRParser.Integer)
                pass
            elif token in [50]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1128
                self.match(XplorMRParser.Partition)
                self.state = 1130
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1129
                    self.match(XplorMRParser.Equ_op)


                self.state = 1132
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1133
                self.match(XplorMRParser.Potential)
                self.state = 1135
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1134
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1137
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1138
                self.match(XplorMRParser.Print)
                self.state = 1139
                self.match(XplorMRParser.Threshold)
                self.state = 1140
                self.number_s()
                self.state = 1143
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1141
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1142
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1145
                self.match(XplorMRParser.Reset)
                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 Coup_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_coup_assign

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

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




    def coup_assign(self):

        localctx = XplorMRParser.Coup_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_coup_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1148
            self.match(XplorMRParser.Assign)
            self.state = 1149
            self.selection()
            self.state = 1150
            self.selection()
            self.state = 1151
            self.selection()
            self.state = 1152
            self.selection()
            self.state = 1158
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==205:
                self.state = 1153
                self.selection()
                self.state = 1154
                self.selection()
                self.state = 1155
                self.selection()
                self.state = 1156
                self.selection()


            self.state = 1160
            self.number()
            self.state = 1161
            self.number()
            self.state = 1165
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1162
                self.number()
                self.state = 1163
                self.number()


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


    class Carbon_shift_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def carbon_shift_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Carbon_shift_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Expectation(self):
            return self.getToken(XplorMRParser.Expectation, 0)

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

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def PhiStep(self):
            return self.getToken(XplorMRParser.PhiStep, 0)

        def PsiStep(self):
            return self.getToken(XplorMRParser.PsiStep, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def carbon_shift_rcoil(self):
            return self.getTypedRuleContext(XplorMRParser.Carbon_shift_rcoilContext,0)


        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Zero(self):
            return self.getToken(XplorMRParser.Zero, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_statement

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

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




    def carbon_shift_statement(self):

        localctx = XplorMRParser.Carbon_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_carbon_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 1201
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1167
                self.carbon_shift_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1168
                self.classification()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1169
                self.match(XplorMRParser.Expectation)
                self.state = 1170
                self.match(XplorMRParser.Integer)
                self.state = 1171
                self.match(XplorMRParser.Integer)
                self.state = 1172
                self.number_s()
                self.state = 1173
                self.number_s()
                self.state = 1174
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1176
                self.match(XplorMRParser.ForceConstant)
                self.state = 1178
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1177
                    self.match(XplorMRParser.Equ_op)


                self.state = 1180
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1181
                self.match(XplorMRParser.Nrestraints)
                self.state = 1183
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1182
                    self.match(XplorMRParser.Equ_op)


                self.state = 1185
                self.match(XplorMRParser.Integer)
                pass
            elif token in [68]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1186
                self.match(XplorMRParser.PhiStep)
                self.state = 1187
                self.number_s()
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1188
                self.match(XplorMRParser.PsiStep)
                self.state = 1189
                self.number_s()
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1190
                self.match(XplorMRParser.Potential)
                self.state = 1192
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1191
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1194
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1195
                self.match(XplorMRParser.Print)
                self.state = 1196
                self.match(XplorMRParser.Threshold)
                self.state = 1197
                self.number_s()
                pass
            elif token in [70]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1198
                self.carbon_shift_rcoil()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1199
                self.match(XplorMRParser.Reset)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1200
                self.match(XplorMRParser.Zero)
                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 Carbon_shift_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_assign

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

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




    def carbon_shift_assign(self):

        localctx = XplorMRParser.Carbon_shift_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_carbon_shift_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1203
            self.match(XplorMRParser.Assign)
            self.state = 1204
            self.selection()
            self.state = 1205
            self.selection()
            self.state = 1206
            self.selection()
            self.state = 1207
            self.selection()
            self.state = 1208
            self.selection()
            self.state = 1209
            self.number()
            self.state = 1210
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Carbon_shift_rcoilContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Rcoil(self):
            return self.getToken(XplorMRParser.Rcoil, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_rcoil

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

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




    def carbon_shift_rcoil(self):

        localctx = XplorMRParser.Carbon_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_carbon_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1212
            self.match(XplorMRParser.Rcoil)
            self.state = 1213
            self.selection()
            self.state = 1214
            self.number()
            self.state = 1215
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def observed(self):
            return self.getTypedRuleContext(XplorMRParser.ObservedContext,0)


        def proton_shift_rcoil(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_rcoilContext,0)


        def proton_shift_anisotropy(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_anisotropyContext,0)


        def proton_shift_amides(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_amidesContext,0)


        def proton_shift_carbons(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_carbonsContext,0)


        def proton_shift_nitrogens(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_nitrogensContext,0)


        def proton_shift_oxygens(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_oxygensContext,0)


        def proton_shift_ring_atoms(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_ring_atomsContext,0)


        def proton_shift_alphas_and_amides(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_alphas_and_amidesContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Error(self):
            return self.getToken(XplorMRParser.Error, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Degeneracy(self):
            return self.getToken(XplorMRParser.Degeneracy, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_statement

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

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




    def proton_shift_statement(self):

        localctx = XplorMRParser.Proton_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_proton_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 1251
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [72]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1217
                self.observed()
                pass
            elif token in [70]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1218
                self.proton_shift_rcoil()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1219
                self.proton_shift_anisotropy()
                pass
            elif token in [73]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1220
                self.proton_shift_amides()
                pass
            elif token in [67]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1221
                self.proton_shift_carbons()
                pass
            elif token in [74]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1222
                self.proton_shift_nitrogens()
                pass
            elif token in [75]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1223
                self.proton_shift_oxygens()
                pass
            elif token in [76]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1224
                self.proton_shift_ring_atoms()
                pass
            elif token in [77]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1225
                self.proton_shift_alphas_and_amides()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1226
                self.classification()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1227
                self.match(XplorMRParser.Error)
                self.state = 1228
                self.number_s()
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1229
                self.match(XplorMRParser.Degeneracy)
                self.state = 1230
                self.match(XplorMRParser.Integer)
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1231
                self.match(XplorMRParser.ForceConstant)
                self.state = 1232
                self.number_s()
                self.state = 1234
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 1233
                    self.number_s()


                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1236
                self.match(XplorMRParser.Potential)
                self.state = 1238
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1237
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1240
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1241
                self.match(XplorMRParser.Print)
                self.state = 1242
                self.match(XplorMRParser.Threshold)
                self.state = 1243
                self.number_s()
                self.state = 1246
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1244
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1245
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1248
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1250
                self.match(XplorMRParser.Reset)
                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 ObservedContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Observed(self):
            return self.getToken(XplorMRParser.Observed, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_observed

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

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




    def observed(self):

        localctx = XplorMRParser.ObservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_observed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1253
            self.match(XplorMRParser.Observed)
            self.state = 1254
            self.selection()
            self.state = 1256
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==205:
                self.state = 1255
                self.selection()


            self.state = 1258
            self.number()
            self.state = 1260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1259
                self.number()


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


    class Proton_shift_rcoilContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Rcoil(self):
            return self.getToken(XplorMRParser.Rcoil, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def number(self):
            return self.getTypedRuleContext(XplorMRParser.NumberContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_rcoil

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

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




    def proton_shift_rcoil(self):

        localctx = XplorMRParser.Proton_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_proton_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1262
            self.match(XplorMRParser.Rcoil)
            self.state = 1263
            self.selection()
            self.state = 1264
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_anisotropyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Anisotropy(self):
            return self.getToken(XplorMRParser.Anisotropy, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


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

        def Logical(self):
            return self.getToken(XplorMRParser.Logical, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_anisotropy

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

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




    def proton_shift_anisotropy(self):

        localctx = XplorMRParser.Proton_shift_anisotropyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_proton_shift_anisotropy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1266
            self.match(XplorMRParser.Anisotropy)
            self.state = 1267
            self.selection()
            self.state = 1268
            self.selection()
            self.state = 1269
            self.selection()
            self.state = 1270
            self.match(XplorMRParser.Simple_name)
            self.state = 1272
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==196:
                self.state = 1271
                self.match(XplorMRParser.Logical)


            self.state = 1274
            self.match(XplorMRParser.Simple_name)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_amidesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Amides(self):
            return self.getToken(XplorMRParser.Amides, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_amides

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

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




    def proton_shift_amides(self):

        localctx = XplorMRParser.Proton_shift_amidesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_proton_shift_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1276
            self.match(XplorMRParser.Amides)
            self.state = 1277
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_carbonsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Carbon(self):
            return self.getToken(XplorMRParser.Carbon, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_carbons

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

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




    def proton_shift_carbons(self):

        localctx = XplorMRParser.Proton_shift_carbonsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_proton_shift_carbons)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1279
            self.match(XplorMRParser.Carbon)
            self.state = 1280
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_nitrogensContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Nitrogens(self):
            return self.getToken(XplorMRParser.Nitrogens, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_nitrogens

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

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




    def proton_shift_nitrogens(self):

        localctx = XplorMRParser.Proton_shift_nitrogensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_proton_shift_nitrogens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1282
            self.match(XplorMRParser.Nitrogens)
            self.state = 1283
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_oxygensContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Oxygens(self):
            return self.getToken(XplorMRParser.Oxygens, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_oxygens

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

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




    def proton_shift_oxygens(self):

        localctx = XplorMRParser.Proton_shift_oxygensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_proton_shift_oxygens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1285
            self.match(XplorMRParser.Oxygens)
            self.state = 1286
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_ring_atomsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RingAtoms(self):
            return self.getToken(XplorMRParser.RingAtoms, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_ring_atoms

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

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




    def proton_shift_ring_atoms(self):

        localctx = XplorMRParser.Proton_shift_ring_atomsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_proton_shift_ring_atoms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1288
            self.match(XplorMRParser.RingAtoms)
            self.state = 1289
            self.match(XplorMRParser.Simple_name)
            self.state = 1290
            self.selection()
            self.state = 1291
            self.selection()
            self.state = 1292
            self.selection()
            self.state = 1293
            self.selection()
            self.state = 1294
            self.selection()
            self.state = 1296
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==205:
                self.state = 1295
                self.selection()


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


    class Proton_shift_alphas_and_amidesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AlphasAndAmides(self):
            return self.getToken(XplorMRParser.AlphasAndAmides, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_alphas_and_amides

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

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




    def proton_shift_alphas_and_amides(self):

        localctx = XplorMRParser.Proton_shift_alphas_and_amidesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_proton_shift_alphas_and_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1298
            self.match(XplorMRParser.AlphasAndAmides)
            self.state = 1299
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ramachandran_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def rama_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Rama_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Cutoff(self):
            return self.getToken(XplorMRParser.Cutoff, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Gaussian(self):
            return self.getToken(XplorMRParser.Gaussian, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Phase(self):
            return self.getToken(XplorMRParser.Phase, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Quartic(self):
            return self.getToken(XplorMRParser.Quartic, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def Shape(self):
            return self.getToken(XplorMRParser.Shape, 0)

        def Gauss_or_Quart(self):
            return self.getToken(XplorMRParser.Gauss_or_Quart, 0)

        def Size(self):
            return self.getToken(XplorMRParser.Size, 0)

        def Dimensions(self):
            return self.getToken(XplorMRParser.Dimensions, 0)

        def Sort(self):
            return self.getToken(XplorMRParser.Sort, 0)

        def Zero(self):
            return self.getToken(XplorMRParser.Zero, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_ramachandran_statement

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

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




    def ramachandran_statement(self):

        localctx = XplorMRParser.Ramachandran_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_ramachandran_statement)
        self._la = 0 # Token type
        try:
            self.state = 1410
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1301
                self.rama_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1302
                self.classification()
                pass
            elif token in [27]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1303
                self.match(XplorMRParser.Cutoff)
                self.state = 1304
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1305
                self.match(XplorMRParser.ForceConstant)
                self.state = 1307
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1306
                    self.match(XplorMRParser.Equ_op)


                self.state = 1309
                self.number_s()
                pass
            elif token in [80]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1310
                self.match(XplorMRParser.Gaussian)
                self.state = 1311
                self.number_s()
                self.state = 1312
                self.number_s()
                self.state = 1313
                self.number_s()
                self.state = 1318
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                if la_ == 1:
                    self.state = 1314
                    self.number_s()
                    self.state = 1315
                    self.number_s()
                    self.state = 1316
                    self.number_s()


                self.state = 1324
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
                if la_ == 1:
                    self.state = 1320
                    self.number_s()
                    self.state = 1321
                    self.number_s()
                    self.state = 1322
                    self.number_s()


                self.state = 1330
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 1326
                    self.number_s()
                    self.state = 1327
                    self.number_s()
                    self.state = 1328
                    self.number_s()


                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1332
                self.match(XplorMRParser.Nrestraints)
                self.state = 1334
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1333
                    self.match(XplorMRParser.Equ_op)


                self.state = 1336
                self.match(XplorMRParser.Integer)
                pass
            elif token in [81]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1337
                self.match(XplorMRParser.Phase)
                self.state = 1338
                self.number_s()
                self.state = 1339
                self.number_s()
                self.state = 1340
                self.number_s()
                self.state = 1345
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
                if la_ == 1:
                    self.state = 1341
                    self.number_s()
                    self.state = 1342
                    self.number_s()
                    self.state = 1343
                    self.number_s()


                self.state = 1351
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                if la_ == 1:
                    self.state = 1347
                    self.number_s()
                    self.state = 1348
                    self.number_s()
                    self.state = 1349
                    self.number_s()


                self.state = 1357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 1353
                    self.number_s()
                    self.state = 1354
                    self.number_s()
                    self.state = 1355
                    self.number_s()


                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1359
                self.match(XplorMRParser.Print)
                self.state = 1360
                self.match(XplorMRParser.Threshold)
                self.state = 1361
                self.number_s()
                self.state = 1364
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1362
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1363
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1366
                self.match(XplorMRParser.Quartic)
                self.state = 1367
                self.number_s()
                self.state = 1368
                self.number_s()
                self.state = 1369
                self.number_s()
                self.state = 1374
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
                if la_ == 1:
                    self.state = 1370
                    self.number_s()
                    self.state = 1371
                    self.number_s()
                    self.state = 1372
                    self.number_s()


                self.state = 1380
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
                if la_ == 1:
                    self.state = 1376
                    self.number_s()
                    self.state = 1377
                    self.number_s()
                    self.state = 1378
                    self.number_s()


                self.state = 1386
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 1382
                    self.number_s()
                    self.state = 1383
                    self.number_s()
                    self.state = 1384
                    self.number_s()


                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1388
                self.match(XplorMRParser.Reset)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1389
                self.match(XplorMRParser.Scale)
                self.state = 1391
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1390
                    self.match(XplorMRParser.Equ_op)


                self.state = 1393
                self.number_s()
                pass
            elif token in [83]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1394
                self.match(XplorMRParser.Shape)
                self.state = 1395
                self.match(XplorMRParser.Gauss_or_Quart)
                pass
            elif token in [63]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1396
                self.match(XplorMRParser.Size)
                self.state = 1397
                self.match(XplorMRParser.Dimensions)
                self.state = 1398
                self.number_s()
                self.state = 1400
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                if la_ == 1:
                    self.state = 1399
                    self.number_s()


                self.state = 1403
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
                if la_ == 1:
                    self.state = 1402
                    self.number_s()


                self.state = 1406
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                    self.state = 1405
                    self.number_s()


                pass
            elif token in [84]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1408
                self.match(XplorMRParser.Sort)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1409
                self.match(XplorMRParser.Zero)
                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 Rama_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_rama_assign

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

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




    def rama_assign(self):

        localctx = XplorMRParser.Rama_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_rama_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1412
            self.match(XplorMRParser.Assign)
            self.state = 1413
            self.selection()
            self.state = 1414
            self.selection()
            self.state = 1415
            self.selection()
            self.state = 1416
            self.selection()
            self.state = 1422
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
            if la_ == 1:
                self.state = 1417
                self.selection()
                self.state = 1418
                self.selection()
                self.state = 1419
                self.selection()
                self.state = 1420
                self.selection()


            self.state = 1429
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.state = 1424
                self.selection()
                self.state = 1425
                self.selection()
                self.state = 1426
                self.selection()
                self.state = 1427
                self.selection()


            self.state = 1436
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==205:
                self.state = 1431
                self.selection()
                self.state = 1432
                self.selection()
                self.state = 1433
                self.selection()
                self.state = 1434
                self.selection()


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


    class Collapse_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def coll_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Coll_assignContext,0)


        def coll_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Coll_assign_loopContext,0)


        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_collapse_statement

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

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




    def collapse_statement(self):

        localctx = XplorMRParser.Collapse_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_collapse_statement)
        self._la = 0 # Token type
        try:
            self.state = 1447
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1438
                self.coll_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1439
                self.coll_assign_loop()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1440
                self.match(XplorMRParser.Scale)
                self.state = 1442
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1441
                    self.match(XplorMRParser.Equ_op)


                self.state = 1444
                self.number_s()
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1445
                self.match(XplorMRParser.Print)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1446
                self.match(XplorMRParser.Reset)
                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 Coll_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_coll_assign

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

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




    def coll_assign(self):

        localctx = XplorMRParser.Coll_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_coll_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1449
            self.match(XplorMRParser.Assign)
            self.state = 1450
            self.selection()
            self.state = 1451
            self.number()
            self.state = 1452
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Diffusion_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def dani_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Dani_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Type(self):
            return self.getToken(XplorMRParser.Type, 0)

        def Rdc_or_Diff_anis_types(self):
            return self.getToken(XplorMRParser.Rdc_or_Diff_anis_types, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_diffusion_statement

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

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




    def diffusion_statement(self):

        localctx = XplorMRParser.Diffusion_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_diffusion_statement)
        self._la = 0 # Token type
        try:
            self.state = 1484
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1454
                self.dani_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1455
                self.classification()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1456
                self.match(XplorMRParser.Coefficients)
                self.state = 1457
                self.number_s()
                self.state = 1458
                self.number_s()
                self.state = 1459
                self.number_s()
                self.state = 1460
                self.number_s()
                self.state = 1461
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1463
                self.match(XplorMRParser.ForceConstant)
                self.state = 1465
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1464
                    self.match(XplorMRParser.Equ_op)


                self.state = 1467
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1468
                self.match(XplorMRParser.Nrestraints)
                self.state = 1470
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1469
                    self.match(XplorMRParser.Equ_op)


                self.state = 1472
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1473
                self.match(XplorMRParser.Potential)
                self.state = 1475
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1474
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1477
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1478
                self.match(XplorMRParser.Print)
                self.state = 1479
                self.match(XplorMRParser.Threshold)
                self.state = 1480
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1481
                self.match(XplorMRParser.Reset)
                pass
            elif token in [46]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1482
                self.match(XplorMRParser.Type)
                self.state = 1483
                self.match(XplorMRParser.Rdc_or_Diff_anis_types)
                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 Dani_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_dani_assign

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

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




    def dani_assign(self):

        localctx = XplorMRParser.Dani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_dani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1486
            self.match(XplorMRParser.Assign)
            self.state = 1487
            self.selection()
            self.state = 1488
            self.selection()
            self.state = 1489
            self.selection()
            self.state = 1490
            self.selection()
            self.state = 1491
            self.selection()
            self.state = 1492
            self.selection()
            self.state = 1493
            self.number()
            self.state = 1495
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1494
                self.number()


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


    class Orientation_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def orie_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Orie_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Cutoff(self):
            return self.getToken(XplorMRParser.Cutoff, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Height(self):
            return self.getToken(XplorMRParser.Height, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Gaussian(self):
            return self.getToken(XplorMRParser.Gaussian, 0)

        def MaxGaussians(self):
            return self.getToken(XplorMRParser.MaxGaussians, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def NewGaussian(self):
            return self.getToken(XplorMRParser.NewGaussian, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Quartic(self):
            return self.getToken(XplorMRParser.Quartic, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Residue(self):
            return self.getToken(XplorMRParser.Residue, 0)

        def Size(self):
            return self.getToken(XplorMRParser.Size, 0)

        def Zero(self):
            return self.getToken(XplorMRParser.Zero, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_orientation_statement

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

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




    def orientation_statement(self):

        localctx = XplorMRParser.Orientation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_orientation_statement)
        self._la = 0 # Token type
        try:
            self.state = 1558
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1497
                self.orie_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1498
                self.classification()
                pass
            elif token in [27]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1499
                self.match(XplorMRParser.Cutoff)
                self.state = 1500
                self.number_s()
                pass
            elif token in [89]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1501
                self.match(XplorMRParser.Height)
                self.state = 1502
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1503
                self.match(XplorMRParser.ForceConstant)
                self.state = 1505
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1504
                    self.match(XplorMRParser.Equ_op)


                self.state = 1507
                self.number_s()
                pass
            elif token in [80]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1508
                self.match(XplorMRParser.Gaussian)
                self.state = 1509
                self.number_s()
                self.state = 1510
                self.number_s()
                self.state = 1511
                self.number_s()
                self.state = 1512
                self.number_s()
                self.state = 1513
                self.number_s()
                self.state = 1514
                self.number_s()
                self.state = 1515
                self.number_s()
                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1517
                self.match(XplorMRParser.MaxGaussians)
                self.state = 1518
                self.match(XplorMRParser.Integer)
                pass
            elif token in [91]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1519
                self.match(XplorMRParser.NewGaussian)
                self.state = 1520
                self.number_s()
                self.state = 1521
                self.number_s()
                self.state = 1522
                self.number_s()
                self.state = 1523
                self.number_s()
                self.state = 1524
                self.number_s()
                self.state = 1525
                self.number_s()
                self.state = 1526
                self.number_s()
                self.state = 1527
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1529
                self.match(XplorMRParser.Nrestraints)
                self.state = 1531
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1530
                    self.match(XplorMRParser.Equ_op)


                self.state = 1533
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1534
                self.match(XplorMRParser.Print)
                self.state = 1535
                self.match(XplorMRParser.Threshold)
                self.state = 1536
                self.number_s()
                self.state = 1539
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1537
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1538
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1541
                self.match(XplorMRParser.Quartic)
                self.state = 1542
                self.number_s()
                self.state = 1543
                self.number_s()
                self.state = 1544
                self.number_s()
                self.state = 1545
                self.number_s()
                self.state = 1546
                self.number_s()
                self.state = 1547
                self.number_s()
                self.state = 1548
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1550
                self.match(XplorMRParser.Reset)
                pass
            elif token in [155]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1551
                self.match(XplorMRParser.Residue)
                self.state = 1552
                self.match(XplorMRParser.Integer)
                pass
            elif token in [63]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1553
                self.match(XplorMRParser.Size)
                self.state = 1554
                self.number_s()
                self.state = 1555
                self.number_s()
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1557
                self.match(XplorMRParser.Zero)
                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 Orie_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_orie_assign

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

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




    def orie_assign(self):

        localctx = XplorMRParser.Orie_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_orie_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1560
            self.match(XplorMRParser.Assign)
            self.state = 1561
            self.selection()
            self.state = 1562
            self.selection()
            self.state = 1563
            self.selection()
            self.state = 1564
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Csa_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def csa_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,0)


        def csa_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Type(self):
            return self.getToken(XplorMRParser.Type, 0)

        def Csa_types(self):
            return self.getToken(XplorMRParser.Csa_types, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def Sigma(self):
            return self.getToken(XplorMRParser.Sigma, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_statement

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

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




    def csa_statement(self):

        localctx = XplorMRParser.Csa_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_csa_statement)
        self._la = 0 # Token type
        try:
            self.state = 1605
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1566
                self.csa_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1567
                self.csa_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1568
                self.classification()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1569
                self.match(XplorMRParser.Scale)
                self.state = 1571
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1570
                    self.match(XplorMRParser.Equ_op)


                self.state = 1573
                self.number_s()
                pass
            elif token in [46]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1574
                self.match(XplorMRParser.Type)
                self.state = 1575
                self.match(XplorMRParser.Csa_types)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1576
                self.match(XplorMRParser.Coefficients)
                self.state = 1577
                self.number_s()
                self.state = 1578
                self.number_s()
                self.state = 1579
                self.number_s()
                pass
            elif token in [93]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1581
                self.match(XplorMRParser.Sigma)
                self.state = 1582
                self.number_s()
                self.state = 1583
                self.number_s()
                self.state = 1584
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1586
                self.match(XplorMRParser.ForceConstant)
                self.state = 1588
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1587
                    self.match(XplorMRParser.Equ_op)


                self.state = 1590
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1591
                self.match(XplorMRParser.Nrestraints)
                self.state = 1593
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1592
                    self.match(XplorMRParser.Equ_op)


                self.state = 1595
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1596
                self.match(XplorMRParser.Potential)
                self.state = 1598
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1597
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1600
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1601
                self.match(XplorMRParser.Print)
                self.state = 1602
                self.match(XplorMRParser.Threshold)
                self.state = 1603
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1604
                self.match(XplorMRParser.Reset)
                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 Csa_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_assign

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

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




    def csa_assign(self):

        localctx = XplorMRParser.Csa_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_csa_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1607
            self.match(XplorMRParser.Assign)
            self.state = 1608
            self.selection()
            self.state = 1609
            self.selection()
            self.state = 1610
            self.selection()
            self.state = 1611
            self.selection()
            self.state = 1612
            self.selection()
            self.state = 1613
            self.selection()
            self.state = 1614
            self.selection()
            self.state = 1615
            self.number()
            self.state = 1617
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
            if la_ == 1:
                self.state = 1616
                self.number()


            self.state = 1620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1619
                self.number()


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


    class Pcsa_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def csa_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Scale(self):
            return self.getToken(XplorMRParser.Scale, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def Sigma(self):
            return self.getToken(XplorMRParser.Sigma, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pcsa_statement

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

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




    def pcsa_statement(self):

        localctx = XplorMRParser.Pcsa_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_pcsa_statement)
        self._la = 0 # Token type
        try:
            self.state = 1659
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1622
                self.csa_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1623
                self.classification()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1624
                self.match(XplorMRParser.Scale)
                self.state = 1626
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1625
                    self.match(XplorMRParser.Equ_op)


                self.state = 1628
                self.number_s()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1629
                self.match(XplorMRParser.Coefficients)
                self.state = 1630
                self.number_s()
                self.state = 1631
                self.number_s()
                self.state = 1632
                self.number_s()
                pass
            elif token in [93]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1634
                self.match(XplorMRParser.Sigma)
                self.state = 1635
                self.number_s()
                self.state = 1636
                self.number_s()
                self.state = 1637
                self.number_s()
                self.state = 1638
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1640
                self.match(XplorMRParser.ForceConstant)
                self.state = 1642
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1641
                    self.match(XplorMRParser.Equ_op)


                self.state = 1644
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1645
                self.match(XplorMRParser.Nrestraints)
                self.state = 1647
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1646
                    self.match(XplorMRParser.Equ_op)


                self.state = 1649
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1650
                self.match(XplorMRParser.Potential)
                self.state = 1652
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1651
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1654
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1655
                self.match(XplorMRParser.Print)
                self.state = 1656
                self.match(XplorMRParser.Threshold)
                self.state = 1657
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1658
                self.match(XplorMRParser.Reset)
                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 One_bond_coupling_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def one_bond_assign(self):
            return self.getTypedRuleContext(XplorMRParser.One_bond_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_coupling_statement

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

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




    def one_bond_coupling_statement(self):

        localctx = XplorMRParser.One_bond_coupling_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_one_bond_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 1691
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1661
                self.one_bond_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1662
                self.classification()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1663
                self.match(XplorMRParser.Coefficients)
                self.state = 1664
                self.number_s()
                self.state = 1665
                self.number_s()
                self.state = 1666
                self.number_s()
                self.state = 1667
                self.number_s()
                self.state = 1668
                self.number_s()
                self.state = 1669
                self.number_s()
                self.state = 1670
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1672
                self.match(XplorMRParser.ForceConstant)
                self.state = 1674
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1673
                    self.match(XplorMRParser.Equ_op)


                self.state = 1676
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1677
                self.match(XplorMRParser.Nrestraints)
                self.state = 1679
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1678
                    self.match(XplorMRParser.Equ_op)


                self.state = 1681
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1682
                self.match(XplorMRParser.Potential)
                self.state = 1684
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1683
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1686
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1687
                self.match(XplorMRParser.Print)
                self.state = 1688
                self.match(XplorMRParser.Threshold)
                self.state = 1689
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1690
                self.match(XplorMRParser.Reset)
                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 One_bond_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_assign

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

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




    def one_bond_assign(self):

        localctx = XplorMRParser.One_bond_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_one_bond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1693
            self.match(XplorMRParser.Assign)
            self.state = 1694
            self.selection()
            self.state = 1695
            self.selection()
            self.state = 1696
            self.selection()
            self.state = 1697
            self.selection()
            self.state = 1698
            self.selection()
            self.state = 1699
            self.selection()
            self.state = 1700
            self.selection()
            self.state = 1701
            self.selection()
            self.state = 1702
            self.number()
            self.state = 1703
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angle_db_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def angle_db_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Angle_db_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def DerivFlag(self):
            return self.getToken(XplorMRParser.DerivFlag, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Expectation(self):
            return self.getToken(XplorMRParser.Expectation, 0)

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

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Error(self):
            return self.getToken(XplorMRParser.Error, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Size(self):
            return self.getToken(XplorMRParser.Size, 0)

        def AngleDb(self):
            return self.getToken(XplorMRParser.AngleDb, 0)

        def Dihedral(self):
            return self.getToken(XplorMRParser.Dihedral, 0)

        def Zero(self):
            return self.getToken(XplorMRParser.Zero, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_statement

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

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




    def angle_db_statement(self):

        localctx = XplorMRParser.Angle_db_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_angle_db_statement)
        self._la = 0 # Token type
        try:
            self.state = 1743
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1705
                self.angle_db_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1706
                self.classification()
                pass
            elif token in [97]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1707
                self.match(XplorMRParser.DerivFlag)
                self.state = 1708
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1709
                self.match(XplorMRParser.Expectation)
                self.state = 1710
                self.match(XplorMRParser.Integer)
                self.state = 1711
                self.match(XplorMRParser.Integer)
                self.state = 1712
                self.number_s()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1713
                self.match(XplorMRParser.Error)
                self.state = 1714
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1715
                self.match(XplorMRParser.ForceConstant)
                self.state = 1717
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1716
                    self.match(XplorMRParser.Equ_op)


                self.state = 1719
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1720
                self.match(XplorMRParser.Nrestraints)
                self.state = 1722
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1721
                    self.match(XplorMRParser.Equ_op)


                self.state = 1724
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1725
                self.match(XplorMRParser.Potential)
                self.state = 1727
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1726
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1729
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1730
                self.match(XplorMRParser.Print)
                self.state = 1731
                self.match(XplorMRParser.Threshold)
                self.state = 1732
                self.number_s()
                self.state = 1735
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1733
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1734
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1737
                self.match(XplorMRParser.Reset)
                pass
            elif token in [63]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1738
                self.match(XplorMRParser.Size)
                self.state = 1739
                _la = self._input.LA(1)
                if not(_la==38 or _la==96):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1740
                self.match(XplorMRParser.Integer)
                self.state = 1741
                self.match(XplorMRParser.Integer)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1742
                self.match(XplorMRParser.Zero)
                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 Angle_db_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_assign

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

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




    def angle_db_assign(self):

        localctx = XplorMRParser.Angle_db_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_angle_db_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1745
            self.match(XplorMRParser.Assign)
            self.state = 1746
            self.selection()
            self.state = 1747
            self.selection()
            self.state = 1748
            self.selection()
            self.state = 1749
            self.selection()
            self.state = 1750
            self.selection()
            self.state = 1751
            self.selection()
            self.state = 1752
            self.selection()
            self.state = 1753
            self.selection()
            self.state = 1754
            self.selection()
            self.state = 1755
            self.selection()
            self.state = 1756
            self.selection()
            self.state = 1758
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==205:
                self.state = 1757
                self.selection()


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


    class Pre_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pre_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pre_assignContext,0)


        def pre_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Pre_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def class_name(self):
            return self.getTypedRuleContext(XplorMRParser.Class_nameContext,0)


        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Class_name_PT(self):
            return self.getToken(XplorMRParser.Class_name_PT, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_PT(self):
            return self.getToken(XplorMRParser.Equ_op_PT, 0)

        def Kconst(self):
            return self.getToken(XplorMRParser.Kconst, 0)

        def Omega(self):
            return self.getToken(XplorMRParser.Omega, 0)

        def Tauc(self):
            return self.getToken(XplorMRParser.Tauc, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Debug(self):
            return self.getToken(XplorMRParser.Debug, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_statement

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

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




    def pre_statement(self):

        localctx = XplorMRParser.Pre_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_pre_statement)
        self._la = 0 # Token type
        try:
            self.state = 1812
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1760
                self.pre_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1761
                self.pre_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1762
                self.classification()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1763
                self.match(XplorMRParser.ForceConstant)
                self.state = 1765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1764
                    self.match(XplorMRParser.Equ_op)


                self.state = 1767
                self.class_name()
                self.state = 1768
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1770
                self.match(XplorMRParser.Nrestraints)
                self.state = 1772
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1771
                    self.match(XplorMRParser.Equ_op)


                self.state = 1774
                self.match(XplorMRParser.Integer)
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1775
                self.match(XplorMRParser.Potential)
                self.state = 1777
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==227:
                    self.state = 1776
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1779
                self.match(XplorMRParser.Class_name_PT)
                self.state = 1780
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [99]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1781
                self.match(XplorMRParser.Kconst)
                self.state = 1783
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1782
                    self.match(XplorMRParser.Equ_op)


                self.state = 1785
                self.class_name()
                self.state = 1786
                self.number_s()
                pass
            elif token in [100]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1788
                self.match(XplorMRParser.Omega)
                self.state = 1790
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1789
                    self.match(XplorMRParser.Equ_op)


                self.state = 1792
                self.class_name()
                self.state = 1793
                self.number_s()
                pass
            elif token in [101]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1795
                self.match(XplorMRParser.Tauc)
                self.state = 1797
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1796
                    self.match(XplorMRParser.Equ_op)


                self.state = 1799
                self.class_name()
                self.state = 1800
                self.number_s()
                self.state = 1801
                self.number_s()
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1803
                self.match(XplorMRParser.Print)
                self.state = 1804
                self.match(XplorMRParser.Threshold)
                self.state = 1805
                self.number_s()
                self.state = 1808
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1806
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1807
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1810
                self.match(XplorMRParser.Reset)
                pass
            elif token in [102]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1811
                self.match(XplorMRParser.Debug)
                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 Pre_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_assign

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

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




    def pre_assign(self):

        localctx = XplorMRParser.Pre_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_pre_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1814
            self.match(XplorMRParser.Assign)
            self.state = 1815
            self.selection()
            self.state = 1816
            self.selection()
            self.state = 1817
            self.number()
            self.state = 1819
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1818
                self.number()


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


    class Pcs_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pcs_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pcs_assignContext,0)


        def pcs_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Pcs_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Tolerance(self):
            return self.getToken(XplorMRParser.Tolerance, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Save(self):
            return self.getToken(XplorMRParser.Save, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Fmed(self):
            return self.getToken(XplorMRParser.Fmed, 0)

        def ErrOn(self):
            return self.getToken(XplorMRParser.ErrOn, 0)

        def ErrOff(self):
            return self.getToken(XplorMRParser.ErrOff, 0)

        def Fon(self):
            return self.getToken(XplorMRParser.Fon, 0)

        def Foff(self):
            return self.getToken(XplorMRParser.Foff, 0)

        def Son(self):
            return self.getToken(XplorMRParser.Son, 0)

        def Soff(self):
            return self.getToken(XplorMRParser.Soff, 0)

        def Frun(self):
            return self.getToken(XplorMRParser.Frun, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_statement

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

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




    def pcs_statement(self):

        localctx = XplorMRParser.Pcs_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_pcs_statement)
        self._la = 0 # Token type
        try:
            self.state = 1862
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1821
                self.pcs_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1822
                self.pcs_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1823
                self.classification()
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1824
                self.match(XplorMRParser.Tolerance)
                self.state = 1825
                self.match(XplorMRParser.Integer)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1826
                self.match(XplorMRParser.Coefficients)
                self.state = 1827
                self.number_s()
                self.state = 1828
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1830
                self.match(XplorMRParser.ForceConstant)
                self.state = 1832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1831
                    self.match(XplorMRParser.Equ_op)


                self.state = 1834
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1835
                self.match(XplorMRParser.Nrestraints)
                self.state = 1837
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1836
                    self.match(XplorMRParser.Equ_op)


                self.state = 1839
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1840
                self.match(XplorMRParser.Print)
                self.state = 1841
                self.match(XplorMRParser.Threshold)
                self.state = 1842
                self.number_s()
                self.state = 1845
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [139]:
                    self.state = 1843
                    self.match(XplorMRParser.All)
                    pass
                elif token in [9]:
                    self.state = 1844
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1847
                self.match(XplorMRParser.Reset)
                pass
            elif token in [105]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1848
                self.match(XplorMRParser.Save)
                self.state = 1849
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [106]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1850
                self.match(XplorMRParser.Fmed)
                self.state = 1851
                self.number_s()
                self.state = 1852
                self.match(XplorMRParser.Integer)
                pass
            elif token in [107]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1854
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [108]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1855
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [109]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1856
                self.match(XplorMRParser.Fon)
                pass
            elif token in [110]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1857
                self.match(XplorMRParser.Foff)
                pass
            elif token in [111]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1858
                self.match(XplorMRParser.Son)
                pass
            elif token in [112]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1859
                self.match(XplorMRParser.Soff)
                pass
            elif token in [113]:
                self.enterOuterAlt(localctx, 18)
                self.state = 1860
                self.match(XplorMRParser.Frun)
                self.state = 1861
                self.match(XplorMRParser.Integer)
                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 Pcs_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_assign

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

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




    def pcs_assign(self):

        localctx = XplorMRParser.Pcs_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_pcs_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1864
            self.match(XplorMRParser.Assign)
            self.state = 1865
            self.selection()
            self.state = 1866
            self.selection()
            self.state = 1867
            self.selection()
            self.state = 1868
            self.selection()
            self.state = 1869
            self.selection()
            self.state = 1870
            self.number()
            self.state = 1872
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.state = 1871
                self.number()


            self.state = 1875
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1874
                self.number()


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


    class Prdc_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def prdc_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Prdc_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Tolerance(self):
            return self.getToken(XplorMRParser.Tolerance, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def ErrOn(self):
            return self.getToken(XplorMRParser.ErrOn, 0)

        def ErrOff(self):
            return self.getToken(XplorMRParser.ErrOff, 0)

        def Fmed(self):
            return self.getToken(XplorMRParser.Fmed, 0)

        def Fon(self):
            return self.getToken(XplorMRParser.Fon, 0)

        def Foff(self):
            return self.getToken(XplorMRParser.Foff, 0)

        def Frun(self):
            return self.getToken(XplorMRParser.Frun, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Save(self):
            return self.getToken(XplorMRParser.Save, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Son(self):
            return self.getToken(XplorMRParser.Son, 0)

        def Soff(self):
            return self.getToken(XplorMRParser.Soff, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_statement

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

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




    def prdc_statement(self):

        localctx = XplorMRParser.Prdc_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_prdc_statement)
        self._la = 0 # Token type
        try:
            self.state = 1908
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1877
                self.prdc_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1878
                self.classification()
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1879
                self.match(XplorMRParser.Tolerance)
                self.state = 1880
                self.match(XplorMRParser.Integer)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1881
                self.match(XplorMRParser.Coefficients)
                self.state = 1882
                self.number_s()
                self.state = 1883
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1885
                self.match(XplorMRParser.ForceConstant)
                self.state = 1887
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1886
                    self.match(XplorMRParser.Equ_op)


                self.state = 1889
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1890
                self.match(XplorMRParser.Nrestraints)
                self.state = 1892
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1891
                    self.match(XplorMRParser.Equ_op)


                self.state = 1894
                self.match(XplorMRParser.Integer)
                pass
            elif token in [107]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1895
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [108]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1896
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [106]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1897
                self.match(XplorMRParser.Fmed)
                pass
            elif token in [109]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1898
                self.match(XplorMRParser.Fon)
                pass
            elif token in [110]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1899
                self.match(XplorMRParser.Foff)
                pass
            elif token in [113]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1900
                self.match(XplorMRParser.Frun)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1901
                self.match(XplorMRParser.Print)
                self.state = 1902
                self.match(XplorMRParser.Threshold)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1903
                self.match(XplorMRParser.Reset)
                pass
            elif token in [105]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1904
                self.match(XplorMRParser.Save)
                self.state = 1905
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [111]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1906
                self.match(XplorMRParser.Son)
                pass
            elif token in [112]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1907
                self.match(XplorMRParser.Soff)
                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 Prdc_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_assign

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

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




    def prdc_assign(self):

        localctx = XplorMRParser.Prdc_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_prdc_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1910
            self.match(XplorMRParser.Assign)
            self.state = 1911
            self.selection()
            self.state = 1912
            self.selection()
            self.state = 1913
            self.selection()
            self.state = 1914
            self.selection()
            self.state = 1915
            self.selection()
            self.state = 1916
            self.selection()
            self.state = 1917
            self.number()
            self.state = 1919
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1918
                self.number()


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


    class Porientation_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def porientation_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Porientation_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_statement

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

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




    def porientation_statement(self):

        localctx = XplorMRParser.Porientation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_porientation_statement)
        self._la = 0 # Token type
        try:
            self.state = 1937
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1921
                self.porientation_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1922
                self.classification()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1923
                self.match(XplorMRParser.ForceConstant)
                self.state = 1925
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1924
                    self.match(XplorMRParser.Equ_op)


                self.state = 1927
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1928
                self.match(XplorMRParser.Nrestraints)
                self.state = 1930
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1929
                    self.match(XplorMRParser.Equ_op)


                self.state = 1932
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1933
                self.match(XplorMRParser.Print)
                self.state = 1934
                self.match(XplorMRParser.Threshold)
                self.state = 1935
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1936
                self.match(XplorMRParser.Reset)
                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 Porientation_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_assign

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

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




    def porientation_assign(self):

        localctx = XplorMRParser.Porientation_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_porientation_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1939
            self.match(XplorMRParser.Assign)
            self.state = 1940
            self.selection()
            self.state = 1941
            self.selection()
            self.state = 1942
            self.number()
            self.state = 1943
            self.number()
            self.state = 1944
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pccr_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pccr_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pccr_assignContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def Weip(self):
            return self.getToken(XplorMRParser.Weip, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Frun(self):
            return self.getToken(XplorMRParser.Frun, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_statement

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

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




    def pccr_statement(self):

        localctx = XplorMRParser.Pccr_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_pccr_statement)
        self._la = 0 # Token type
        try:
            self.state = 1968
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1946
                self.pccr_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1947
                self.classification()
                pass
            elif token in [117]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1948
                self.match(XplorMRParser.Weip)
                self.state = 1949
                self.match(XplorMRParser.Integer)
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1950
                self.match(XplorMRParser.Coefficients)
                self.state = 1951
                self.number_s()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1952
                self.match(XplorMRParser.ForceConstant)
                self.state = 1954
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1953
                    self.match(XplorMRParser.Equ_op)


                self.state = 1956
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1957
                self.match(XplorMRParser.Nrestraints)
                self.state = 1959
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1958
                    self.match(XplorMRParser.Equ_op)


                self.state = 1961
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1962
                self.match(XplorMRParser.Print)
                self.state = 1963
                self.match(XplorMRParser.Threshold)
                self.state = 1964
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1965
                self.match(XplorMRParser.Reset)
                pass
            elif token in [113]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1966
                self.match(XplorMRParser.Frun)
                self.state = 1967
                self.match(XplorMRParser.Integer)
                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 Pccr_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_assign

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

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




    def pccr_assign(self):

        localctx = XplorMRParser.Pccr_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_pccr_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1970
            self.match(XplorMRParser.Assign)
            self.state = 1971
            self.selection()
            self.state = 1972
            self.selection()
            self.state = 1973
            self.selection()
            self.state = 1974
            self.number()
            self.state = 1976
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 0):
                self.state = 1975
                self.number()


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


    class Hbond_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def hbond_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_assignContext,0)


        def hbond_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_assign_loopContext,0)


        def classification(self):
            return self.getTypedRuleContext(XplorMRParser.ClassificationContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_statement

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

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




    def hbond_statement(self):

        localctx = XplorMRParser.Hbond_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_hbond_statement)
        self._la = 0 # Token type
        try:
            self.state = 1995
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1978
                self.hbond_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1979
                self.hbond_assign_loop()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1980
                self.classification()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1981
                self.match(XplorMRParser.ForceConstant)
                self.state = 1983
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1982
                    self.match(XplorMRParser.Equ_op)


                self.state = 1985
                self.number_s()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1986
                self.match(XplorMRParser.Nrestraints)
                self.state = 1988
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 1987
                    self.match(XplorMRParser.Equ_op)


                self.state = 1990
                self.match(XplorMRParser.Integer)
                pass
            elif token in [17]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1991
                self.match(XplorMRParser.Print)
                self.state = 1992
                self.match(XplorMRParser.Threshold)
                self.state = 1993
                self.number_s()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1994
                self.match(XplorMRParser.Reset)
                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 Hbond_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_assign

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

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




    def hbond_assign(self):

        localctx = XplorMRParser.Hbond_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_hbond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1997
            self.match(XplorMRParser.Assign)
            self.state = 1998
            self.selection()
            self.state = 1999
            self.selection()
            self.state = 2000
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_db_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def hbond_db_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_db_assignContext,0)


        def hbond_db_assign_loop(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_db_assign_loopContext,0)


        def Kdir(self):
            return self.getToken(XplorMRParser.Kdir, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Klin(self):
            return self.getToken(XplorMRParser.Klin, 0)

        def Nseg(self):
            return self.getToken(XplorMRParser.Nseg, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Nmin(self):
            return self.getToken(XplorMRParser.Nmin, 0)

        def Nmax(self):
            return self.getToken(XplorMRParser.Nmax, 0)

        def Segm(self):
            return self.getToken(XplorMRParser.Segm, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Ohcut(self):
            return self.getToken(XplorMRParser.Ohcut, 0)

        def Coh1cut(self):
            return self.getToken(XplorMRParser.Coh1cut, 0)

        def Coh2cut(self):
            return self.getToken(XplorMRParser.Coh2cut, 0)

        def Ohncut(self):
            return self.getToken(XplorMRParser.Ohncut, 0)

        def Updfrq(self):
            return self.getToken(XplorMRParser.Updfrq, 0)

        def Prnfrq(self):
            return self.getToken(XplorMRParser.Prnfrq, 0)

        def Freemode(self):
            return self.getToken(XplorMRParser.Freemode, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_db_statement

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

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




    def hbond_db_statement(self):

        localctx = XplorMRParser.Hbond_db_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_hbond_db_statement)
        self._la = 0 # Token type
        try:
            self.state = 2069
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2002
                self.hbond_db_assign()
                pass
            elif token in [186]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2003
                self.hbond_db_assign_loop()
                pass
            elif token in [120]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2004
                self.match(XplorMRParser.Kdir)
                self.state = 2006
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2005
                    self.match(XplorMRParser.Equ_op)


                self.state = 2008
                self.number_s()
                pass
            elif token in [121]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2009
                self.match(XplorMRParser.Klin)
                self.state = 2011
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2010
                    self.match(XplorMRParser.Equ_op)


                self.state = 2013
                self.number_s()
                pass
            elif token in [122]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2014
                self.match(XplorMRParser.Nseg)
                self.state = 2016
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2015
                    self.match(XplorMRParser.Equ_op)


                self.state = 2018
                self.match(XplorMRParser.Integer)
                pass
            elif token in [123]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2019
                self.match(XplorMRParser.Nmin)
                self.state = 2021
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2020
                    self.match(XplorMRParser.Equ_op)


                self.state = 2023
                self.match(XplorMRParser.Integer)
                pass
            elif token in [124]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2024
                self.match(XplorMRParser.Nmax)
                self.state = 2026
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2025
                    self.match(XplorMRParser.Equ_op)


                self.state = 2028
                self.match(XplorMRParser.Integer)
                pass
            elif token in [125]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2029
                self.match(XplorMRParser.Segm)
                self.state = 2031
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2030
                    self.match(XplorMRParser.Equ_op)


                self.state = 2033
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [126]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2034
                self.match(XplorMRParser.Ohcut)
                self.state = 2036
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2035
                    self.match(XplorMRParser.Equ_op)


                self.state = 2038
                self.number_s()
                pass
            elif token in [127]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2039
                self.match(XplorMRParser.Coh1cut)
                self.state = 2041
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2040
                    self.match(XplorMRParser.Equ_op)


                self.state = 2043
                self.number_s()
                pass
            elif token in [128]:
                self.enterOuterAlt(localctx, 11)
                self.state = 2044
                self.match(XplorMRParser.Coh2cut)
                self.state = 2046
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2045
                    self.match(XplorMRParser.Equ_op)


                self.state = 2048
                self.number_s()
                pass
            elif token in [129]:
                self.enterOuterAlt(localctx, 12)
                self.state = 2049
                self.match(XplorMRParser.Ohncut)
                self.state = 2051
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2050
                    self.match(XplorMRParser.Equ_op)


                self.state = 2053
                self.number_s()
                pass
            elif token in [130]:
                self.enterOuterAlt(localctx, 13)
                self.state = 2054
                self.match(XplorMRParser.Updfrq)
                self.state = 2056
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2055
                    self.match(XplorMRParser.Equ_op)


                self.state = 2058
                self.match(XplorMRParser.Integer)
                pass
            elif token in [131]:
                self.enterOuterAlt(localctx, 14)
                self.state = 2059
                self.match(XplorMRParser.Prnfrq)
                self.state = 2061
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2060
                    self.match(XplorMRParser.Equ_op)


                self.state = 2063
                self.match(XplorMRParser.Integer)
                pass
            elif token in [132]:
                self.enterOuterAlt(localctx, 15)
                self.state = 2064
                self.match(XplorMRParser.Freemode)
                self.state = 2066
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2065
                    self.match(XplorMRParser.Equ_op)


                self.state = 2068
                self.match(XplorMRParser.Integer)
                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 Hbond_db_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_db_assign

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

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




    def hbond_db_assign(self):

        localctx = XplorMRParser.Hbond_db_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_hbond_db_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2071
            self.match(XplorMRParser.Assign)
            self.state = 2072
            self.selection()
            self.state = 2073
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ncs_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Ncs(self):
            return self.getToken(XplorMRParser.Ncs, 0)

        def Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def ncs_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Ncs_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Ncs_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_ncs_restraint

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

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




    def ncs_restraint(self):

        localctx = XplorMRParser.Ncs_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_ncs_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2075
            self.match(XplorMRParser.Ncs)
            self.state = 2076
            self.match(XplorMRParser.Restraints)
            self.state = 2080
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 54044295040073728) != 0):
                self.state = 2077
                self.ncs_statement()
                self.state = 2082
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2083
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ncs_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Group(self):
            return self.getToken(XplorMRParser.Group, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def ncs_group_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Ncs_group_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Ncs_group_statementContext,i)


        def Initialize(self):
            return self.getToken(XplorMRParser.Initialize, 0)

        def Print_any(self):
            return self.getToken(XplorMRParser.Print_any, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_ncs_statement

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

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




    def ncs_statement(self):

        localctx = XplorMRParser.Ncs_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_ncs_statement)
        self._la = 0 # Token type
        try:
            self.state = 2095
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [54]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2085
                self.match(XplorMRParser.Group)
                self.state = 2089
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==57 or _la==136 or _la==137:
                    self.state = 2086
                    self.ncs_group_statement()
                    self.state = 2091
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2092
                self.match(XplorMRParser.End)
                pass
            elif token in [55]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2093
                self.match(XplorMRParser.Initialize)
                pass
            elif token in [40]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2094
                self.match(XplorMRParser.Print_any)
                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 Ncs_group_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Equivalence(self):
            return self.getToken(XplorMRParser.Equivalence, 0)

        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Sigb(self):
            return self.getToken(XplorMRParser.Sigb, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Weight(self):
            return self.getToken(XplorMRParser.Weight, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_ncs_group_statement

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

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




    def ncs_group_statement(self):

        localctx = XplorMRParser.Ncs_group_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_ncs_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 2112
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [136]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2097
                self.match(XplorMRParser.Equivalence)
                self.state = 2099
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2098
                    self.match(XplorMRParser.Equ_op)


                self.state = 2101
                self.selection()
                pass
            elif token in [137]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2102
                self.match(XplorMRParser.Sigb)
                self.state = 2104
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2103
                    self.match(XplorMRParser.Equ_op)


                self.state = 2106
                self.number_s()
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2107
                self.match(XplorMRParser.Weight)
                self.state = 2109
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2108
                    self.match(XplorMRParser.Equ_op)


                self.state = 2111
                self.number_s()
                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 SelectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_paren(self):
            return self.getToken(XplorMRParser.L_paren, 0)

        def selection_expression(self):
            return self.getTypedRuleContext(XplorMRParser.Selection_expressionContext,0)


        def R_paren(self):
            return self.getToken(XplorMRParser.R_paren, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_selection

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

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




    def selection(self):

        localctx = XplorMRParser.SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_selection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2114
            self.match(XplorMRParser.L_paren)
            self.state = 2115
            self.selection_expression()
            self.state = 2116
            self.match(XplorMRParser.R_paren)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Selection_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.TermContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.TermContext,i)


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_selection_expression

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

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




    def selection_expression(self):

        localctx = XplorMRParser.Selection_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_selection_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2118
            self.term()
            self.state = 2123
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==190:
                self.state = 2119
                self.match(XplorMRParser.Or_op)
                self.state = 2120
                self.term()
                self.state = 2125
                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 TermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.FactorContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.FactorContext,i)


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_term

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

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




    def term(self):

        localctx = XplorMRParser.TermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2126
            self.factor(0)
            self.state = 2131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==191:
                self.state = 2127
                self.match(XplorMRParser.And_op)
                self.state = 2128
                self.factor(0)
                self.state = 2133
                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 FactorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_paren(self):
            return self.getToken(XplorMRParser.L_paren, 0)

        def selection_expression(self):
            return self.getTypedRuleContext(XplorMRParser.Selection_expressionContext,0)


        def R_paren(self):
            return self.getToken(XplorMRParser.R_paren, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Atom(self):
            return self.getToken(XplorMRParser.Atom, 0)

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

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

        def Integers(self):
            return self.getToken(XplorMRParser.Integers, 0)

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

        def Attribute(self):
            return self.getToken(XplorMRParser.Attribute, 0)

        def Attr_properties(self):
            return self.getToken(XplorMRParser.Attr_properties, 0)

        def Comparison_ops(self):
            return self.getToken(XplorMRParser.Comparison_ops, 0)

        def number_f(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_fContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_fContext,i)


        def Abs(self):
            return self.getToken(XplorMRParser.Abs, 0)

        def BondedTo(self):
            return self.getToken(XplorMRParser.BondedTo, 0)

        def factor(self):
            return self.getTypedRuleContext(XplorMRParser.FactorContext,0)


        def ByGroup(self):
            return self.getToken(XplorMRParser.ByGroup, 0)

        def ByRes(self):
            return self.getToken(XplorMRParser.ByRes, 0)

        def Chemical(self):
            return self.getToken(XplorMRParser.Chemical, 0)

        def Symbol_name(self):
            return self.getToken(XplorMRParser.Symbol_name, 0)

        def Colon(self):
            return self.getToken(XplorMRParser.Colon, 0)

        def Hydrogen(self):
            return self.getToken(XplorMRParser.Hydrogen, 0)

        def Id(self):
            return self.getToken(XplorMRParser.Id, 0)

        def Known(self):
            return self.getToken(XplorMRParser.Known, 0)

        def Name(self):
            return self.getToken(XplorMRParser.Name, 0)

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

        def Not_op(self):
            return self.getToken(XplorMRParser.Not_op, 0)

        def Point(self):
            return self.getToken(XplorMRParser.Point, 0)

        def Cut(self):
            return self.getToken(XplorMRParser.Cut, 0)

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

        def Tail(self):
            return self.getToken(XplorMRParser.Tail, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


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

        def Head(self):
            return self.getToken(XplorMRParser.Head, 0)

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

        def Pseudo(self):
            return self.getToken(XplorMRParser.Pseudo, 0)

        def Residue(self):
            return self.getToken(XplorMRParser.Residue, 0)

        def Resname(self):
            return self.getToken(XplorMRParser.Resname, 0)

        def SegIdentifier(self):
            return self.getToken(XplorMRParser.SegIdentifier, 0)

        def Store1(self):
            return self.getToken(XplorMRParser.Store1, 0)

        def Store2(self):
            return self.getToken(XplorMRParser.Store2, 0)

        def Store3(self):
            return self.getToken(XplorMRParser.Store3, 0)

        def Store4(self):
            return self.getToken(XplorMRParser.Store4, 0)

        def Store5(self):
            return self.getToken(XplorMRParser.Store5, 0)

        def Store6(self):
            return self.getToken(XplorMRParser.Store6, 0)

        def Store7(self):
            return self.getToken(XplorMRParser.Store7, 0)

        def Store8(self):
            return self.getToken(XplorMRParser.Store8, 0)

        def Store9(self):
            return self.getToken(XplorMRParser.Store9, 0)

        def Tag(self):
            return self.getToken(XplorMRParser.Tag, 0)

        def Donor(self):
            return self.getToken(XplorMRParser.Donor, 0)

        def Acceptor(self):
            return self.getToken(XplorMRParser.Acceptor, 0)

        def Around(self):
            return self.getToken(XplorMRParser.Around, 0)

        def Saround(self):
            return self.getToken(XplorMRParser.Saround, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_factor

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

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



    def factor(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = XplorMRParser.FactorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 196
        self.enterRecursionRule(localctx, 196, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2273
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.state = 2135
                self.match(XplorMRParser.L_paren)
                self.state = 2136
                self.selection_expression()
                self.state = 2137
                self.match(XplorMRParser.R_paren)
                pass

            elif la_ == 2:
                self.state = 2139
                self.match(XplorMRParser.All)
                pass

            elif la_ == 3:
                self.state = 2140
                self.match(XplorMRParser.Atom)
                self.state = 2141
                _la = self._input.LA(1)
                if not(_la==202 or _la==203):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2142
                _la = self._input.LA(1)
                if not(_la==195 or _la==204):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2143
                _la = self._input.LA(1)
                if not(_la==202 or _la==203):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                self.state = 2144
                self.match(XplorMRParser.Attribute)
                self.state = 2146
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==220:
                    self.state = 2145
                    self.match(XplorMRParser.Abs)


                self.state = 2148
                self.match(XplorMRParser.Attr_properties)
                self.state = 2149
                self.match(XplorMRParser.Comparison_ops)
                self.state = 2150
                self.number_f()
                pass

            elif la_ == 5:
                self.state = 2151
                self.match(XplorMRParser.BondedTo)
                self.state = 2152
                self.factor(29)
                pass

            elif la_ == 6:
                self.state = 2153
                self.match(XplorMRParser.ByGroup)
                self.state = 2154
                self.factor(28)
                pass

            elif la_ == 7:
                self.state = 2155
                self.match(XplorMRParser.ByRes)
                self.state = 2156
                self.factor(27)
                pass

            elif la_ == 8:
                self.state = 2157
                self.match(XplorMRParser.Chemical)
                self.state = 2165
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [203]:
                    self.state = 2158
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [202]:
                    self.state = 2159
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2162
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
                    if la_ == 1:
                        self.state = 2160
                        self.match(XplorMRParser.Colon)
                        self.state = 2161
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [214]:
                    self.state = 2164
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                self.state = 2167
                self.match(XplorMRParser.Hydrogen)
                pass

            elif la_ == 10:
                self.state = 2168
                self.match(XplorMRParser.Id)
                self.state = 2169
                self.match(XplorMRParser.Integer)
                pass

            elif la_ == 11:
                self.state = 2170
                self.match(XplorMRParser.Known)
                pass

            elif la_ == 12:
                self.state = 2171
                self.match(XplorMRParser.Name)
                self.state = 2184
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [203]:
                    self.state = 2172
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [202]:
                    self.state = 2173
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2176
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
                    if la_ == 1:
                        self.state = 2174
                        self.match(XplorMRParser.Colon)
                        self.state = 2175
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [198]:
                    self.state = 2178
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 2181
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
                    if la_ == 1:
                        self.state = 2179
                        self.match(XplorMRParser.Colon)
                        self.state = 2180
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                elif token in [214]:
                    self.state = 2183
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 13:
                self.state = 2186
                self.match(XplorMRParser.Not_op)
                self.state = 2187
                self.factor(21)
                pass

            elif la_ == 14:
                self.state = 2188
                self.match(XplorMRParser.Point)
                self.state = 2189
                self.match(XplorMRParser.L_paren)
                self.state = 2190
                self.number_f()
                self.state = 2192
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==193:
                    self.state = 2191
                    self.match(XplorMRParser.Comma)


                self.state = 2194
                self.number_f()
                self.state = 2196
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==193:
                    self.state = 2195
                    self.match(XplorMRParser.Comma)


                self.state = 2198
                self.number_f()
                self.state = 2199
                self.match(XplorMRParser.R_paren)
                self.state = 2200
                self.match(XplorMRParser.Cut)
                self.state = 2201
                self.number_f()
                pass

            elif la_ == 15:
                self.state = 2203
                self.match(XplorMRParser.Point)
                self.state = 2204
                self.match(XplorMRParser.L_paren)
                self.state = 2205
                self.match(XplorMRParser.Tail)
                self.state = 2207
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==208:
                    self.state = 2206
                    self.match(XplorMRParser.Equ_op)


                self.state = 2209
                self.selection()
                self.state = 2211
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==193:
                    self.state = 2210
                    self.match(XplorMRParser.Comma)


                self.state = 2218
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==189:
                    self.state = 2213
                    self.match(XplorMRParser.Head)
                    self.state = 2215
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==208:
                        self.state = 2214
                        self.match(XplorMRParser.Equ_op)


                    self.state = 2217
                    self.selection()


                self.state = 2220
                self.match(XplorMRParser.R_paren)
                self.state = 2221
                self.match(XplorMRParser.Cut)
                self.state = 2222
                self.number_f()
                pass

            elif la_ == 16:
                self.state = 2224
                self.match(XplorMRParser.Previous)
                pass

            elif la_ == 17:
                self.state = 2225
                self.match(XplorMRParser.Pseudo)
                pass

            elif la_ == 18:
                self.state = 2226
                self.match(XplorMRParser.Residue)
                self.state = 2234
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [204]:
                    self.state = 2227
                    self.match(XplorMRParser.Integers)
                    pass
                elif token in [195]:
                    self.state = 2228
                    self.match(XplorMRParser.Integer)
                    self.state = 2231
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
                    if la_ == 1:
                        self.state = 2229
                        self.match(XplorMRParser.Colon)
                        self.state = 2230
                        self.match(XplorMRParser.Integer)


                    pass
                elif token in [214]:
                    self.state = 2233
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 19:
                self.state = 2236
                self.match(XplorMRParser.Resname)
                self.state = 2244
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [203]:
                    self.state = 2237
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [202]:
                    self.state = 2238
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2241
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,247,self._ctx)
                    if la_ == 1:
                        self.state = 2239
                        self.match(XplorMRParser.Colon)
                        self.state = 2240
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [214]:
                    self.state = 2243
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 20:
                self.state = 2246
                self.match(XplorMRParser.SegIdentifier)
                self.state = 2259
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [203]:
                    self.state = 2247
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [202]:
                    self.state = 2248
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2251
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,249,self._ctx)
                    if la_ == 1:
                        self.state = 2249
                        self.match(XplorMRParser.Colon)
                        self.state = 2250
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [198]:
                    self.state = 2253
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 2256
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,250,self._ctx)
                    if la_ == 1:
                        self.state = 2254
                        self.match(XplorMRParser.Colon)
                        self.state = 2255
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                elif token in [214]:
                    self.state = 2258
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 21:
                self.state = 2261
                self.match(XplorMRParser.Store1)
                pass

            elif la_ == 22:
                self.state = 2262
                self.match(XplorMRParser.Store2)
                pass

            elif la_ == 23:
                self.state = 2263
                self.match(XplorMRParser.Store3)
                pass

            elif la_ == 24:
                self.state = 2264
                self.match(XplorMRParser.Store4)
                pass

            elif la_ == 25:
                self.state = 2265
                self.match(XplorMRParser.Store5)
                pass

            elif la_ == 26:
                self.state = 2266
                self.match(XplorMRParser.Store6)
                pass

            elif la_ == 27:
                self.state = 2267
                self.match(XplorMRParser.Store7)
                pass

            elif la_ == 28:
                self.state = 2268
                self.match(XplorMRParser.Store8)
                pass

            elif la_ == 29:
                self.state = 2269
                self.match(XplorMRParser.Store9)
                pass

            elif la_ == 30:
                self.state = 2270
                self.match(XplorMRParser.Tag)
                pass

            elif la_ == 31:
                self.state = 2271
                self.match(XplorMRParser.Donor)
                pass

            elif la_ == 32:
                self.state = 2272
                self.match(XplorMRParser.Acceptor)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2283
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,254,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 2281
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
                    if la_ == 1:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 2275
                        if not self.precpred(self._ctx, 32):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 32)")
                        self.state = 2276
                        self.match(XplorMRParser.Around)
                        self.state = 2277
                        self.number_f()
                        pass

                    elif la_ == 2:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 2278
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 2279
                        self.match(XplorMRParser.Saround)
                        self.state = 2280
                        self.number_f()
                        pass

             
                self.state = 2285
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,254,self._ctx)

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


    class NumberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Symbol_name(self):
            return self.getToken(XplorMRParser.Symbol_name, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number

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

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




    def number(self):

        localctx = XplorMRParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2286
            _la = self._input.LA(1)
            if not(((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 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 Number_fContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_f

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

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




    def number_f(self):

        localctx = XplorMRParser.Number_fContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_number_f)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2288
            _la = self._input.LA(1)
            if not(_la==195 or _la==197):
                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 Number_sContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Symbol_name(self):
            return self.getToken(XplorMRParser.Symbol_name, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_s

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

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




    def number_s(self):

        localctx = XplorMRParser.Number_sContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_number_s)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2290
            _la = self._input.LA(1)
            if not(((((_la - 195)) & ~0x3f) == 0 and ((1 << (_la - 195)) & 524293) != 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 Number_aContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_a

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

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




    def number_a(self):

        localctx = XplorMRParser.Number_aContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_number_a)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2292
            _la = self._input.LA(1)
            if not(_la==195 or _la==197):
                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 ClassificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def class_name(self):
            return self.getTypedRuleContext(XplorMRParser.Class_nameContext,0)


        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_classification

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

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




    def classification(self):

        localctx = XplorMRParser.ClassificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_classification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2294
            self.match(XplorMRParser.Classification)
            self.state = 2296
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==208:
                self.state = 2295
                self.match(XplorMRParser.Equ_op)


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


    class Class_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Noe(self):
            return self.getToken(XplorMRParser.Noe, 0)

        def Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

        def AngleDb(self):
            return self.getToken(XplorMRParser.AngleDb, 0)

        def HBonded(self):
            return self.getToken(XplorMRParser.HBonded, 0)

        def Dihedral(self):
            return self.getToken(XplorMRParser.Dihedral, 0)

        def Improper(self):
            return self.getToken(XplorMRParser.Improper, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_class_name

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

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




    def class_name(self):

        localctx = XplorMRParser.Class_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_class_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2300
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 412316860424) != 0) or _la==96 or ((((_la - 180)) & ~0x3f) == 0 and ((1 << (_la - 180)) & 4194307) != 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 Flag_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Flags(self):
            return self.getToken(XplorMRParser.Flags, 0)

        def Include(self):
            return self.getToken(XplorMRParser.Include, 0)

        def End_FL(self):
            return self.getToken(XplorMRParser.End_FL, 0)

        def Exclude(self):
            return self.getToken(XplorMRParser.Exclude, 0)

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

        def Any_class(self):
            return self.getToken(XplorMRParser.Any_class, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_flag_statement

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

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




    def flag_statement(self):

        localctx = XplorMRParser.Flag_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_flag_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2302
            self.match(XplorMRParser.Flags)
            self.state = 2313
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==237:
                self.state = 2303
                self.match(XplorMRParser.Exclude)
                self.state = 2311
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [238, 240]:
                    self.state = 2307
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==240:
                        self.state = 2304
                        self.match(XplorMRParser.Class_name)
                        self.state = 2309
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [241]:
                    self.state = 2310
                    self.match(XplorMRParser.Any_class)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 2315
            self.match(XplorMRParser.Include)
            self.state = 2319
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==240:
                self.state = 2316
                self.match(XplorMRParser.Class_name)
                self.state = 2321
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2322
            self.match(XplorMRParser.End_FL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Vector(self):
            return self.getToken(XplorMRParser.Vector, 0)

        def vector_mode(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_modeContext,0)


        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_statement

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

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




    def vector_statement(self):

        localctx = XplorMRParser.Vector_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_vector_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2324
            self.match(XplorMRParser.Vector)
            self.state = 2325
            self.vector_mode()
            self.state = 2326
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_modeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vector_expression(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_expressionContext,0)


        def R_paren_VE(self):
            return self.getToken(XplorMRParser.R_paren_VE, 0)

        def Do_Lp(self):
            return self.getToken(XplorMRParser.Do_Lp, 0)

        def Identity_Lp(self):
            return self.getToken(XplorMRParser.Identity_Lp, 0)

        def Show(self):
            return self.getToken(XplorMRParser.Show, 0)

        def vector_show_property(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_show_propertyContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_mode

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

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




    def vector_mode(self):

        localctx = XplorMRParser.Vector_modeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_vector_mode)
        self._la = 0 # Token type
        try:
            self.state = 2334
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [170, 171]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2328
                _la = self._input.LA(1)
                if not(_la==170 or _la==171):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2329
                self.vector_expression()
                self.state = 2330
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [172]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2332
                self.match(XplorMRParser.Show)
                self.state = 2333
                self.vector_show_property()
                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 Vector_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Atom_properties_VE(self):
            return self.getToken(XplorMRParser.Atom_properties_VE, 0)

        def Equ_op_VE(self):
            return self.getToken(XplorMRParser.Equ_op_VE, 0)

        def vector_operation(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_operationContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_expression

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

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




    def vector_expression(self):

        localctx = XplorMRParser.Vector_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_vector_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2336
            self.match(XplorMRParser.Atom_properties_VE)
            self.state = 2339
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==244:
                self.state = 2337
                self.match(XplorMRParser.Equ_op_VE)
                self.state = 2338
                self.vector_operation()


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


    class Vector_operationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vflc(self):
            return self.getTypedRuleContext(XplorMRParser.VflcContext,0)


        def vector_operation(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_operationContext,0)


        def Add_op_VE(self):
            return self.getToken(XplorMRParser.Add_op_VE, 0)

        def Sub_op_VE(self):
            return self.getToken(XplorMRParser.Sub_op_VE, 0)

        def Mul_op_VE(self):
            return self.getToken(XplorMRParser.Mul_op_VE, 0)

        def Div_op_VE(self):
            return self.getToken(XplorMRParser.Div_op_VE, 0)

        def Exp_op_VE(self):
            return self.getToken(XplorMRParser.Exp_op_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_operation

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

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




    def vector_operation(self):

        localctx = XplorMRParser.Vector_operationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_vector_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2341
            self.vflc()
            self.state = 2344
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 245)) & ~0x3f) == 0 and ((1 << (_la - 245)) & 31) != 0):
                self.state = 2342
                _la = self._input.LA(1)
                if not(((((_la - 245)) & ~0x3f) == 0 and ((1 << (_la - 245)) & 31) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2343
                self.vector_operation()


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


    class VflcContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Atom_properties_VE(self):
            return self.getToken(XplorMRParser.Atom_properties_VE, 0)

        def vector_func_call(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_func_callContext,0)


        def Integer_VE(self):
            return self.getToken(XplorMRParser.Integer_VE, 0)

        def Real_VE(self):
            return self.getToken(XplorMRParser.Real_VE, 0)

        def Simple_name_VE(self):
            return self.getToken(XplorMRParser.Simple_name_VE, 0)

        def Symbol_name_VE(self):
            return self.getToken(XplorMRParser.Symbol_name_VE, 0)

        def Double_quote_string_VE(self):
            return self.getToken(XplorMRParser.Double_quote_string_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vflc

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

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




    def vflc(self):

        localctx = XplorMRParser.VflcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_vflc)
        try:
            self.state = 2353
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [253]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2346
                self.match(XplorMRParser.Atom_properties_VE)
                pass
            elif token in [254, 255, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2347
                self.vector_func_call()
                pass
            elif token in [251]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2348
                self.match(XplorMRParser.Integer_VE)
                pass
            elif token in [252]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2349
                self.match(XplorMRParser.Real_VE)
                pass
            elif token in [277]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2350
                self.match(XplorMRParser.Simple_name_VE)
                pass
            elif token in [276]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2351
                self.match(XplorMRParser.Symbol_name_VE)
                pass
            elif token in [278]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2352
                self.match(XplorMRParser.Double_quote_string_VE)
                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 Vector_func_callContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Abs_VE(self):
            return self.getToken(XplorMRParser.Abs_VE, 0)

        def L_paren_VF(self):
            return self.getToken(XplorMRParser.L_paren_VF, 0)

        def vflc(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.VflcContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.VflcContext,i)


        def R_paren_VE(self):
            return self.getToken(XplorMRParser.R_paren_VE, 0)

        def Acos_VE(self):
            return self.getToken(XplorMRParser.Acos_VE, 0)

        def Cos_VE(self):
            return self.getToken(XplorMRParser.Cos_VE, 0)

        def Decode_VE(self):
            return self.getToken(XplorMRParser.Decode_VE, 0)

        def Encode_VE(self):
            return self.getToken(XplorMRParser.Encode_VE, 0)

        def Exp_VE(self):
            return self.getToken(XplorMRParser.Exp_VE, 0)

        def Gauss_VE(self):
            return self.getToken(XplorMRParser.Gauss_VE, 0)

        def Heavy_VE(self):
            return self.getToken(XplorMRParser.Heavy_VE, 0)

        def Int_VE(self):
            return self.getToken(XplorMRParser.Int_VE, 0)

        def Log10_VE(self):
            return self.getToken(XplorMRParser.Log10_VE, 0)

        def Log_VE(self):
            return self.getToken(XplorMRParser.Log_VE, 0)

        def Max_VE(self):
            return self.getToken(XplorMRParser.Max_VE, 0)

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

        def Maxw_VE(self):
            return self.getToken(XplorMRParser.Maxw_VE, 0)

        def Min_VE(self):
            return self.getToken(XplorMRParser.Min_VE, 0)

        def Mod_VE(self):
            return self.getToken(XplorMRParser.Mod_VE, 0)

        def Norm_VE(self):
            return self.getToken(XplorMRParser.Norm_VE, 0)

        def Random_VE(self):
            return self.getToken(XplorMRParser.Random_VE, 0)

        def Sign_VE(self):
            return self.getToken(XplorMRParser.Sign_VE, 0)

        def Sin_VE(self):
            return self.getToken(XplorMRParser.Sin_VE, 0)

        def Sqrt_VE(self):
            return self.getToken(XplorMRParser.Sqrt_VE, 0)

        def Tan_VE(self):
            return self.getToken(XplorMRParser.Tan_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_func_call

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

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




    def vector_func_call(self):

        localctx = XplorMRParser.Vector_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_vector_func_call)
        self._la = 0 # Token type
        try:
            self.state = 2474
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [254]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2355
                self.match(XplorMRParser.Abs_VE)
                self.state = 2356
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2357
                self.vflc()
                self.state = 2358
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [255]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2360
                self.match(XplorMRParser.Acos_VE)
                self.state = 2361
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2362
                self.vflc()
                self.state = 2363
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [257]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2365
                self.match(XplorMRParser.Cos_VE)
                self.state = 2366
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2367
                self.vflc()
                self.state = 2368
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [258]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2370
                self.match(XplorMRParser.Decode_VE)
                self.state = 2371
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2372
                self.vflc()
                self.state = 2373
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [259]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2375
                self.match(XplorMRParser.Encode_VE)
                self.state = 2376
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2377
                self.vflc()
                self.state = 2378
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [260]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2380
                self.match(XplorMRParser.Exp_VE)
                self.state = 2381
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2382
                self.vflc()
                self.state = 2383
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [261]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2385
                self.match(XplorMRParser.Gauss_VE)
                self.state = 2386
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2387
                self.vflc()
                self.state = 2388
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [262]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2390
                self.match(XplorMRParser.Heavy_VE)
                self.state = 2391
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2392
                self.vflc()
                self.state = 2393
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [263]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2395
                self.match(XplorMRParser.Int_VE)
                self.state = 2396
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2397
                self.vflc()
                self.state = 2398
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [264]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2400
                self.match(XplorMRParser.Log10_VE)
                self.state = 2401
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2402
                self.vflc()
                self.state = 2403
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [265]:
                self.enterOuterAlt(localctx, 11)
                self.state = 2405
                self.match(XplorMRParser.Log_VE)
                self.state = 2406
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2407
                self.vflc()
                self.state = 2408
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [266]:
                self.enterOuterAlt(localctx, 12)
                self.state = 2410
                self.match(XplorMRParser.Max_VE)
                self.state = 2411
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2412
                self.vflc()
                self.state = 2417
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==250:
                    self.state = 2413
                    self.match(XplorMRParser.Comma_VE)
                    self.state = 2414
                    self.vflc()
                    self.state = 2419
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2420
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [267]:
                self.enterOuterAlt(localctx, 13)
                self.state = 2422
                self.match(XplorMRParser.Maxw_VE)
                self.state = 2423
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2424
                self.vflc()
                self.state = 2425
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [268]:
                self.enterOuterAlt(localctx, 14)
                self.state = 2427
                self.match(XplorMRParser.Min_VE)
                self.state = 2428
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2429
                self.vflc()
                self.state = 2434
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==250:
                    self.state = 2430
                    self.match(XplorMRParser.Comma_VE)
                    self.state = 2431
                    self.vflc()
                    self.state = 2436
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2437
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [269]:
                self.enterOuterAlt(localctx, 15)
                self.state = 2439
                self.match(XplorMRParser.Mod_VE)
                self.state = 2440
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2441
                self.vflc()
                self.state = 2442
                self.match(XplorMRParser.Comma_VE)
                self.state = 2443
                self.vflc()
                self.state = 2444
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [270]:
                self.enterOuterAlt(localctx, 16)
                self.state = 2446
                self.match(XplorMRParser.Norm_VE)
                self.state = 2447
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2448
                self.vflc()
                self.state = 2449
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [271]:
                self.enterOuterAlt(localctx, 17)
                self.state = 2451
                self.match(XplorMRParser.Random_VE)
                self.state = 2452
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2453
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [272]:
                self.enterOuterAlt(localctx, 18)
                self.state = 2454
                self.match(XplorMRParser.Sign_VE)
                self.state = 2455
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2456
                self.vflc()
                self.state = 2457
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [273]:
                self.enterOuterAlt(localctx, 19)
                self.state = 2459
                self.match(XplorMRParser.Sin_VE)
                self.state = 2460
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2461
                self.vflc()
                self.state = 2462
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [274]:
                self.enterOuterAlt(localctx, 20)
                self.state = 2464
                self.match(XplorMRParser.Sqrt_VE)
                self.state = 2465
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2466
                self.vflc()
                self.state = 2467
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [275]:
                self.enterOuterAlt(localctx, 21)
                self.state = 2469
                self.match(XplorMRParser.Tan_VE)
                self.state = 2470
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2471
                self.vflc()
                self.state = 2472
                self.match(XplorMRParser.R_paren_VE)
                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 Vector_show_propertyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_paren_VS(self):
            return self.getToken(XplorMRParser.L_paren_VS, 0)

        def Atom_properties_VS(self):
            return self.getToken(XplorMRParser.Atom_properties_VS, 0)

        def R_paren_VS(self):
            return self.getToken(XplorMRParser.R_paren_VS, 0)

        def Average_VS(self):
            return self.getToken(XplorMRParser.Average_VS, 0)

        def Element_VS(self):
            return self.getToken(XplorMRParser.Element_VS, 0)

        def Max_VS(self):
            return self.getToken(XplorMRParser.Max_VS, 0)

        def Min_VS(self):
            return self.getToken(XplorMRParser.Min_VS, 0)

        def Norm_VS(self):
            return self.getToken(XplorMRParser.Norm_VS, 0)

        def Rms_VS(self):
            return self.getToken(XplorMRParser.Rms_VS, 0)

        def Sum_VS(self):
            return self.getToken(XplorMRParser.Sum_VS, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_show_property

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

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




    def vector_show_property(self):

        localctx = XplorMRParser.Vector_show_propertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_vector_show_property)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2476
            _la = self._input.LA(1)
            if not(((((_la - 284)) & ~0x3f) == 0 and ((1 << (_la - 284)) & 127) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2477
            self.match(XplorMRParser.L_paren_VS)
            self.state = 2478
            self.match(XplorMRParser.Atom_properties_VS)
            self.state = 2479
            self.match(XplorMRParser.R_paren_VS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Evaluate_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Evaluate_Lp(self):
            return self.getToken(XplorMRParser.Evaluate_Lp, 0)

        def Symbol_name_VE(self):
            return self.getToken(XplorMRParser.Symbol_name_VE, 0)

        def Equ_op_VE(self):
            return self.getToken(XplorMRParser.Equ_op_VE, 0)

        def evaluate_operation(self):
            return self.getTypedRuleContext(XplorMRParser.Evaluate_operationContext,0)


        def R_paren_VE(self):
            return self.getToken(XplorMRParser.R_paren_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_evaluate_statement

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

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




    def evaluate_statement(self):

        localctx = XplorMRParser.Evaluate_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_evaluate_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2481
            self.match(XplorMRParser.Evaluate_Lp)
            self.state = 2482
            self.match(XplorMRParser.Symbol_name_VE)
            self.state = 2483
            self.match(XplorMRParser.Equ_op_VE)
            self.state = 2484
            self.evaluate_operation()
            self.state = 2485
            self.match(XplorMRParser.R_paren_VE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Evaluate_operationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vflc(self):
            return self.getTypedRuleContext(XplorMRParser.VflcContext,0)


        def evaluate_operation(self):
            return self.getTypedRuleContext(XplorMRParser.Evaluate_operationContext,0)


        def Add_op_VE(self):
            return self.getToken(XplorMRParser.Add_op_VE, 0)

        def Sub_op_VE(self):
            return self.getToken(XplorMRParser.Sub_op_VE, 0)

        def Mul_op_VE(self):
            return self.getToken(XplorMRParser.Mul_op_VE, 0)

        def Div_op_VE(self):
            return self.getToken(XplorMRParser.Div_op_VE, 0)

        def Exp_op_VE(self):
            return self.getToken(XplorMRParser.Exp_op_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_evaluate_operation

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

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




    def evaluate_operation(self):

        localctx = XplorMRParser.Evaluate_operationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_evaluate_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2487
            self.vflc()
            self.state = 2490
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 245)) & ~0x3f) == 0 and ((1 << (_la - 245)) & 31) != 0):
                self.state = 2488
                _la = self._input.LA(1)
                if not(((((_la - 245)) & ~0x3f) == 0 and ((1 << (_la - 245)) & 31) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2489
                self.evaluate_operation()


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


    class Patch_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Patch(self):
            return self.getToken(XplorMRParser.Patch, 0)

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def End(self):
            return self.getToken(XplorMRParser.End, 0)

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

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

        def class_name(self):
            return self.getTypedRuleContext(XplorMRParser.Class_nameContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_patch_statement

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

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




    def patch_statement(self):

        localctx = XplorMRParser.Patch_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_patch_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2492
            self.match(XplorMRParser.Patch)
            self.state = 2494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 412316860424) != 0) or _la==96 or ((((_la - 180)) & ~0x3f) == 0 and ((1 << (_la - 180)) & 4194307) != 0):
                self.state = 2493
                self.class_name()


            self.state = 2496
            self.match(XplorMRParser.Reference)
            self.state = 2497
            self.match(XplorMRParser.Equ_op)
            self.state = 2498
            _la = self._input.LA(1)
            if not(_la==176 or _la==195):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2499
            self.match(XplorMRParser.Equ_op)
            self.state = 2500
            self.selection()
            self.state = 2506
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==175:
                self.state = 2501
                self.match(XplorMRParser.Reference)
                self.state = 2502
                self.match(XplorMRParser.Equ_op)
                self.state = 2503
                _la = self._input.LA(1)
                if not(_la==176 or _la==195):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2504
                self.match(XplorMRParser.Equ_op)
                self.state = 2505
                self.selection()


            self.state = 2508
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Parameter_settingContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Parameter(self):
            return self.getToken(XplorMRParser.Parameter, 0)

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def parameter_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Parameter_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Parameter_statementContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_parameter_setting

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

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




    def parameter_setting(self):

        localctx = XplorMRParser.Parameter_settingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_parameter_setting)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2510
            self.match(XplorMRParser.Parameter)
            self.state = 2514
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==19 or _la==38 or _la==96 or _la==143 or ((((_la - 180)) & ~0x3f) == 0 and ((1 << (_la - 180)) & 63) != 0):
                self.state = 2511
                self.parameter_statement()
                self.state = 2516
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2517
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Parameter_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AngleDb(self):
            return self.getToken(XplorMRParser.AngleDb, 0)

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

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def UB(self):
            return self.getToken(XplorMRParser.UB, 0)

        def BondedTo(self):
            return self.getToken(XplorMRParser.BondedTo, 0)

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

        def Dihedral(self):
            return self.getToken(XplorMRParser.Dihedral, 0)

        def Improper(self):
            return self.getToken(XplorMRParser.Improper, 0)

        def Mult(self):
            return self.getToken(XplorMRParser.Mult, 0)

        def HBonded(self):
            return self.getToken(XplorMRParser.HBonded, 0)

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

        def NBFix(self):
            return self.getToken(XplorMRParser.NBFix, 0)

        def NonB(self):
            return self.getToken(XplorMRParser.NonB, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def VDWOff(self):
            return self.getToken(XplorMRParser.VDWOff, 0)

        def Verbose(self):
            return self.getToken(XplorMRParser.Verbose, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_parameter_statement

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

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




    def parameter_statement(self):

        localctx = XplorMRParser.Parameter_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_parameter_statement)
        self._la = 0 # Token type
        try:
            self.state = 2574
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [96]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2519
                self.match(XplorMRParser.AngleDb)
                self.state = 2520
                self.match(XplorMRParser.Simple_name)
                self.state = 2521
                self.match(XplorMRParser.Simple_name)
                self.state = 2522
                self.match(XplorMRParser.Simple_name)
                self.state = 2523
                self.number_s()
                self.state = 2524
                self.number_s()
                self.state = 2529
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==178:
                    self.state = 2525
                    self.match(XplorMRParser.UB)
                    self.state = 2526
                    self.number_s()
                    self.state = 2527
                    self.number_s()


                pass
            elif token in [143]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2531
                self.match(XplorMRParser.BondedTo)
                self.state = 2532
                self.match(XplorMRParser.Simple_name)
                self.state = 2533
                self.match(XplorMRParser.Simple_name)
                self.state = 2534
                self.number_s()
                self.state = 2535
                self.number_s()
                pass
            elif token in [38, 181]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2537
                _la = self._input.LA(1)
                if not(_la==38 or _la==181):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2538
                self.match(XplorMRParser.Simple_name)
                self.state = 2539
                self.match(XplorMRParser.Simple_name)
                self.state = 2540
                self.match(XplorMRParser.Simple_name)
                self.state = 2541
                self.match(XplorMRParser.Simple_name)
                self.state = 2544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==179:
                    self.state = 2542
                    self.match(XplorMRParser.Mult)
                    self.state = 2543
                    self.match(XplorMRParser.Integer)


                self.state = 2546
                self.number_s()
                self.state = 2547
                self.match(XplorMRParser.Integer)
                self.state = 2548
                self.number_s()
                pass
            elif token in [180]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2550
                self.match(XplorMRParser.HBonded)
                self.state = 2551
                self.match(XplorMRParser.Simple_names)
                self.state = 2552
                self.match(XplorMRParser.Simple_names)
                self.state = 2553
                self.number_s()
                self.state = 2554
                self.number_s()
                pass
            elif token in [182]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2556
                self.match(XplorMRParser.NBFix)
                self.state = 2557
                self.match(XplorMRParser.Simple_name)
                self.state = 2558
                self.match(XplorMRParser.Simple_name)
                self.state = 2559
                self.number_s()
                self.state = 2560
                self.number_s()
                self.state = 2561
                self.number_s()
                self.state = 2562
                self.number_s()
                pass
            elif token in [183]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2564
                self.match(XplorMRParser.NonB)
                self.state = 2565
                self.match(XplorMRParser.Simple_name)
                self.state = 2566
                self.number_s()
                self.state = 2567
                self.number_s()
                self.state = 2568
                self.number_s()
                self.state = 2569
                self.number_s()
                pass
            elif token in [19, 184]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2571
                _la = self._input.LA(1)
                if not(_la==19 or _la==184):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2572
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [185]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2573
                self.match(XplorMRParser.Verbose)
                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 Noe_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def noe_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Noe_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Noe_assignContext,i)


        def distance_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Distance_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Distance_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_assign_loop

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

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




    def noe_assign_loop(self):

        localctx = XplorMRParser.Noe_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_noe_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2576
            self.match(XplorMRParser.For)
            self.state = 2577
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2578
            self.match(XplorMRParser.In_CF)
            self.state = 2579
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2598
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
            if la_ == 1:
                self.state = 2583
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2580
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2585
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2586
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2591
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2595
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2592
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2597
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2600
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2601
            self.match(XplorMRParser.Loop)
            self.state = 2602
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2608
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==3 or _la==4 or _la==173:
                self.state = 2606
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2603
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2604
                    self.noe_assign()
                    pass
                elif token in [3]:
                    self.state = 2605
                    self.distance_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2611
            self.match(XplorMRParser.End)
            self.state = 2612
            self.match(XplorMRParser.Loop)
            self.state = 2613
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedral_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def dihedral_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_assignContext,i)


        def dihedral_angle_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dihedral_angle_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dihedral_angle_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_assign_loop

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

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




    def dihedral_assign_loop(self):

        localctx = XplorMRParser.Dihedral_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_dihedral_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2615
            self.match(XplorMRParser.For)
            self.state = 2616
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2617
            self.match(XplorMRParser.In_CF)
            self.state = 2618
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2637
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,283,self._ctx)
            if la_ == 1:
                self.state = 2622
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2619
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2624
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2628
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2625
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2630
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2634
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2631
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2636
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2639
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2640
            self.match(XplorMRParser.Loop)
            self.state = 2641
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 412316860432) != 0) or _la==173:
                self.state = 2645
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2642
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2643
                    self.dihedral_assign()
                    pass
                elif token in [37, 38]:
                    self.state = 2644
                    self.dihedral_angle_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2650
            self.match(XplorMRParser.End)
            self.state = 2651
            self.match(XplorMRParser.Loop)
            self.state = 2652
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sani_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def sani_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Sani_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Sani_assignContext,i)


        def rdc_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Rdc_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Rdc_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_sani_assign_loop

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

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




    def sani_assign_loop(self):

        localctx = XplorMRParser.Sani_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_sani_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2654
            self.match(XplorMRParser.For)
            self.state = 2655
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2656
            self.match(XplorMRParser.In_CF)
            self.state = 2657
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2676
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
            if la_ == 1:
                self.state = 2661
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2658
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2663
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2667
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2664
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2669
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2673
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2670
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2675
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2678
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2679
            self.match(XplorMRParser.Loop)
            self.state = 2680
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2686
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 7091849999155216) != 0) or _la==173:
                self.state = 2684
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2681
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2682
                    self.sani_assign()
                    pass
                elif token in [41, 44, 45, 48, 51, 52]:
                    self.state = 2683
                    self.rdc_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2689
            self.match(XplorMRParser.End)
            self.state = 2690
            self.match(XplorMRParser.Loop)
            self.state = 2691
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Xadc_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def xadc_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Xadc_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Xadc_assignContext,i)


        def antidistance_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Antidistance_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Antidistance_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_xadc_assign_loop

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

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




    def xadc_assign_loop(self):

        localctx = XplorMRParser.Xadc_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_xadc_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2693
            self.match(XplorMRParser.For)
            self.state = 2694
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2695
            self.match(XplorMRParser.In_CF)
            self.state = 2696
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2715
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
            if la_ == 1:
                self.state = 2700
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2697
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2702
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2703
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2708
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2712
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2709
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2714
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2717
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2718
            self.match(XplorMRParser.Loop)
            self.state = 2719
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==61 or _la==173:
                self.state = 2723
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2720
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2721
                    self.xadc_assign()
                    pass
                elif token in [61]:
                    self.state = 2722
                    self.antidistance_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2728
            self.match(XplorMRParser.End)
            self.state = 2729
            self.match(XplorMRParser.Loop)
            self.state = 2730
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Coup_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def coup_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coup_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coup_assignContext,i)


        def coupling_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coupling_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coupling_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_coup_assign_loop

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

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




    def coup_assign_loop(self):

        localctx = XplorMRParser.Coup_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_coup_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2732
            self.match(XplorMRParser.For)
            self.state = 2733
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2734
            self.match(XplorMRParser.In_CF)
            self.state = 2735
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2754
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,301,self._ctx)
            if la_ == 1:
                self.state = 2739
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2736
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2741
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2745
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2742
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2747
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2751
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2748
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2753
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2756
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2757
            self.match(XplorMRParser.Loop)
            self.state = 2758
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2764
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==65 or _la==173:
                self.state = 2762
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2759
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2760
                    self.coup_assign()
                    pass
                elif token in [65]:
                    self.state = 2761
                    self.coupling_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2767
            self.match(XplorMRParser.End)
            self.state = 2768
            self.match(XplorMRParser.Loop)
            self.state = 2769
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Coll_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def coll_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coll_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coll_assignContext,i)


        def radius_of_gyration_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Radius_of_gyration_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Radius_of_gyration_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_coll_assign_loop

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

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




    def coll_assign_loop(self):

        localctx = XplorMRParser.Coll_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_coll_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2771
            self.match(XplorMRParser.For)
            self.state = 2772
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2773
            self.match(XplorMRParser.In_CF)
            self.state = 2774
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2793
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,307,self._ctx)
            if la_ == 1:
                self.state = 2778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2775
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2780
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2784
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2781
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2786
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2790
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2787
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2792
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2795
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2796
            self.match(XplorMRParser.Loop)
            self.state = 2797
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2803
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==86 or _la==173:
                self.state = 2801
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2798
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2799
                    self.coll_assign()
                    pass
                elif token in [86]:
                    self.state = 2800
                    self.radius_of_gyration_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2806
            self.match(XplorMRParser.End)
            self.state = 2807
            self.match(XplorMRParser.Loop)
            self.state = 2808
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Csa_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def csa_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,i)


        def csa_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_assign_loop

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

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




    def csa_assign_loop(self):

        localctx = XplorMRParser.Csa_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_csa_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2810
            self.match(XplorMRParser.For)
            self.state = 2811
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2812
            self.match(XplorMRParser.In_CF)
            self.state = 2813
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2832
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,313,self._ctx)
            if la_ == 1:
                self.state = 2817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2814
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2823
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2820
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2825
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2829
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2826
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2831
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2834
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2835
            self.match(XplorMRParser.Loop)
            self.state = 2836
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2842
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==92 or _la==173:
                self.state = 2840
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2837
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2838
                    self.csa_assign()
                    pass
                elif token in [92]:
                    self.state = 2839
                    self.csa_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2845
            self.match(XplorMRParser.End)
            self.state = 2846
            self.match(XplorMRParser.Loop)
            self.state = 2847
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pre_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def pre_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_assignContext,i)


        def pre_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_assign_loop

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

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




    def pre_assign_loop(self):

        localctx = XplorMRParser.Pre_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_pre_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2849
            self.match(XplorMRParser.For)
            self.state = 2850
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2851
            self.match(XplorMRParser.In_CF)
            self.state = 2852
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2871
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
            if la_ == 1:
                self.state = 2856
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2853
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2858
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2862
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2859
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2864
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2868
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2865
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2870
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2873
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2874
            self.match(XplorMRParser.Loop)
            self.state = 2875
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2881
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==98 or _la==173:
                self.state = 2879
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2876
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2877
                    self.pre_assign()
                    pass
                elif token in [98]:
                    self.state = 2878
                    self.pre_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2884
            self.match(XplorMRParser.End)
            self.state = 2885
            self.match(XplorMRParser.Loop)
            self.state = 2886
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcs_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def pcs_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_assignContext,i)


        def pcs_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_restraintContext,i)


        def carbon_shift_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Carbon_shift_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Carbon_shift_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_assign_loop

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

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




    def pcs_assign_loop(self):

        localctx = XplorMRParser.Pcs_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_pcs_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2888
            self.match(XplorMRParser.For)
            self.state = 2889
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2890
            self.match(XplorMRParser.In_CF)
            self.state = 2891
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2910
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
            if la_ == 1:
                self.state = 2895
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2892
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2897
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2901
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2898
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2903
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2907
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2904
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2909
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2912
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2913
            self.match(XplorMRParser.Loop)
            self.state = 2914
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==67 or _la==103 or _la==173:
                self.state = 2919
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2915
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2916
                    self.pcs_assign()
                    pass
                elif token in [103]:
                    self.state = 2917
                    self.pcs_restraint()
                    pass
                elif token in [67]:
                    self.state = 2918
                    self.carbon_shift_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2924
            self.match(XplorMRParser.End)
            self.state = 2925
            self.match(XplorMRParser.Loop)
            self.state = 2926
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def hbond_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_assignContext,i)


        def hbond_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_assign_loop

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

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




    def hbond_assign_loop(self):

        localctx = XplorMRParser.Hbond_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_hbond_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2928
            self.match(XplorMRParser.For)
            self.state = 2929
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2930
            self.match(XplorMRParser.In_CF)
            self.state = 2931
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2950
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
            if la_ == 1:
                self.state = 2935
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2932
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2937
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2941
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2938
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2943
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2947
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2944
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2949
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2952
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2953
            self.match(XplorMRParser.Loop)
            self.state = 2954
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2960
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==118 or _la==173:
                self.state = 2958
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2955
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2956
                    self.hbond_assign()
                    pass
                elif token in [118]:
                    self.state = 2957
                    self.hbond_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2963
            self.match(XplorMRParser.End)
            self.state = 2964
            self.match(XplorMRParser.Loop)
            self.state = 2965
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_db_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def hbond_db_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_db_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_db_assignContext,i)


        def hbond_db_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_db_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_db_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_db_assign_loop

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

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




    def hbond_db_assign_loop(self):

        localctx = XplorMRParser.Hbond_db_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_hbond_db_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2967
            self.match(XplorMRParser.For)
            self.state = 2968
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2969
            self.match(XplorMRParser.In_CF)
            self.state = 2970
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2989
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                self.state = 2974
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 2971
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2976
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2980
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 2977
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2982
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2986
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 2983
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2988
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2991
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2992
            self.match(XplorMRParser.Loop)
            self.state = 2993
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2999
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==4 or _la==119 or _la==173:
                self.state = 2997
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 2994
                    self.evaluate_statement()
                    pass
                elif token in [4]:
                    self.state = 2995
                    self.hbond_db_assign()
                    pass
                elif token in [119]:
                    self.state = 2996
                    self.hbond_db_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 3002
            self.match(XplorMRParser.End)
            self.state = 3003
            self.match(XplorMRParser.Loop)
            self.state = 3004
            self.match(XplorMRParser.Simple_name_LL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Planar_group_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(XplorMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(XplorMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(XplorMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(XplorMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(XplorMRParser.R_paren_CF, 0)

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

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

        def End(self):
            return self.getToken(XplorMRParser.End, 0)

        def evaluate_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Evaluate_statementContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Evaluate_statementContext,i)


        def planar_group(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Planar_groupContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Planar_groupContext,i)


        def planar_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Planar_restraintContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Planar_restraintContext,i)


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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_group_loop

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

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




    def planar_group_loop(self):

        localctx = XplorMRParser.Planar_group_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_planar_group_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 3006
            self.match(XplorMRParser.For)
            self.state = 3007
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 3008
            self.match(XplorMRParser.In_CF)
            self.state = 3009
            self.match(XplorMRParser.L_paren_CF)
            self.state = 3028
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,343,self._ctx)
            if la_ == 1:
                self.state = 3013
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==296:
                    self.state = 3010
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 3015
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 3019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==297:
                    self.state = 3016
                    self.match(XplorMRParser.Real_CF)
                    self.state = 3021
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 3025
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==299:
                    self.state = 3022
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 3027
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 3030
            self.match(XplorMRParser.R_paren_CF)
            self.state = 3031
            self.match(XplorMRParser.Loop)
            self.state = 3032
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 3038
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 27021735203176448) != 0) or _la==173:
                self.state = 3036
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [173]:
                    self.state = 3033
                    self.evaluate_statement()
                    pass
                elif token in [54]:
                    self.state = 3034
                    self.planar_group()
                    pass
                elif token in [37, 53]:
                    self.state = 3035
                    self.planar_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 3041
            self.match(XplorMRParser.End)
            self.state = 3042
            self.match(XplorMRParser.Loop)
            self.state = 3043
            self.match(XplorMRParser.Simple_name_LL)
        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[98] = self.factor_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 factor_sempred(self, localctx:FactorContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 32)
         

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




