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

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

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

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.10.1")
        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) & ((1 << XplorMRParser.Noe) | (1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Dihedral) | (1 << XplorMRParser.Print_any) | (1 << XplorMRParser.Sanisotropy) | (1 << XplorMRParser.Xdipolar) | (1 << XplorMRParser.Dipolar) | (1 << XplorMRParser.VeAngle) | (1 << XplorMRParser.Tensor) | (1 << XplorMRParser.Anisotropy) | (1 << XplorMRParser.Planar) | (1 << XplorMRParser.Group) | (1 << XplorMRParser.Initialize) | (1 << XplorMRParser.Harmonic) | (1 << XplorMRParser.Xadc))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (XplorMRParser.Coupling - 64)) | (1 << (XplorMRParser.Carbon - 64)) | (1 << (XplorMRParser.Proton - 64)) | (1 << (XplorMRParser.Observed - 64)) | (1 << (XplorMRParser.Ramachandran - 64)) | (1 << (XplorMRParser.Collapse - 64)) | (1 << (XplorMRParser.Danisotropy - 64)) | (1 << (XplorMRParser.Orient - 64)) | (1 << (XplorMRParser.Dcsa - 64)) | (1 << (XplorMRParser.Pcsa - 64)) | (1 << (XplorMRParser.OneBond - 64)) | (1 << (XplorMRParser.AngleDb - 64)) | (1 << (XplorMRParser.PMagnetic - 64)) | (1 << (XplorMRParser.Xpcs - 64)) | (1 << (XplorMRParser.Xrdcoupling - 64)) | (1 << (XplorMRParser.Xangle - 64)) | (1 << (XplorMRParser.Xccr - 64)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (XplorMRParser.Ncs - 132)) | (1 << (XplorMRParser.Flags - 132)) | (1 << (XplorMRParser.BondedTo - 132)) | (1 << (XplorMRParser.Vector - 132)) | (1 << (XplorMRParser.Evaluate_Lp - 132)) | (1 << (XplorMRParser.Patch - 132)) | (1 << (XplorMRParser.Parameter - 132)) | (1 << (XplorMRParser.HBonded - 132)) | (1 << (XplorMRParser.Improper - 132)) | (1 << (XplorMRParser.NBFix - 132)) | (1 << (XplorMRParser.NonB - 132)) | (1 << (XplorMRParser.VDWOff - 132)) | (1 << (XplorMRParser.Verbose - 132)) | (1 << (XplorMRParser.For - 132)))) != 0) or _la==XplorMRParser.Hbda or _la==XplorMRParser.Hbdb:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Asymptote) | (1 << XplorMRParser.Average) | (1 << XplorMRParser.Bhig) | (1 << XplorMRParser.Ceiling) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.CountViol) | (1 << XplorMRParser.Distribute) | (1 << XplorMRParser.Monomers) | (1 << XplorMRParser.Ncount) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Predict) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Rswitch) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.SoExponent) | (1 << XplorMRParser.SqConstant) | (1 << XplorMRParser.SqExponent) | (1 << XplorMRParser.SqOffset) | (1 << XplorMRParser.Temperature))) != 0) or _la==XplorMRParser.For:
                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==XplorMRParser.Restraints:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Nassign) | (1 << XplorMRParser.Print_any))) != 0) or _la==XplorMRParser.Vector or _la==XplorMRParser.For:
                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 [XplorMRParser.Sanisotropy]:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or _la==XplorMRParser.For:
                    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 [XplorMRParser.Xdipolar, XplorMRParser.Dipolar]:
                self.enterOuterAlt(localctx, 2)
                self.state = 353
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Xdipolar or _la==XplorMRParser.Dipolar):
                    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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Average) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type) | (1 << XplorMRParser.Sign))) != 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 [XplorMRParser.VeAngle]:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Cv) | (1 << XplorMRParser.Partition))) != 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 [XplorMRParser.Tensor]:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients))) != 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 [XplorMRParser.Anisotropy]:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type))) != 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==XplorMRParser.Restraints:
                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) & ((1 << XplorMRParser.Print_any) | (1 << XplorMRParser.Group) | (1 << XplorMRParser.Initialize))) != 0) or _la==XplorMRParser.Vector or _la==XplorMRParser.For:
                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==XplorMRParser.Restraints:
                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==XplorMRParser.Exponent or _la==XplorMRParser.Normal or _la==XplorMRParser.Vector:
                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) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Expectation) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or _la==XplorMRParser.For:
                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)) & ((1 << (XplorMRParser.Assign - 4)) | (1 << (XplorMRParser.Classification - 4)) | (1 << (XplorMRParser.Nrestraints - 4)) | (1 << (XplorMRParser.Potential - 4)) | (1 << (XplorMRParser.Print - 4)) | (1 << (XplorMRParser.Reset - 4)) | (1 << (XplorMRParser.Coefficients - 4)) | (1 << (XplorMRParser.ForceConstant - 4)) | (1 << (XplorMRParser.Cv - 4)) | (1 << (XplorMRParser.Partition - 4)) | (1 << (XplorMRParser.DegEnergy - 4)))) != 0) or _la==XplorMRParser.For:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Expectation) | (1 << XplorMRParser.Zero))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (XplorMRParser.PhiStep - 67)) | (1 << (XplorMRParser.PsiStep - 67)) | (1 << (XplorMRParser.Rcoil - 67)))) != 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) & ((1 << XplorMRParser.Classification) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Anisotropy))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (XplorMRParser.DegEnergy - 65)) | (1 << (XplorMRParser.Carbon - 65)) | (1 << (XplorMRParser.Rcoil - 65)) | (1 << (XplorMRParser.Observed - 65)) | (1 << (XplorMRParser.Amides - 65)) | (1 << (XplorMRParser.Nitrogens - 65)) | (1 << (XplorMRParser.Oxygens - 65)) | (1 << (XplorMRParser.RingAtoms - 65)) | (1 << (XplorMRParser.AlphasAndAmides - 65)) | (1 << (XplorMRParser.Error - 65)))) != 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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Cutoff) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (XplorMRParser.Gaussian - 79)) | (1 << (XplorMRParser.Phase - 79)) | (1 << (XplorMRParser.Quartic - 79)) | (1 << (XplorMRParser.Shape - 79)) | (1 << (XplorMRParser.Sort - 79)))) != 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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale))) != 0) or _la==XplorMRParser.For:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type))) != 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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Cutoff) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or ((((_la - 79)) & ~0x3f) == 0 and ((1 << (_la - 79)) & ((1 << (XplorMRParser.Gaussian - 79)) | (1 << (XplorMRParser.Quartic - 79)) | (1 << (XplorMRParser.Height - 79)) | (1 << (XplorMRParser.MaxGaussians - 79)) | (1 << (XplorMRParser.NewGaussian - 79)))) != 0) or _la==XplorMRParser.Residue:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type))) != 0) or _la==XplorMRParser.Sigma or _la==XplorMRParser.For:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or _la==XplorMRParser.Sigma:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Expectation) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or _la==XplorMRParser.Error or _la==XplorMRParser.DerivFlag:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant))) != 0) or ((((_la - 98)) & ~0x3f) == 0 and ((1 << (_la - 98)) & ((1 << (XplorMRParser.Kconst - 98)) | (1 << (XplorMRParser.Omega - 98)) | (1 << (XplorMRParser.Tauc - 98)) | (1 << (XplorMRParser.Debug - 98)))) != 0) or _la==XplorMRParser.For:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & ((1 << (XplorMRParser.Tolerance - 103)) | (1 << (XplorMRParser.Save - 103)) | (1 << (XplorMRParser.Fmed - 103)) | (1 << (XplorMRParser.ErrOn - 103)) | (1 << (XplorMRParser.ErrOff - 103)) | (1 << (XplorMRParser.Fon - 103)) | (1 << (XplorMRParser.Foff - 103)) | (1 << (XplorMRParser.Son - 103)) | (1 << (XplorMRParser.Soff - 103)) | (1 << (XplorMRParser.Frun - 103)))) != 0) or _la==XplorMRParser.For:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & ((1 << (XplorMRParser.Tolerance - 103)) | (1 << (XplorMRParser.Save - 103)) | (1 << (XplorMRParser.Fmed - 103)) | (1 << (XplorMRParser.ErrOn - 103)) | (1 << (XplorMRParser.ErrOff - 103)) | (1 << (XplorMRParser.Fon - 103)) | (1 << (XplorMRParser.Foff - 103)) | (1 << (XplorMRParser.Son - 103)) | (1 << (XplorMRParser.Soff - 103)) | (1 << (XplorMRParser.Frun - 103)))) != 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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant))) != 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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or _la==XplorMRParser.Frun or _la==XplorMRParser.Weip:
                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) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant))) != 0) or _la==XplorMRParser.For:
                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==XplorMRParser.Assign or ((((_la - 117)) & ~0x3f) == 0 and ((1 << (_la - 117)) & ((1 << (XplorMRParser.Kdir - 117)) | (1 << (XplorMRParser.Klin - 117)) | (1 << (XplorMRParser.Nseg - 117)) | (1 << (XplorMRParser.Nmin - 117)) | (1 << (XplorMRParser.Nmax - 117)) | (1 << (XplorMRParser.Segm - 117)) | (1 << (XplorMRParser.Ohcut - 117)) | (1 << (XplorMRParser.Coh1cut - 117)) | (1 << (XplorMRParser.Coh2cut - 117)) | (1 << (XplorMRParser.Ohncut - 117)) | (1 << (XplorMRParser.Updfrq - 117)) | (1 << (XplorMRParser.Prnfrq - 117)) | (1 << (XplorMRParser.Freemode - 117)))) != 0) or _la==XplorMRParser.For:
                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 [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 582
                self.noe_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 583
                self.noe_assign_loop()
                pass
            elif token in [XplorMRParser.Asymptote]:
                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 [XplorMRParser.Average]:
                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 [XplorMRParser.Bhig]:
                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 [XplorMRParser.Ceiling]:
                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==XplorMRParser.Equ_op:
                    self.state = 596
                    self.match(XplorMRParser.Equ_op)


                self.state = 599
                self.number_s()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 7)
                self.state = 600
                self.classification()
                pass
            elif token in [XplorMRParser.CountViol]:
                self.enterOuterAlt(localctx, 8)
                self.state = 601
                self.match(XplorMRParser.CountViol)
                self.state = 602
                self.class_name()
                pass
            elif token in [XplorMRParser.Distribute]:
                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 [XplorMRParser.Monomers]:
                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 [XplorMRParser.Ncount]:
                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 [XplorMRParser.Nrestraints]:
                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==XplorMRParser.Equ_op:
                    self.state = 617
                    self.match(XplorMRParser.Equ_op)


                self.state = 620
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                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 [XplorMRParser.Predict]:
                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 [XplorMRParser.Print]:
                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==XplorMRParser.Equ_op:
                    self.state = 630
                    self.match(XplorMRParser.Equ_op)


                self.state = 633
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 16)
                self.state = 634
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Rswitch]:
                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 [XplorMRParser.Scale]:
                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 [XplorMRParser.SoExponent]:
                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 [XplorMRParser.SqConstant]:
                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 [XplorMRParser.SqExponent]:
                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 [XplorMRParser.SqOffset]:
                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 [XplorMRParser.Temperature]:
                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==XplorMRParser.Equ_op:
                    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 - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 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) & ((1 << XplorMRParser.Peak) | (1 << XplorMRParser.Spectrum) | (1 << XplorMRParser.Volume) | (1 << XplorMRParser.Ppm1) | (1 << XplorMRParser.Ppm2) | (1 << XplorMRParser.Cv) | (1 << XplorMRParser.Weight))) != 0):
                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==XplorMRParser.Or_op:
                self.state = 682
                self.match(XplorMRParser.Or_op)
                self.state = 684
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Assign:
                    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 - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 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 [XplorMRParser.Cutoff]:
                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==XplorMRParser.Equ_op:
                    self.state = 703
                    self.match(XplorMRParser.Equ_op)


                self.state = 706
                self.number_s()
                pass
            elif token in [XplorMRParser.Cuton]:
                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==XplorMRParser.Equ_op:
                    self.state = 708
                    self.match(XplorMRParser.Equ_op)


                self.state = 711
                self.number_s()
                pass
            elif token in [XplorMRParser.From]:
                self.enterOuterAlt(localctx, 3)
                self.state = 712
                self.match(XplorMRParser.From)
                self.state = 713
                self.selection()
                pass
            elif token in [XplorMRParser.To]:
                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 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 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 = 753
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Peak]:
                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==XplorMRParser.Equ_op:
                    self.state = 719
                    self.match(XplorMRParser.Equ_op)


                self.state = 722
                self.number_a()
                pass
            elif token in [XplorMRParser.Spectrum]:
                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==XplorMRParser.Equ_op:
                    self.state = 724
                    self.match(XplorMRParser.Equ_op)


                self.state = 727
                self.number_a()
                pass
            elif token in [XplorMRParser.Weight]:
                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==XplorMRParser.Equ_op:
                    self.state = 729
                    self.match(XplorMRParser.Equ_op)


                self.state = 732
                self.number_a()
                pass
            elif token in [XplorMRParser.Volume]:
                self.enterOuterAlt(localctx, 4)
                self.state = 733
                self.match(XplorMRParser.Volume)
                self.state = 735
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 734
                    self.match(XplorMRParser.Equ_op)


                self.state = 737
                self.number_a()
                pass
            elif token in [XplorMRParser.Ppm1]:
                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==XplorMRParser.Equ_op:
                    self.state = 739
                    self.match(XplorMRParser.Equ_op)


                self.state = 742
                self.number_a()
                pass
            elif token in [XplorMRParser.Ppm2]:
                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==XplorMRParser.Equ_op:
                    self.state = 744
                    self.match(XplorMRParser.Equ_op)


                self.state = 747
                self.number_a()
                pass
            elif token in [XplorMRParser.Cv]:
                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==XplorMRParser.Equ_op:
                    self.state = 749
                    self.match(XplorMRParser.Equ_op)


                self.state = 752
                self.number_a()
                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 = 770
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Vector]:
                self.enterOuterAlt(localctx, 1)
                self.state = 755
                self.vector_statement()
                pass
            elif token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 2)
                self.state = 756
                self.dihedral_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 3)
                self.state = 757
                self.dihedral_assign_loop()
                pass
            elif token in [XplorMRParser.Nassign]:
                self.enterOuterAlt(localctx, 4)
                self.state = 758
                self.match(XplorMRParser.Nassign)
                self.state = 760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 759
                    self.match(XplorMRParser.Equ_op)


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


                self.state = 768
                self.number_s()
                pass
            elif token in [XplorMRParser.Print_any]:
                self.enterOuterAlt(localctx, 7)
                self.state = 769
                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 = 772
            self.match(XplorMRParser.Assign)
            self.state = 773
            self.selection()
            self.state = 774
            self.selection()
            self.state = 775
            self.selection()
            self.state = 776
            self.selection()
            self.state = 777
            self.number()
            self.state = 778
            self.number()
            self.state = 779
            self.number()
            self.state = 780
            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 = 809
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 782
                self.sani_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 783
                self.sani_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 784
                self.classification()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 785
                self.match(XplorMRParser.Coefficients)
                self.state = 786
                self.number_s()
                self.state = 787
                self.number_s()
                self.state = 788
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 790
                self.match(XplorMRParser.ForceConstant)
                self.state = 792
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 791
                    self.match(XplorMRParser.Equ_op)


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


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


                self.state = 804
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 805
                self.match(XplorMRParser.Print)
                self.state = 806
                self.match(XplorMRParser.Threshold)
                self.state = 807
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 9)
                self.state = 808
                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 = 811
            self.match(XplorMRParser.Assign)
            self.state = 812
            self.selection()
            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.number()
            self.state = 820
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.state = 819
                self.number()


            self.state = 823
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 822
                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 = 862
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 825
                self.xdip_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 826
                self.classification()
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 3)
                self.state = 827
                self.match(XplorMRParser.Type)
                self.state = 828
                self.match(XplorMRParser.Rdc_dist_fix_types)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 829
                self.match(XplorMRParser.Scale)
                self.state = 831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 830
                    self.match(XplorMRParser.Equ_op)


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


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


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


                self.state = 857
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 11)
                self.state = 858
                self.match(XplorMRParser.Print)
                self.state = 859
                self.match(XplorMRParser.Threshold)
                self.state = 860
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 861
                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 = 864
            self.match(XplorMRParser.Assign)
            self.state = 865
            self.selection()
            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.number()
            self.state = 872
            self.number()
            self.state = 879
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 873
                self.number()

            elif la_ == 2:
                self.state = 874
                self.number()
                self.state = 875
                self.number()
                self.state = 876
                self.number()
                self.state = 877
                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 = 909
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 881
                self.vean_assign()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 2)
                self.state = 882
                self.match(XplorMRParser.Cv)
                self.state = 884
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 883
                    self.match(XplorMRParser.Equ_op)


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


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


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


                self.state = 904
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 905
                self.match(XplorMRParser.Print)
                self.state = 906
                self.match(XplorMRParser.Threshold)
                self.state = 907
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 908
                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 = 911
            self.match(XplorMRParser.Assign)
            self.state = 912
            self.selection()
            self.state = 913
            self.selection()
            self.state = 914
            self.selection()
            self.state = 915
            self.selection()
            self.state = 916
            self.number()
            self.state = 917
            self.number()
            self.state = 921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 918
                self.number()
                self.state = 919
                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 = 941
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 923
                self.tenso_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 924
                self.classification()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 925
                self.match(XplorMRParser.Coefficients)
                self.state = 926
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 927
                self.match(XplorMRParser.Nrestraints)
                self.state = 929
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 928
                    self.match(XplorMRParser.Equ_op)


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


                self.state = 936
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 937
                self.match(XplorMRParser.Print)
                self.state = 938
                self.match(XplorMRParser.Threshold)
                self.state = 939
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 940
                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 = 943
            self.match(XplorMRParser.Assign)
            self.state = 944
            self.selection()
            self.state = 945
            self.selection()
            self.state = 946
            self.number()
            self.state = 948
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 947
                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 = 979
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 950
                self.anis_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 951
                self.classification()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 952
                self.match(XplorMRParser.Coefficients)
                self.state = 953
                self.number_s()
                self.state = 954
                self.number_s()
                self.state = 955
                self.number_s()
                self.state = 956
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 958
                self.match(XplorMRParser.ForceConstant)
                self.state = 960
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 959
                    self.match(XplorMRParser.Equ_op)


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


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


                self.state = 972
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 973
                self.match(XplorMRParser.Print)
                self.state = 974
                self.match(XplorMRParser.Threshold)
                self.state = 975
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 976
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 977
                self.match(XplorMRParser.Type)
                self.state = 978
                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 = 981
            self.match(XplorMRParser.Assign)
            self.state = 982
            self.selection()
            self.state = 983
            self.selection()
            self.state = 984
            self.selection()
            self.state = 985
            self.selection()
            self.state = 986
            self.number()
            self.state = 988
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 987
                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 = 995
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Vector]:
                self.enterOuterAlt(localctx, 1)
                self.state = 990
                self.vector_statement()
                pass
            elif token in [XplorMRParser.Group]:
                self.enterOuterAlt(localctx, 2)
                self.state = 991
                self.planar_group()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 3)
                self.state = 992
                self.planar_group_loop()
                pass
            elif token in [XplorMRParser.Initialize]:
                self.enterOuterAlt(localctx, 4)
                self.state = 993
                self.match(XplorMRParser.Initialize)
                pass
            elif token in [XplorMRParser.Print_any]:
                self.enterOuterAlt(localctx, 5)
                self.state = 994
                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 = 997
            self.match(XplorMRParser.Group)
            self.state = 1001
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Selection or _la==XplorMRParser.Weight:
                self.state = 998
                self.group_statement()
                self.state = 1003
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1004
            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 = 1016
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Selection]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1006
                self.match(XplorMRParser.Selection)
                self.state = 1008
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1007
                    self.match(XplorMRParser.Equ_op)


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


                self.state = 1015
                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 = 1058
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Vector]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1018
                self.vector_statement()
                pass
            elif token in [XplorMRParser.Exponent]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1019
                self.match(XplorMRParser.Exponent)
                self.state = 1021
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1020
                    self.match(XplorMRParser.Equ_op)


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


                self.state = 1028
                self.match(XplorMRParser.L_paren)
                self.state = 1054
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Integer, XplorMRParser.Real, XplorMRParser.Symbol_name]:
                    self.state = 1029
                    self.number_s()
                    self.state = 1031
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==XplorMRParser.Comma:
                        self.state = 1030
                        self.match(XplorMRParser.Comma)


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


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


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


                    self.state = 1052
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==XplorMRParser.Head:
                        self.state = 1047
                        self.match(XplorMRParser.Head)
                        self.state = 1049
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==XplorMRParser.Equ_op:
                            self.state = 1048
                            self.match(XplorMRParser.Equ_op)


                        self.state = 1051
                        self.selection()


                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1056
                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 = 1060
            self.match(XplorMRParser.Assign)
            self.state = 1061
            self.selection()
            self.state = 1062
            self.number()
            self.state = 1063
            self.number()
            self.state = 1064
            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 = 1095
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1066
                self.xadc_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1067
                self.xadc_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1068
                self.classification()
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1069
                self.match(XplorMRParser.Expectation)
                self.state = 1070
                self.match(XplorMRParser.Integer)
                self.state = 1071
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1072
                self.match(XplorMRParser.ForceConstant)
                self.state = 1074
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1073
                    self.match(XplorMRParser.Equ_op)


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


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

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1089
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1090
                self.match(XplorMRParser.Size)
                self.state = 1091
                self.number_s()
                self.state = 1092
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1094
                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 = 1097
            self.match(XplorMRParser.Assign)
            self.state = 1098
            self.selection()
            self.state = 1099
            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 DegEnergy(self):
            return self.getToken(XplorMRParser.DegEnergy, 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 = 1145
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1101
                self.coup_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1102
                self.coup_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1103
                self.classification()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1104
                self.match(XplorMRParser.Coefficients)
                self.state = 1105
                self.number_s()
                self.state = 1106
                self.number_s()
                self.state = 1107
                self.number_s()
                self.state = 1108
                self.number_s()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1110
                self.match(XplorMRParser.Cv)
                self.state = 1112
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1111
                    self.match(XplorMRParser.Equ_op)


                self.state = 1114
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1115
                self.match(XplorMRParser.DegEnergy)
                self.state = 1116
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1117
                self.match(XplorMRParser.ForceConstant)
                self.state = 1118
                self.number_s()
                self.state = 1120
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                    self.state = 1119
                    self.number_s()


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


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


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


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

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1144
                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 = 1147
            self.match(XplorMRParser.Assign)
            self.state = 1148
            self.selection()
            self.state = 1149
            self.selection()
            self.state = 1150
            self.selection()
            self.state = 1151
            self.selection()
            self.state = 1157
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1152
                self.selection()
                self.state = 1153
                self.selection()
                self.state = 1154
                self.selection()
                self.state = 1155
                self.selection()


            self.state = 1159
            self.number()
            self.state = 1160
            self.number()
            self.state = 1164
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1161
                self.number()
                self.state = 1162
                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 = 1200
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1166
                self.carbon_shift_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1167
                self.classification()
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1168
                self.match(XplorMRParser.Expectation)
                self.state = 1169
                self.match(XplorMRParser.Integer)
                self.state = 1170
                self.match(XplorMRParser.Integer)
                self.state = 1171
                self.number_s()
                self.state = 1172
                self.number_s()
                self.state = 1173
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1175
                self.match(XplorMRParser.ForceConstant)
                self.state = 1177
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1176
                    self.match(XplorMRParser.Equ_op)


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


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


                self.state = 1193
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1194
                self.match(XplorMRParser.Print)
                self.state = 1195
                self.match(XplorMRParser.Threshold)
                self.state = 1196
                self.number_s()
                pass
            elif token in [XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1197
                self.carbon_shift_rcoil()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1198
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1199
                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 = 1202
            self.match(XplorMRParser.Assign)
            self.state = 1203
            self.selection()
            self.state = 1204
            self.selection()
            self.state = 1205
            self.selection()
            self.state = 1206
            self.selection()
            self.state = 1207
            self.selection()
            self.state = 1208
            self.number()
            self.state = 1209
            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 = 1211
            self.match(XplorMRParser.Rcoil)
            self.state = 1212
            self.selection()
            self.state = 1213
            self.number()
            self.state = 1214
            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 DegEnergy(self):
            return self.getToken(XplorMRParser.DegEnergy, 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 = 1250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Observed]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1216
                self.observed()
                pass
            elif token in [XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1217
                self.proton_shift_rcoil()
                pass
            elif token in [XplorMRParser.Anisotropy]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1218
                self.proton_shift_anisotropy()
                pass
            elif token in [XplorMRParser.Amides]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1219
                self.proton_shift_amides()
                pass
            elif token in [XplorMRParser.Carbon]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1220
                self.proton_shift_carbons()
                pass
            elif token in [XplorMRParser.Nitrogens]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1221
                self.proton_shift_nitrogens()
                pass
            elif token in [XplorMRParser.Oxygens]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1222
                self.proton_shift_oxygens()
                pass
            elif token in [XplorMRParser.RingAtoms]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1223
                self.proton_shift_ring_atoms()
                pass
            elif token in [XplorMRParser.AlphasAndAmides]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1224
                self.proton_shift_alphas_and_amides()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1225
                self.classification()
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1226
                self.match(XplorMRParser.Error)
                self.state = 1227
                self.number_s()
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1228
                self.match(XplorMRParser.DegEnergy)
                self.state = 1229
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1230
                self.match(XplorMRParser.ForceConstant)
                self.state = 1231
                self.number_s()
                self.state = 1233
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                    self.state = 1232
                    self.number_s()


                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1235
                self.match(XplorMRParser.Potential)
                self.state = 1237
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1236
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1239
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1240
                self.match(XplorMRParser.Print)
                self.state = 1241
                self.match(XplorMRParser.Threshold)
                self.state = 1242
                self.number_s()
                self.state = 1245
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1243
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1244
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1247
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1249
                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 = 1252
            self.match(XplorMRParser.Observed)
            self.state = 1253
            self.selection()
            self.state = 1255
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1254
                self.selection()


            self.state = 1257
            self.number()
            self.state = 1259
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1258
                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 = 1261
            self.match(XplorMRParser.Rcoil)
            self.state = 1262
            self.selection()
            self.state = 1263
            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 = 1265
            self.match(XplorMRParser.Anisotropy)
            self.state = 1266
            self.selection()
            self.state = 1267
            self.selection()
            self.state = 1268
            self.selection()
            self.state = 1269
            self.match(XplorMRParser.Simple_name)
            self.state = 1271
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Logical:
                self.state = 1270
                self.match(XplorMRParser.Logical)


            self.state = 1273
            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 = 1275
            self.match(XplorMRParser.Amides)
            self.state = 1276
            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 = 1278
            self.match(XplorMRParser.Carbon)
            self.state = 1279
            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 = 1281
            self.match(XplorMRParser.Nitrogens)
            self.state = 1282
            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 = 1284
            self.match(XplorMRParser.Oxygens)
            self.state = 1285
            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 = 1287
            self.match(XplorMRParser.RingAtoms)
            self.state = 1288
            self.match(XplorMRParser.Simple_name)
            self.state = 1289
            self.selection()
            self.state = 1290
            self.selection()
            self.state = 1291
            self.selection()
            self.state = 1292
            self.selection()
            self.state = 1293
            self.selection()
            self.state = 1295
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1294
                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 = 1297
            self.match(XplorMRParser.AlphasAndAmides)
            self.state = 1298
            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 = 1409
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1300
                self.rama_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1301
                self.classification()
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1302
                self.match(XplorMRParser.Cutoff)
                self.state = 1303
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1304
                self.match(XplorMRParser.ForceConstant)
                self.state = 1306
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1305
                    self.match(XplorMRParser.Equ_op)


                self.state = 1308
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1309
                self.match(XplorMRParser.Gaussian)
                self.state = 1310
                self.number_s()
                self.state = 1311
                self.number_s()
                self.state = 1312
                self.number_s()
                self.state = 1317
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                if la_ == 1:
                    self.state = 1313
                    self.number_s()
                    self.state = 1314
                    self.number_s()
                    self.state = 1315
                    self.number_s()


                self.state = 1323
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
                if la_ == 1:
                    self.state = 1319
                    self.number_s()
                    self.state = 1320
                    self.number_s()
                    self.state = 1321
                    self.number_s()


                self.state = 1329
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                    self.state = 1325
                    self.number_s()
                    self.state = 1326
                    self.number_s()
                    self.state = 1327
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1331
                self.match(XplorMRParser.Nrestraints)
                self.state = 1333
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1332
                    self.match(XplorMRParser.Equ_op)


                self.state = 1335
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Phase]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1336
                self.match(XplorMRParser.Phase)
                self.state = 1337
                self.number_s()
                self.state = 1338
                self.number_s()
                self.state = 1339
                self.number_s()
                self.state = 1344
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
                if la_ == 1:
                    self.state = 1340
                    self.number_s()
                    self.state = 1341
                    self.number_s()
                    self.state = 1342
                    self.number_s()


                self.state = 1350
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                if la_ == 1:
                    self.state = 1346
                    self.number_s()
                    self.state = 1347
                    self.number_s()
                    self.state = 1348
                    self.number_s()


                self.state = 1356
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                    self.state = 1352
                    self.number_s()
                    self.state = 1353
                    self.number_s()
                    self.state = 1354
                    self.number_s()


                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1358
                self.match(XplorMRParser.Print)
                self.state = 1359
                self.match(XplorMRParser.Threshold)
                self.state = 1360
                self.number_s()
                self.state = 1363
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1361
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1362
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1365
                self.match(XplorMRParser.Quartic)
                self.state = 1366
                self.number_s()
                self.state = 1367
                self.number_s()
                self.state = 1368
                self.number_s()
                self.state = 1373
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
                if la_ == 1:
                    self.state = 1369
                    self.number_s()
                    self.state = 1370
                    self.number_s()
                    self.state = 1371
                    self.number_s()


                self.state = 1379
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
                if la_ == 1:
                    self.state = 1375
                    self.number_s()
                    self.state = 1376
                    self.number_s()
                    self.state = 1377
                    self.number_s()


                self.state = 1385
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                    self.state = 1381
                    self.number_s()
                    self.state = 1382
                    self.number_s()
                    self.state = 1383
                    self.number_s()


                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1387
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1388
                self.match(XplorMRParser.Scale)
                self.state = 1390
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1389
                    self.match(XplorMRParser.Equ_op)


                self.state = 1392
                self.number_s()
                pass
            elif token in [XplorMRParser.Shape]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1393
                self.match(XplorMRParser.Shape)
                self.state = 1394
                self.match(XplorMRParser.Gauss_or_Quart)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1395
                self.match(XplorMRParser.Size)
                self.state = 1396
                self.match(XplorMRParser.Dimensions)
                self.state = 1397
                self.number_s()
                self.state = 1399
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                if la_ == 1:
                    self.state = 1398
                    self.number_s()


                self.state = 1402
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
                if la_ == 1:
                    self.state = 1401
                    self.number_s()


                self.state = 1405
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                    self.state = 1404
                    self.number_s()


                pass
            elif token in [XplorMRParser.Sort]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1407
                self.match(XplorMRParser.Sort)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1408
                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 = 1411
            self.match(XplorMRParser.Assign)
            self.state = 1412
            self.selection()
            self.state = 1413
            self.selection()
            self.state = 1414
            self.selection()
            self.state = 1415
            self.selection()
            self.state = 1421
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
            if la_ == 1:
                self.state = 1416
                self.selection()
                self.state = 1417
                self.selection()
                self.state = 1418
                self.selection()
                self.state = 1419
                self.selection()


            self.state = 1428
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.state = 1423
                self.selection()
                self.state = 1424
                self.selection()
                self.state = 1425
                self.selection()
                self.state = 1426
                self.selection()


            self.state = 1435
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1430
                self.selection()
                self.state = 1431
                self.selection()
                self.state = 1432
                self.selection()
                self.state = 1433
                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 = 1446
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1437
                self.coll_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1438
                self.coll_assign_loop()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1439
                self.match(XplorMRParser.Scale)
                self.state = 1441
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1440
                    self.match(XplorMRParser.Equ_op)


                self.state = 1443
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1444
                self.match(XplorMRParser.Print)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1445
                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 = 1448
            self.match(XplorMRParser.Assign)
            self.state = 1449
            self.selection()
            self.state = 1450
            self.number()
            self.state = 1451
            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 = 1483
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1453
                self.dani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1454
                self.classification()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1455
                self.match(XplorMRParser.Coefficients)
                self.state = 1456
                self.number_s()
                self.state = 1457
                self.number_s()
                self.state = 1458
                self.number_s()
                self.state = 1459
                self.number_s()
                self.state = 1460
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1462
                self.match(XplorMRParser.ForceConstant)
                self.state = 1464
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1463
                    self.match(XplorMRParser.Equ_op)


                self.state = 1466
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1467
                self.match(XplorMRParser.Nrestraints)
                self.state = 1469
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1468
                    self.match(XplorMRParser.Equ_op)


                self.state = 1471
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1472
                self.match(XplorMRParser.Potential)
                self.state = 1474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1473
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1476
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1477
                self.match(XplorMRParser.Print)
                self.state = 1478
                self.match(XplorMRParser.Threshold)
                self.state = 1479
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1480
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1481
                self.match(XplorMRParser.Type)
                self.state = 1482
                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 = 1485
            self.match(XplorMRParser.Assign)
            self.state = 1486
            self.selection()
            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.number()
            self.state = 1494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1493
                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 = 1557
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1496
                self.orie_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1497
                self.classification()
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1498
                self.match(XplorMRParser.Cutoff)
                self.state = 1499
                self.number_s()
                pass
            elif token in [XplorMRParser.Height]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1500
                self.match(XplorMRParser.Height)
                self.state = 1501
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1502
                self.match(XplorMRParser.ForceConstant)
                self.state = 1504
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1503
                    self.match(XplorMRParser.Equ_op)


                self.state = 1506
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1507
                self.match(XplorMRParser.Gaussian)
                self.state = 1508
                self.number_s()
                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()
                pass
            elif token in [XplorMRParser.MaxGaussians]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1516
                self.match(XplorMRParser.MaxGaussians)
                self.state = 1517
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.NewGaussian]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1518
                self.match(XplorMRParser.NewGaussian)
                self.state = 1519
                self.number_s()
                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()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1528
                self.match(XplorMRParser.Nrestraints)
                self.state = 1530
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1529
                    self.match(XplorMRParser.Equ_op)


                self.state = 1532
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1533
                self.match(XplorMRParser.Print)
                self.state = 1534
                self.match(XplorMRParser.Threshold)
                self.state = 1535
                self.number_s()
                self.state = 1538
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1536
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1537
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1540
                self.match(XplorMRParser.Quartic)
                self.state = 1541
                self.number_s()
                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()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1549
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Residue]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1550
                self.match(XplorMRParser.Residue)
                self.state = 1551
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1552
                self.match(XplorMRParser.Size)
                self.state = 1553
                self.number_s()
                self.state = 1554
                self.number_s()
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1556
                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 = 1559
            self.match(XplorMRParser.Assign)
            self.state = 1560
            self.selection()
            self.state = 1561
            self.selection()
            self.state = 1562
            self.selection()
            self.state = 1563
            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 = 1604
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1565
                self.csa_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1566
                self.csa_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1567
                self.classification()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1568
                self.match(XplorMRParser.Scale)
                self.state = 1570
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1569
                    self.match(XplorMRParser.Equ_op)


                self.state = 1572
                self.number_s()
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1573
                self.match(XplorMRParser.Type)
                self.state = 1574
                self.match(XplorMRParser.Csa_types)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1575
                self.match(XplorMRParser.Coefficients)
                self.state = 1576
                self.number_s()
                self.state = 1577
                self.number_s()
                self.state = 1578
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1580
                self.match(XplorMRParser.Sigma)
                self.state = 1581
                self.number_s()
                self.state = 1582
                self.number_s()
                self.state = 1583
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1585
                self.match(XplorMRParser.ForceConstant)
                self.state = 1587
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1586
                    self.match(XplorMRParser.Equ_op)


                self.state = 1589
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1590
                self.match(XplorMRParser.Nrestraints)
                self.state = 1592
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1591
                    self.match(XplorMRParser.Equ_op)


                self.state = 1594
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1595
                self.match(XplorMRParser.Potential)
                self.state = 1597
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1596
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1599
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1600
                self.match(XplorMRParser.Print)
                self.state = 1601
                self.match(XplorMRParser.Threshold)
                self.state = 1602
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1603
                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 = 1606
            self.match(XplorMRParser.Assign)
            self.state = 1607
            self.selection()
            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.number()
            self.state = 1616
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
            if la_ == 1:
                self.state = 1615
                self.number()


            self.state = 1619
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1618
                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 = 1658
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1621
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1622
                self.classification()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1623
                self.match(XplorMRParser.Scale)
                self.state = 1625
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1624
                    self.match(XplorMRParser.Equ_op)


                self.state = 1627
                self.number_s()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1628
                self.match(XplorMRParser.Coefficients)
                self.state = 1629
                self.number_s()
                self.state = 1630
                self.number_s()
                self.state = 1631
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1633
                self.match(XplorMRParser.Sigma)
                self.state = 1634
                self.number_s()
                self.state = 1635
                self.number_s()
                self.state = 1636
                self.number_s()
                self.state = 1637
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1639
                self.match(XplorMRParser.ForceConstant)
                self.state = 1641
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1640
                    self.match(XplorMRParser.Equ_op)


                self.state = 1643
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1644
                self.match(XplorMRParser.Nrestraints)
                self.state = 1646
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1645
                    self.match(XplorMRParser.Equ_op)


                self.state = 1648
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1649
                self.match(XplorMRParser.Potential)
                self.state = 1651
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1650
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1653
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1654
                self.match(XplorMRParser.Print)
                self.state = 1655
                self.match(XplorMRParser.Threshold)
                self.state = 1656
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1657
                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 = 1690
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1660
                self.one_bond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1661
                self.classification()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1662
                self.match(XplorMRParser.Coefficients)
                self.state = 1663
                self.number_s()
                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()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1671
                self.match(XplorMRParser.ForceConstant)
                self.state = 1673
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1672
                    self.match(XplorMRParser.Equ_op)


                self.state = 1675
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1676
                self.match(XplorMRParser.Nrestraints)
                self.state = 1678
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1677
                    self.match(XplorMRParser.Equ_op)


                self.state = 1680
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1681
                self.match(XplorMRParser.Potential)
                self.state = 1683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1682
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1685
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1686
                self.match(XplorMRParser.Print)
                self.state = 1687
                self.match(XplorMRParser.Threshold)
                self.state = 1688
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1689
                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 = 1692
            self.match(XplorMRParser.Assign)
            self.state = 1693
            self.selection()
            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.number()
            self.state = 1702
            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 = 1742
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1704
                self.angle_db_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1705
                self.classification()
                pass
            elif token in [XplorMRParser.DerivFlag]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1706
                self.match(XplorMRParser.DerivFlag)
                self.state = 1707
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1708
                self.match(XplorMRParser.Expectation)
                self.state = 1709
                self.match(XplorMRParser.Integer)
                self.state = 1710
                self.match(XplorMRParser.Integer)
                self.state = 1711
                self.number_s()
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1712
                self.match(XplorMRParser.Error)
                self.state = 1713
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1714
                self.match(XplorMRParser.ForceConstant)
                self.state = 1716
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1715
                    self.match(XplorMRParser.Equ_op)


                self.state = 1718
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1719
                self.match(XplorMRParser.Nrestraints)
                self.state = 1721
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1720
                    self.match(XplorMRParser.Equ_op)


                self.state = 1723
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1724
                self.match(XplorMRParser.Potential)
                self.state = 1726
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1725
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1728
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1729
                self.match(XplorMRParser.Print)
                self.state = 1730
                self.match(XplorMRParser.Threshold)
                self.state = 1731
                self.number_s()
                self.state = 1734
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1732
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1733
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1736
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1737
                self.match(XplorMRParser.Size)
                self.state = 1738
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Dihedral or _la==XplorMRParser.AngleDb):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1739
                self.match(XplorMRParser.Integer)
                self.state = 1740
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1741
                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 = 1744
            self.match(XplorMRParser.Assign)
            self.state = 1745
            self.selection()
            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 = 1757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1756
                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 = 1811
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1759
                self.pre_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1760
                self.pre_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1761
                self.classification()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1762
                self.match(XplorMRParser.ForceConstant)
                self.state = 1764
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1763
                    self.match(XplorMRParser.Equ_op)


                self.state = 1766
                self.class_name()
                self.state = 1767
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1769
                self.match(XplorMRParser.Nrestraints)
                self.state = 1771
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1770
                    self.match(XplorMRParser.Equ_op)


                self.state = 1773
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1774
                self.match(XplorMRParser.Potential)
                self.state = 1776
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_PT:
                    self.state = 1775
                    self.match(XplorMRParser.Equ_op_PT)


                self.state = 1778
                self.match(XplorMRParser.Class_name_PT)
                self.state = 1779
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Kconst]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1780
                self.match(XplorMRParser.Kconst)
                self.state = 1782
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1781
                    self.match(XplorMRParser.Equ_op)


                self.state = 1784
                self.class_name()
                self.state = 1785
                self.number_s()
                pass
            elif token in [XplorMRParser.Omega]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1787
                self.match(XplorMRParser.Omega)
                self.state = 1789
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1788
                    self.match(XplorMRParser.Equ_op)


                self.state = 1791
                self.class_name()
                self.state = 1792
                self.number_s()
                pass
            elif token in [XplorMRParser.Tauc]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1794
                self.match(XplorMRParser.Tauc)
                self.state = 1796
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1795
                    self.match(XplorMRParser.Equ_op)


                self.state = 1798
                self.class_name()
                self.state = 1799
                self.number_s()
                self.state = 1800
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1802
                self.match(XplorMRParser.Print)
                self.state = 1803
                self.match(XplorMRParser.Threshold)
                self.state = 1804
                self.number_s()
                self.state = 1807
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1805
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1806
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1809
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Debug]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1810
                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 = 1813
            self.match(XplorMRParser.Assign)
            self.state = 1814
            self.selection()
            self.state = 1815
            self.selection()
            self.state = 1816
            self.number()
            self.state = 1818
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1817
                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 = 1861
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1820
                self.pcs_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1821
                self.pcs_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1822
                self.classification()
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1823
                self.match(XplorMRParser.Tolerance)
                self.state = 1824
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1825
                self.match(XplorMRParser.Coefficients)
                self.state = 1826
                self.number_s()
                self.state = 1827
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1829
                self.match(XplorMRParser.ForceConstant)
                self.state = 1831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1830
                    self.match(XplorMRParser.Equ_op)


                self.state = 1833
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1834
                self.match(XplorMRParser.Nrestraints)
                self.state = 1836
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1835
                    self.match(XplorMRParser.Equ_op)


                self.state = 1838
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1839
                self.match(XplorMRParser.Print)
                self.state = 1840
                self.match(XplorMRParser.Threshold)
                self.state = 1841
                self.number_s()
                self.state = 1844
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1842
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1843
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1846
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1847
                self.match(XplorMRParser.Save)
                self.state = 1848
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1849
                self.match(XplorMRParser.Fmed)
                self.state = 1850
                self.number_s()
                self.state = 1851
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1853
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1854
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1855
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1856
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1857
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1858
                self.match(XplorMRParser.Soff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 18)
                self.state = 1859
                self.match(XplorMRParser.Frun)
                self.state = 1860
                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 = 1863
            self.match(XplorMRParser.Assign)
            self.state = 1864
            self.selection()
            self.state = 1865
            self.selection()
            self.state = 1866
            self.selection()
            self.state = 1867
            self.selection()
            self.state = 1868
            self.selection()
            self.state = 1869
            self.number()
            self.state = 1871
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.state = 1870
                self.number()


            self.state = 1874
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1873
                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 = 1907
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1876
                self.prdc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1877
                self.classification()
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1878
                self.match(XplorMRParser.Tolerance)
                self.state = 1879
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1880
                self.match(XplorMRParser.Coefficients)
                self.state = 1881
                self.number_s()
                self.state = 1882
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1884
                self.match(XplorMRParser.ForceConstant)
                self.state = 1886
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1885
                    self.match(XplorMRParser.Equ_op)


                self.state = 1888
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1889
                self.match(XplorMRParser.Nrestraints)
                self.state = 1891
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1890
                    self.match(XplorMRParser.Equ_op)


                self.state = 1893
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1894
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1895
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1896
                self.match(XplorMRParser.Fmed)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1897
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1898
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1899
                self.match(XplorMRParser.Frun)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1900
                self.match(XplorMRParser.Print)
                self.state = 1901
                self.match(XplorMRParser.Threshold)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1902
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1903
                self.match(XplorMRParser.Save)
                self.state = 1904
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1905
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1906
                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 = 1909
            self.match(XplorMRParser.Assign)
            self.state = 1910
            self.selection()
            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.number()
            self.state = 1918
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1917
                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 = 1936
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1920
                self.porientation_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1921
                self.classification()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1922
                self.match(XplorMRParser.ForceConstant)
                self.state = 1924
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1923
                    self.match(XplorMRParser.Equ_op)


                self.state = 1926
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1927
                self.match(XplorMRParser.Nrestraints)
                self.state = 1929
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1928
                    self.match(XplorMRParser.Equ_op)


                self.state = 1931
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1932
                self.match(XplorMRParser.Print)
                self.state = 1933
                self.match(XplorMRParser.Threshold)
                self.state = 1934
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1935
                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 = 1938
            self.match(XplorMRParser.Assign)
            self.state = 1939
            self.selection()
            self.state = 1940
            self.selection()
            self.state = 1941
            self.number()
            self.state = 1942
            self.number()
            self.state = 1943
            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 = 1967
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1945
                self.pccr_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1946
                self.classification()
                pass
            elif token in [XplorMRParser.Weip]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1947
                self.match(XplorMRParser.Weip)
                self.state = 1948
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1949
                self.match(XplorMRParser.Coefficients)
                self.state = 1950
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1951
                self.match(XplorMRParser.ForceConstant)
                self.state = 1953
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1952
                    self.match(XplorMRParser.Equ_op)


                self.state = 1955
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1956
                self.match(XplorMRParser.Nrestraints)
                self.state = 1958
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1957
                    self.match(XplorMRParser.Equ_op)


                self.state = 1960
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1961
                self.match(XplorMRParser.Print)
                self.state = 1962
                self.match(XplorMRParser.Threshold)
                self.state = 1963
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1964
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1965
                self.match(XplorMRParser.Frun)
                self.state = 1966
                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 = 1969
            self.match(XplorMRParser.Assign)
            self.state = 1970
            self.selection()
            self.state = 1971
            self.selection()
            self.state = 1972
            self.selection()
            self.state = 1973
            self.number()
            self.state = 1975
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 0):
                self.state = 1974
                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 = 1994
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1977
                self.hbond_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1978
                self.hbond_assign_loop()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1979
                self.classification()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1980
                self.match(XplorMRParser.ForceConstant)
                self.state = 1982
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1981
                    self.match(XplorMRParser.Equ_op)


                self.state = 1984
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1985
                self.match(XplorMRParser.Nrestraints)
                self.state = 1987
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1986
                    self.match(XplorMRParser.Equ_op)


                self.state = 1989
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1990
                self.match(XplorMRParser.Print)
                self.state = 1991
                self.match(XplorMRParser.Threshold)
                self.state = 1992
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1993
                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 = 1996
            self.match(XplorMRParser.Assign)
            self.state = 1997
            self.selection()
            self.state = 1998
            self.selection()
            self.state = 1999
            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 = 2068
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2001
                self.hbond_db_assign()
                pass
            elif token in [XplorMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2002
                self.hbond_db_assign_loop()
                pass
            elif token in [XplorMRParser.Kdir]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2003
                self.match(XplorMRParser.Kdir)
                self.state = 2005
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2004
                    self.match(XplorMRParser.Equ_op)


                self.state = 2007
                self.number_s()
                pass
            elif token in [XplorMRParser.Klin]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2008
                self.match(XplorMRParser.Klin)
                self.state = 2010
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2009
                    self.match(XplorMRParser.Equ_op)


                self.state = 2012
                self.number_s()
                pass
            elif token in [XplorMRParser.Nseg]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2013
                self.match(XplorMRParser.Nseg)
                self.state = 2015
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2014
                    self.match(XplorMRParser.Equ_op)


                self.state = 2017
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Nmin]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2018
                self.match(XplorMRParser.Nmin)
                self.state = 2020
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2019
                    self.match(XplorMRParser.Equ_op)


                self.state = 2022
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Nmax]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2023
                self.match(XplorMRParser.Nmax)
                self.state = 2025
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2024
                    self.match(XplorMRParser.Equ_op)


                self.state = 2027
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Segm]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2028
                self.match(XplorMRParser.Segm)
                self.state = 2030
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2029
                    self.match(XplorMRParser.Equ_op)


                self.state = 2032
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Ohcut]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2033
                self.match(XplorMRParser.Ohcut)
                self.state = 2035
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2034
                    self.match(XplorMRParser.Equ_op)


                self.state = 2037
                self.number_s()
                pass
            elif token in [XplorMRParser.Coh1cut]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2038
                self.match(XplorMRParser.Coh1cut)
                self.state = 2040
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2039
                    self.match(XplorMRParser.Equ_op)


                self.state = 2042
                self.number_s()
                pass
            elif token in [XplorMRParser.Coh2cut]:
                self.enterOuterAlt(localctx, 11)
                self.state = 2043
                self.match(XplorMRParser.Coh2cut)
                self.state = 2045
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2044
                    self.match(XplorMRParser.Equ_op)


                self.state = 2047
                self.number_s()
                pass
            elif token in [XplorMRParser.Ohncut]:
                self.enterOuterAlt(localctx, 12)
                self.state = 2048
                self.match(XplorMRParser.Ohncut)
                self.state = 2050
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2049
                    self.match(XplorMRParser.Equ_op)


                self.state = 2052
                self.number_s()
                pass
            elif token in [XplorMRParser.Updfrq]:
                self.enterOuterAlt(localctx, 13)
                self.state = 2053
                self.match(XplorMRParser.Updfrq)
                self.state = 2055
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2054
                    self.match(XplorMRParser.Equ_op)


                self.state = 2057
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Prnfrq]:
                self.enterOuterAlt(localctx, 14)
                self.state = 2058
                self.match(XplorMRParser.Prnfrq)
                self.state = 2060
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2059
                    self.match(XplorMRParser.Equ_op)


                self.state = 2062
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Freemode]:
                self.enterOuterAlt(localctx, 15)
                self.state = 2063
                self.match(XplorMRParser.Freemode)
                self.state = 2065
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2064
                    self.match(XplorMRParser.Equ_op)


                self.state = 2067
                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 = 2070
            self.match(XplorMRParser.Assign)
            self.state = 2071
            self.selection()
            self.state = 2072
            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 = 2074
            self.match(XplorMRParser.Ncs)
            self.state = 2075
            self.match(XplorMRParser.Restraints)
            self.state = 2079
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Print_any) | (1 << XplorMRParser.Group) | (1 << XplorMRParser.Initialize))) != 0):
                self.state = 2076
                self.ncs_statement()
                self.state = 2081
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2082
            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 = 2094
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Group]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2084
                self.match(XplorMRParser.Group)
                self.state = 2088
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Weight or _la==XplorMRParser.Equivalence or _la==XplorMRParser.Sigb:
                    self.state = 2085
                    self.ncs_group_statement()
                    self.state = 2090
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2091
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Initialize]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2092
                self.match(XplorMRParser.Initialize)
                pass
            elif token in [XplorMRParser.Print_any]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2093
                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 = 2111
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Equivalence]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2096
                self.match(XplorMRParser.Equivalence)
                self.state = 2098
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2097
                    self.match(XplorMRParser.Equ_op)


                self.state = 2100
                self.selection()
                pass
            elif token in [XplorMRParser.Sigb]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2101
                self.match(XplorMRParser.Sigb)
                self.state = 2103
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2102
                    self.match(XplorMRParser.Equ_op)


                self.state = 2105
                self.number_s()
                pass
            elif token in [XplorMRParser.Weight]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2106
                self.match(XplorMRParser.Weight)
                self.state = 2108
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2107
                    self.match(XplorMRParser.Equ_op)


                self.state = 2110
                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 = 2113
            self.match(XplorMRParser.L_paren)
            self.state = 2114
            self.selection_expression()
            self.state = 2115
            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 = 2117
            self.term()
            self.state = 2122
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 2118
                self.match(XplorMRParser.Or_op)
                self.state = 2119
                self.term()
                self.state = 2124
                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 = 2125
            self.factor(0)
            self.state = 2130
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.And_op:
                self.state = 2126
                self.match(XplorMRParser.And_op)
                self.state = 2127
                self.factor(0)
                self.state = 2132
                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 = 2272
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.state = 2134
                self.match(XplorMRParser.L_paren)
                self.state = 2135
                self.selection_expression()
                self.state = 2136
                self.match(XplorMRParser.R_paren)
                pass

            elif la_ == 2:
                self.state = 2138
                self.match(XplorMRParser.All)
                pass

            elif la_ == 3:
                self.state = 2139
                self.match(XplorMRParser.Atom)
                self.state = 2140
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Simple_name or _la==XplorMRParser.Simple_names):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2141
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Integers):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2142
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Simple_name or _la==XplorMRParser.Simple_names):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                self.state = 2143
                self.match(XplorMRParser.Attribute)
                self.state = 2145
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Abs:
                    self.state = 2144
                    self.match(XplorMRParser.Abs)


                self.state = 2147
                self.match(XplorMRParser.Attr_properties)
                self.state = 2148
                self.match(XplorMRParser.Comparison_ops)
                self.state = 2149
                self.number_f()
                pass

            elif la_ == 5:
                self.state = 2150
                self.match(XplorMRParser.BondedTo)
                self.state = 2151
                self.factor(29)
                pass

            elif la_ == 6:
                self.state = 2152
                self.match(XplorMRParser.ByGroup)
                self.state = 2153
                self.factor(28)
                pass

            elif la_ == 7:
                self.state = 2154
                self.match(XplorMRParser.ByRes)
                self.state = 2155
                self.factor(27)
                pass

            elif la_ == 8:
                self.state = 2156
                self.match(XplorMRParser.Chemical)
                self.state = 2164
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 2157
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 2158
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2161
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,234,self._ctx)
                    if la_ == 1:
                        self.state = 2159
                        self.match(XplorMRParser.Colon)
                        self.state = 2160
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Symbol_name]:
                    self.state = 2163
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                self.state = 2166
                self.match(XplorMRParser.Hydrogen)
                pass

            elif la_ == 10:
                self.state = 2167
                self.match(XplorMRParser.Id)
                self.state = 2168
                self.match(XplorMRParser.Integer)
                pass

            elif la_ == 11:
                self.state = 2169
                self.match(XplorMRParser.Known)
                pass

            elif la_ == 12:
                self.state = 2170
                self.match(XplorMRParser.Name)
                self.state = 2183
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 2171
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 2172
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2175
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
                    if la_ == 1:
                        self.state = 2173
                        self.match(XplorMRParser.Colon)
                        self.state = 2174
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Double_quote_string]:
                    self.state = 2177
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 2180
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,237,self._ctx)
                    if la_ == 1:
                        self.state = 2178
                        self.match(XplorMRParser.Colon)
                        self.state = 2179
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                elif token in [XplorMRParser.Symbol_name]:
                    self.state = 2182
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 13:
                self.state = 2185
                self.match(XplorMRParser.Not_op)
                self.state = 2186
                self.factor(21)
                pass

            elif la_ == 14:
                self.state = 2187
                self.match(XplorMRParser.Point)
                self.state = 2188
                self.match(XplorMRParser.L_paren)
                self.state = 2189
                self.number_f()
                self.state = 2191
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 2190
                    self.match(XplorMRParser.Comma)


                self.state = 2193
                self.number_f()
                self.state = 2195
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 2194
                    self.match(XplorMRParser.Comma)


                self.state = 2197
                self.number_f()
                self.state = 2198
                self.match(XplorMRParser.R_paren)
                self.state = 2199
                self.match(XplorMRParser.Cut)
                self.state = 2200
                self.number_f()
                pass

            elif la_ == 15:
                self.state = 2202
                self.match(XplorMRParser.Point)
                self.state = 2203
                self.match(XplorMRParser.L_paren)
                self.state = 2204
                self.match(XplorMRParser.Tail)
                self.state = 2206
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 2205
                    self.match(XplorMRParser.Equ_op)


                self.state = 2208
                self.selection()
                self.state = 2210
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 2209
                    self.match(XplorMRParser.Comma)


                self.state = 2217
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Head:
                    self.state = 2212
                    self.match(XplorMRParser.Head)
                    self.state = 2214
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==XplorMRParser.Equ_op:
                        self.state = 2213
                        self.match(XplorMRParser.Equ_op)


                    self.state = 2216
                    self.selection()


                self.state = 2219
                self.match(XplorMRParser.R_paren)
                self.state = 2220
                self.match(XplorMRParser.Cut)
                self.state = 2221
                self.number_f()
                pass

            elif la_ == 16:
                self.state = 2223
                self.match(XplorMRParser.Previous)
                pass

            elif la_ == 17:
                self.state = 2224
                self.match(XplorMRParser.Pseudo)
                pass

            elif la_ == 18:
                self.state = 2225
                self.match(XplorMRParser.Residue)
                self.state = 2233
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Integers]:
                    self.state = 2226
                    self.match(XplorMRParser.Integers)
                    pass
                elif token in [XplorMRParser.Integer]:
                    self.state = 2227
                    self.match(XplorMRParser.Integer)
                    self.state = 2230
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
                    if la_ == 1:
                        self.state = 2228
                        self.match(XplorMRParser.Colon)
                        self.state = 2229
                        self.match(XplorMRParser.Integer)


                    pass
                elif token in [XplorMRParser.Symbol_name]:
                    self.state = 2232
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 19:
                self.state = 2235
                self.match(XplorMRParser.Resname)
                self.state = 2243
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 2236
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 2237
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2240
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,247,self._ctx)
                    if la_ == 1:
                        self.state = 2238
                        self.match(XplorMRParser.Colon)
                        self.state = 2239
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Symbol_name]:
                    self.state = 2242
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 20:
                self.state = 2245
                self.match(XplorMRParser.SegIdentifier)
                self.state = 2258
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 2246
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 2247
                    self.match(XplorMRParser.Simple_name)
                    self.state = 2250
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,249,self._ctx)
                    if la_ == 1:
                        self.state = 2248
                        self.match(XplorMRParser.Colon)
                        self.state = 2249
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Double_quote_string]:
                    self.state = 2252
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 2255
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,250,self._ctx)
                    if la_ == 1:
                        self.state = 2253
                        self.match(XplorMRParser.Colon)
                        self.state = 2254
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                elif token in [XplorMRParser.Symbol_name]:
                    self.state = 2257
                    self.match(XplorMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 21:
                self.state = 2260
                self.match(XplorMRParser.Store1)
                pass

            elif la_ == 22:
                self.state = 2261
                self.match(XplorMRParser.Store2)
                pass

            elif la_ == 23:
                self.state = 2262
                self.match(XplorMRParser.Store3)
                pass

            elif la_ == 24:
                self.state = 2263
                self.match(XplorMRParser.Store4)
                pass

            elif la_ == 25:
                self.state = 2264
                self.match(XplorMRParser.Store5)
                pass

            elif la_ == 26:
                self.state = 2265
                self.match(XplorMRParser.Store6)
                pass

            elif la_ == 27:
                self.state = 2266
                self.match(XplorMRParser.Store7)
                pass

            elif la_ == 28:
                self.state = 2267
                self.match(XplorMRParser.Store8)
                pass

            elif la_ == 29:
                self.state = 2268
                self.match(XplorMRParser.Store9)
                pass

            elif la_ == 30:
                self.state = 2269
                self.match(XplorMRParser.Tag)
                pass

            elif la_ == 31:
                self.state = 2270
                self.match(XplorMRParser.Donor)
                pass

            elif la_ == 32:
                self.state = 2271
                self.match(XplorMRParser.Acceptor)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 2282
            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 = 2280
                    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 = 2274
                        if not self.precpred(self._ctx, 32):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 32)")
                        self.state = 2275
                        self.match(XplorMRParser.Around)
                        self.state = 2276
                        self.number_f()
                        pass

                    elif la_ == 2:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 2277
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 2278
                        self.match(XplorMRParser.Saround)
                        self.state = 2279
                        self.number_f()
                        pass

             
                self.state = 2284
                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 = 2285
            _la = self._input.LA(1)
            if not(((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 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 = 2287
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                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 = 2289
            _la = self._input.LA(1)
            if not(((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (XplorMRParser.Integer - 192)) | (1 << (XplorMRParser.Real - 192)) | (1 << (XplorMRParser.Symbol_name - 192)))) != 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 = 2291
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                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 = 2293
            self.match(XplorMRParser.Classification)
            self.state = 2295
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Equ_op:
                self.state = 2294
                self.match(XplorMRParser.Equ_op)


            self.state = 2297
            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 = 2299
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Noe) | (1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Dihedral))) != 0) or _la==XplorMRParser.AngleDb or ((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (XplorMRParser.HBonded - 177)) | (1 << (XplorMRParser.Improper - 177)) | (1 << (XplorMRParser.Simple_name - 177)))) != 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 = 2301
            self.match(XplorMRParser.Flags)
            self.state = 2312
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Exclude:
                self.state = 2302
                self.match(XplorMRParser.Exclude)
                self.state = 2310
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Include, XplorMRParser.Class_name]:
                    self.state = 2306
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==XplorMRParser.Class_name:
                        self.state = 2303
                        self.match(XplorMRParser.Class_name)
                        self.state = 2308
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [XplorMRParser.Any_class]:
                    self.state = 2309
                    self.match(XplorMRParser.Any_class)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 2314
            self.match(XplorMRParser.Include)
            self.state = 2318
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Class_name:
                self.state = 2315
                self.match(XplorMRParser.Class_name)
                self.state = 2320
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2321
            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 = 2323
            self.match(XplorMRParser.Vector)
            self.state = 2324
            self.vector_mode()
            self.state = 2325
            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 = 2333
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Do_Lp, XplorMRParser.Identity_Lp]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2327
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Do_Lp or _la==XplorMRParser.Identity_Lp):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2328
                self.vector_expression()
                self.state = 2329
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Show]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2331
                self.match(XplorMRParser.Show)
                self.state = 2332
                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 = 2335
            self.match(XplorMRParser.Atom_properties_VE)
            self.state = 2338
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Equ_op_VE:
                self.state = 2336
                self.match(XplorMRParser.Equ_op_VE)
                self.state = 2337
                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 = 2340
            self.vflc()
            self.state = 2343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 244)) & ~0x3f) == 0 and ((1 << (_la - 244)) & ((1 << (XplorMRParser.Add_op_VE - 244)) | (1 << (XplorMRParser.Sub_op_VE - 244)) | (1 << (XplorMRParser.Mul_op_VE - 244)) | (1 << (XplorMRParser.Div_op_VE - 244)) | (1 << (XplorMRParser.Exp_op_VE - 244)))) != 0):
                self.state = 2341
                _la = self._input.LA(1)
                if not(((((_la - 244)) & ~0x3f) == 0 and ((1 << (_la - 244)) & ((1 << (XplorMRParser.Add_op_VE - 244)) | (1 << (XplorMRParser.Sub_op_VE - 244)) | (1 << (XplorMRParser.Mul_op_VE - 244)) | (1 << (XplorMRParser.Div_op_VE - 244)) | (1 << (XplorMRParser.Exp_op_VE - 244)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2342
                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 = 2352
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Atom_properties_VE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2345
                self.match(XplorMRParser.Atom_properties_VE)
                pass
            elif token in [XplorMRParser.Abs_VE, XplorMRParser.Acos_VE, XplorMRParser.Cos_VE, XplorMRParser.Decode_VE, XplorMRParser.Encode_VE, XplorMRParser.Exp_VE, XplorMRParser.Gauss_VE, XplorMRParser.Heavy_VE, XplorMRParser.Int_VE, XplorMRParser.Log10_VE, XplorMRParser.Log_VE, XplorMRParser.Max_VE, XplorMRParser.Maxw_VE, XplorMRParser.Min_VE, XplorMRParser.Mod_VE, XplorMRParser.Norm_VE, XplorMRParser.Random_VE, XplorMRParser.Sign_VE, XplorMRParser.Sin_VE, XplorMRParser.Sqrt_VE, XplorMRParser.Tan_VE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2346
                self.vector_func_call()
                pass
            elif token in [XplorMRParser.Integer_VE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2347
                self.match(XplorMRParser.Integer_VE)
                pass
            elif token in [XplorMRParser.Real_VE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2348
                self.match(XplorMRParser.Real_VE)
                pass
            elif token in [XplorMRParser.Simple_name_VE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2349
                self.match(XplorMRParser.Simple_name_VE)
                pass
            elif token in [XplorMRParser.Symbol_name_VE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2350
                self.match(XplorMRParser.Symbol_name_VE)
                pass
            elif token in [XplorMRParser.Double_quote_string_VE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2351
                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 = 2473
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Abs_VE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2354
                self.match(XplorMRParser.Abs_VE)
                self.state = 2355
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2356
                self.vflc()
                self.state = 2357
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Acos_VE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2359
                self.match(XplorMRParser.Acos_VE)
                self.state = 2360
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2361
                self.vflc()
                self.state = 2362
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Cos_VE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2364
                self.match(XplorMRParser.Cos_VE)
                self.state = 2365
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2366
                self.vflc()
                self.state = 2367
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Decode_VE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2369
                self.match(XplorMRParser.Decode_VE)
                self.state = 2370
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2371
                self.vflc()
                self.state = 2372
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Encode_VE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2374
                self.match(XplorMRParser.Encode_VE)
                self.state = 2375
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2376
                self.vflc()
                self.state = 2377
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Exp_VE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2379
                self.match(XplorMRParser.Exp_VE)
                self.state = 2380
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2381
                self.vflc()
                self.state = 2382
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Gauss_VE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2384
                self.match(XplorMRParser.Gauss_VE)
                self.state = 2385
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2386
                self.vflc()
                self.state = 2387
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Heavy_VE]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2389
                self.match(XplorMRParser.Heavy_VE)
                self.state = 2390
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2391
                self.vflc()
                self.state = 2392
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Int_VE]:
                self.enterOuterAlt(localctx, 9)
                self.state = 2394
                self.match(XplorMRParser.Int_VE)
                self.state = 2395
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2396
                self.vflc()
                self.state = 2397
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Log10_VE]:
                self.enterOuterAlt(localctx, 10)
                self.state = 2399
                self.match(XplorMRParser.Log10_VE)
                self.state = 2400
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2401
                self.vflc()
                self.state = 2402
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Log_VE]:
                self.enterOuterAlt(localctx, 11)
                self.state = 2404
                self.match(XplorMRParser.Log_VE)
                self.state = 2405
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2406
                self.vflc()
                self.state = 2407
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Max_VE]:
                self.enterOuterAlt(localctx, 12)
                self.state = 2409
                self.match(XplorMRParser.Max_VE)
                self.state = 2410
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2411
                self.vflc()
                self.state = 2416
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Comma_VE:
                    self.state = 2412
                    self.match(XplorMRParser.Comma_VE)
                    self.state = 2413
                    self.vflc()
                    self.state = 2418
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2419
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Maxw_VE]:
                self.enterOuterAlt(localctx, 13)
                self.state = 2421
                self.match(XplorMRParser.Maxw_VE)
                self.state = 2422
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2423
                self.vflc()
                self.state = 2424
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Min_VE]:
                self.enterOuterAlt(localctx, 14)
                self.state = 2426
                self.match(XplorMRParser.Min_VE)
                self.state = 2427
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2428
                self.vflc()
                self.state = 2433
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Comma_VE:
                    self.state = 2429
                    self.match(XplorMRParser.Comma_VE)
                    self.state = 2430
                    self.vflc()
                    self.state = 2435
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2436
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Mod_VE]:
                self.enterOuterAlt(localctx, 15)
                self.state = 2438
                self.match(XplorMRParser.Mod_VE)
                self.state = 2439
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2440
                self.vflc()
                self.state = 2441
                self.match(XplorMRParser.Comma_VE)
                self.state = 2442
                self.vflc()
                self.state = 2443
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Norm_VE]:
                self.enterOuterAlt(localctx, 16)
                self.state = 2445
                self.match(XplorMRParser.Norm_VE)
                self.state = 2446
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2447
                self.vflc()
                self.state = 2448
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Random_VE]:
                self.enterOuterAlt(localctx, 17)
                self.state = 2450
                self.match(XplorMRParser.Random_VE)
                self.state = 2451
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2452
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Sign_VE]:
                self.enterOuterAlt(localctx, 18)
                self.state = 2453
                self.match(XplorMRParser.Sign_VE)
                self.state = 2454
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2455
                self.vflc()
                self.state = 2456
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Sin_VE]:
                self.enterOuterAlt(localctx, 19)
                self.state = 2458
                self.match(XplorMRParser.Sin_VE)
                self.state = 2459
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2460
                self.vflc()
                self.state = 2461
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Sqrt_VE]:
                self.enterOuterAlt(localctx, 20)
                self.state = 2463
                self.match(XplorMRParser.Sqrt_VE)
                self.state = 2464
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2465
                self.vflc()
                self.state = 2466
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Tan_VE]:
                self.enterOuterAlt(localctx, 21)
                self.state = 2468
                self.match(XplorMRParser.Tan_VE)
                self.state = 2469
                self.match(XplorMRParser.L_paren_VF)
                self.state = 2470
                self.vflc()
                self.state = 2471
                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 = 2475
            _la = self._input.LA(1)
            if not(((((_la - 283)) & ~0x3f) == 0 and ((1 << (_la - 283)) & ((1 << (XplorMRParser.Average_VS - 283)) | (1 << (XplorMRParser.Element_VS - 283)) | (1 << (XplorMRParser.Max_VS - 283)) | (1 << (XplorMRParser.Min_VS - 283)) | (1 << (XplorMRParser.Norm_VS - 283)) | (1 << (XplorMRParser.Rms_VS - 283)) | (1 << (XplorMRParser.Sum_VS - 283)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2476
            self.match(XplorMRParser.L_paren_VS)
            self.state = 2477
            self.match(XplorMRParser.Atom_properties_VS)
            self.state = 2478
            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 = 2480
            self.match(XplorMRParser.Evaluate_Lp)
            self.state = 2481
            self.match(XplorMRParser.Symbol_name_VE)
            self.state = 2482
            self.match(XplorMRParser.Equ_op_VE)
            self.state = 2483
            self.evaluate_operation()
            self.state = 2484
            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 = 2486
            self.vflc()
            self.state = 2489
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 244)) & ~0x3f) == 0 and ((1 << (_la - 244)) & ((1 << (XplorMRParser.Add_op_VE - 244)) | (1 << (XplorMRParser.Sub_op_VE - 244)) | (1 << (XplorMRParser.Mul_op_VE - 244)) | (1 << (XplorMRParser.Div_op_VE - 244)) | (1 << (XplorMRParser.Exp_op_VE - 244)))) != 0):
                self.state = 2487
                _la = self._input.LA(1)
                if not(((((_la - 244)) & ~0x3f) == 0 and ((1 << (_la - 244)) & ((1 << (XplorMRParser.Add_op_VE - 244)) | (1 << (XplorMRParser.Sub_op_VE - 244)) | (1 << (XplorMRParser.Mul_op_VE - 244)) | (1 << (XplorMRParser.Div_op_VE - 244)) | (1 << (XplorMRParser.Exp_op_VE - 244)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2488
                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 = 2491
            self.match(XplorMRParser.Patch)
            self.state = 2493
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Noe) | (1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Dihedral))) != 0) or _la==XplorMRParser.AngleDb or ((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (XplorMRParser.HBonded - 177)) | (1 << (XplorMRParser.Improper - 177)) | (1 << (XplorMRParser.Simple_name - 177)))) != 0):
                self.state = 2492
                self.class_name()


            self.state = 2495
            self.match(XplorMRParser.Reference)
            self.state = 2496
            self.match(XplorMRParser.Equ_op)
            self.state = 2497
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Nil or _la==XplorMRParser.Integer):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2498
            self.match(XplorMRParser.Equ_op)
            self.state = 2499
            self.selection()
            self.state = 2505
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Reference:
                self.state = 2500
                self.match(XplorMRParser.Reference)
                self.state = 2501
                self.match(XplorMRParser.Equ_op)
                self.state = 2502
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Nil or _la==XplorMRParser.Integer):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2503
                self.match(XplorMRParser.Equ_op)
                self.state = 2504
                self.selection()


            self.state = 2507
            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 = 2509
            self.match(XplorMRParser.Parameter)
            self.state = 2513
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Reset or _la==XplorMRParser.Dihedral or _la==XplorMRParser.AngleDb or _la==XplorMRParser.BondedTo or ((((_la - 177)) & ~0x3f) == 0 and ((1 << (_la - 177)) & ((1 << (XplorMRParser.HBonded - 177)) | (1 << (XplorMRParser.Improper - 177)) | (1 << (XplorMRParser.NBFix - 177)) | (1 << (XplorMRParser.NonB - 177)) | (1 << (XplorMRParser.VDWOff - 177)) | (1 << (XplorMRParser.Verbose - 177)))) != 0):
                self.state = 2510
                self.parameter_statement()
                self.state = 2515
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2516
            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 = 2573
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.AngleDb]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2518
                self.match(XplorMRParser.AngleDb)
                self.state = 2519
                self.match(XplorMRParser.Simple_name)
                self.state = 2520
                self.match(XplorMRParser.Simple_name)
                self.state = 2521
                self.match(XplorMRParser.Simple_name)
                self.state = 2522
                self.number_s()
                self.state = 2523
                self.number_s()
                self.state = 2528
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.UB:
                    self.state = 2524
                    self.match(XplorMRParser.UB)
                    self.state = 2525
                    self.number_s()
                    self.state = 2526
                    self.number_s()


                pass
            elif token in [XplorMRParser.BondedTo]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2530
                self.match(XplorMRParser.BondedTo)
                self.state = 2531
                self.match(XplorMRParser.Simple_name)
                self.state = 2532
                self.match(XplorMRParser.Simple_name)
                self.state = 2533
                self.number_s()
                self.state = 2534
                self.number_s()
                pass
            elif token in [XplorMRParser.Dihedral, XplorMRParser.Improper]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2536
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Dihedral or _la==XplorMRParser.Improper):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2537
                self.match(XplorMRParser.Simple_name)
                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 = 2543
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Mult:
                    self.state = 2541
                    self.match(XplorMRParser.Mult)
                    self.state = 2542
                    self.match(XplorMRParser.Integer)


                self.state = 2545
                self.number_s()
                self.state = 2546
                self.match(XplorMRParser.Integer)
                self.state = 2547
                self.number_s()
                pass
            elif token in [XplorMRParser.HBonded]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2549
                self.match(XplorMRParser.HBonded)
                self.state = 2550
                self.match(XplorMRParser.Simple_names)
                self.state = 2551
                self.match(XplorMRParser.Simple_names)
                self.state = 2552
                self.number_s()
                self.state = 2553
                self.number_s()
                pass
            elif token in [XplorMRParser.NBFix]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2555
                self.match(XplorMRParser.NBFix)
                self.state = 2556
                self.match(XplorMRParser.Simple_name)
                self.state = 2557
                self.match(XplorMRParser.Simple_name)
                self.state = 2558
                self.number_s()
                self.state = 2559
                self.number_s()
                self.state = 2560
                self.number_s()
                self.state = 2561
                self.number_s()
                pass
            elif token in [XplorMRParser.NonB]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2563
                self.match(XplorMRParser.NonB)
                self.state = 2564
                self.match(XplorMRParser.Simple_name)
                self.state = 2565
                self.number_s()
                self.state = 2566
                self.number_s()
                self.state = 2567
                self.number_s()
                self.state = 2568
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset, XplorMRParser.VDWOff]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2570
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Reset or _la==XplorMRParser.VDWOff):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 2571
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Verbose]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2572
                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 = 2575
            self.match(XplorMRParser.For)
            self.state = 2576
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2577
            self.match(XplorMRParser.In_CF)
            self.state = 2578
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
            if la_ == 1:
                self.state = 2582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2579
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2584
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2588
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2585
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2590
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2594
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2591
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2596
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2599
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2600
            self.match(XplorMRParser.Loop)
            self.state = 2601
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2607
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Noe or _la==XplorMRParser.Assign or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2605
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2602
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2603
                    self.noe_assign()
                    pass
                elif token in [XplorMRParser.Noe]:
                    self.state = 2604
                    self.distance_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2610
            self.match(XplorMRParser.End)
            self.state = 2611
            self.match(XplorMRParser.Loop)
            self.state = 2612
            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 = 2614
            self.match(XplorMRParser.For)
            self.state = 2615
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2616
            self.match(XplorMRParser.In_CF)
            self.state = 2617
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2636
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,283,self._ctx)
            if la_ == 1:
                self.state = 2621
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2618
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2623
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2627
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2624
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2629
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2633
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2630
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2635
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2638
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2639
            self.match(XplorMRParser.Loop)
            self.state = 2640
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2646
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Dihedral))) != 0) or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2644
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2641
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2642
                    self.dihedral_assign()
                    pass
                elif token in [XplorMRParser.Restraints, XplorMRParser.Dihedral]:
                    self.state = 2643
                    self.dihedral_angle_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2649
            self.match(XplorMRParser.End)
            self.state = 2650
            self.match(XplorMRParser.Loop)
            self.state = 2651
            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 = 2653
            self.match(XplorMRParser.For)
            self.state = 2654
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2655
            self.match(XplorMRParser.In_CF)
            self.state = 2656
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2675
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
            if la_ == 1:
                self.state = 2660
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2657
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2662
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2666
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2663
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2668
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2672
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2669
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2674
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2677
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2678
            self.match(XplorMRParser.Loop)
            self.state = 2679
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2685
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Sanisotropy) | (1 << XplorMRParser.Xdipolar) | (1 << XplorMRParser.Dipolar) | (1 << XplorMRParser.VeAngle) | (1 << XplorMRParser.Tensor) | (1 << XplorMRParser.Anisotropy))) != 0) or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2683
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2680
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2681
                    self.sani_assign()
                    pass
                elif token in [XplorMRParser.Sanisotropy, XplorMRParser.Xdipolar, XplorMRParser.Dipolar, XplorMRParser.VeAngle, XplorMRParser.Tensor, XplorMRParser.Anisotropy]:
                    self.state = 2682
                    self.rdc_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2688
            self.match(XplorMRParser.End)
            self.state = 2689
            self.match(XplorMRParser.Loop)
            self.state = 2690
            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 = 2692
            self.match(XplorMRParser.For)
            self.state = 2693
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2694
            self.match(XplorMRParser.In_CF)
            self.state = 2695
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2714
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
            if la_ == 1:
                self.state = 2699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2696
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2701
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2705
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2702
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2707
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2708
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2713
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2716
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2717
            self.match(XplorMRParser.Loop)
            self.state = 2718
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2724
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Xadc or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2722
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2719
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2720
                    self.xadc_assign()
                    pass
                elif token in [XplorMRParser.Xadc]:
                    self.state = 2721
                    self.antidistance_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2727
            self.match(XplorMRParser.End)
            self.state = 2728
            self.match(XplorMRParser.Loop)
            self.state = 2729
            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 = 2731
            self.match(XplorMRParser.For)
            self.state = 2732
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2733
            self.match(XplorMRParser.In_CF)
            self.state = 2734
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2753
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,301,self._ctx)
            if la_ == 1:
                self.state = 2738
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2735
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2740
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2744
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2741
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2746
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2750
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2747
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2752
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2755
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2756
            self.match(XplorMRParser.Loop)
            self.state = 2757
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2763
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Coupling or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2761
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2758
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2759
                    self.coup_assign()
                    pass
                elif token in [XplorMRParser.Coupling]:
                    self.state = 2760
                    self.coupling_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2766
            self.match(XplorMRParser.End)
            self.state = 2767
            self.match(XplorMRParser.Loop)
            self.state = 2768
            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 = 2770
            self.match(XplorMRParser.For)
            self.state = 2771
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2772
            self.match(XplorMRParser.In_CF)
            self.state = 2773
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2792
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,307,self._ctx)
            if la_ == 1:
                self.state = 2777
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2774
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2779
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2783
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2780
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2785
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2789
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2786
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2791
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2794
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2795
            self.match(XplorMRParser.Loop)
            self.state = 2796
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2802
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Collapse or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2800
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2797
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2798
                    self.coll_assign()
                    pass
                elif token in [XplorMRParser.Collapse]:
                    self.state = 2799
                    self.radius_of_gyration_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2805
            self.match(XplorMRParser.End)
            self.state = 2806
            self.match(XplorMRParser.Loop)
            self.state = 2807
            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 = 2809
            self.match(XplorMRParser.For)
            self.state = 2810
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2811
            self.match(XplorMRParser.In_CF)
            self.state = 2812
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2831
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,313,self._ctx)
            if la_ == 1:
                self.state = 2816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2813
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2818
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2822
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2819
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2824
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2828
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2825
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2830
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2833
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2834
            self.match(XplorMRParser.Loop)
            self.state = 2835
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2841
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Dcsa or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2839
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2836
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2837
                    self.csa_assign()
                    pass
                elif token in [XplorMRParser.Dcsa]:
                    self.state = 2838
                    self.csa_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2844
            self.match(XplorMRParser.End)
            self.state = 2845
            self.match(XplorMRParser.Loop)
            self.state = 2846
            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 = 2848
            self.match(XplorMRParser.For)
            self.state = 2849
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2850
            self.match(XplorMRParser.In_CF)
            self.state = 2851
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2870
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,319,self._ctx)
            if la_ == 1:
                self.state = 2855
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2852
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2857
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2861
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2858
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2863
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2867
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2864
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2869
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2872
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2873
            self.match(XplorMRParser.Loop)
            self.state = 2874
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2880
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.PMagnetic or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2878
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2875
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2876
                    self.pre_assign()
                    pass
                elif token in [XplorMRParser.PMagnetic]:
                    self.state = 2877
                    self.pre_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2883
            self.match(XplorMRParser.End)
            self.state = 2884
            self.match(XplorMRParser.Loop)
            self.state = 2885
            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 = 2887
            self.match(XplorMRParser.For)
            self.state = 2888
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2889
            self.match(XplorMRParser.In_CF)
            self.state = 2890
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2909
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,325,self._ctx)
            if la_ == 1:
                self.state = 2894
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2891
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2896
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2900
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2897
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2902
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2906
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2903
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2908
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2911
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2912
            self.match(XplorMRParser.Loop)
            self.state = 2913
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2920
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Carbon or _la==XplorMRParser.Xpcs or _la==XplorMRParser.Evaluate_Lp:
                self.state = 2918
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2914
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2915
                    self.pcs_assign()
                    pass
                elif token in [XplorMRParser.Xpcs]:
                    self.state = 2916
                    self.pcs_restraint()
                    pass
                elif token in [XplorMRParser.Carbon]:
                    self.state = 2917
                    self.carbon_shift_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2923
            self.match(XplorMRParser.End)
            self.state = 2924
            self.match(XplorMRParser.Loop)
            self.state = 2925
            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 = 2927
            self.match(XplorMRParser.For)
            self.state = 2928
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2929
            self.match(XplorMRParser.In_CF)
            self.state = 2930
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2949
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,331,self._ctx)
            if la_ == 1:
                self.state = 2934
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2931
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2936
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2940
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2937
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2942
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2946
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2943
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2948
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2951
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2952
            self.match(XplorMRParser.Loop)
            self.state = 2953
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2959
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Evaluate_Lp or _la==XplorMRParser.Hbda:
                self.state = 2957
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2954
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2955
                    self.hbond_assign()
                    pass
                elif token in [XplorMRParser.Hbda]:
                    self.state = 2956
                    self.hbond_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 2962
            self.match(XplorMRParser.End)
            self.state = 2963
            self.match(XplorMRParser.Loop)
            self.state = 2964
            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 = 2966
            self.match(XplorMRParser.For)
            self.state = 2967
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 2968
            self.match(XplorMRParser.In_CF)
            self.state = 2969
            self.match(XplorMRParser.L_paren_CF)
            self.state = 2988
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,337,self._ctx)
            if la_ == 1:
                self.state = 2973
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 2970
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 2975
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 2979
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 2976
                    self.match(XplorMRParser.Real_CF)
                    self.state = 2981
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 2985
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 2982
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 2987
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 2990
            self.match(XplorMRParser.R_paren_CF)
            self.state = 2991
            self.match(XplorMRParser.Loop)
            self.state = 2992
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 2998
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign or _la==XplorMRParser.Evaluate_Lp or _la==XplorMRParser.Hbdb:
                self.state = 2996
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 2993
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Assign]:
                    self.state = 2994
                    self.hbond_db_assign()
                    pass
                elif token in [XplorMRParser.Hbdb]:
                    self.state = 2995
                    self.hbond_db_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 3001
            self.match(XplorMRParser.End)
            self.state = 3002
            self.match(XplorMRParser.Loop)
            self.state = 3003
            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 = 3005
            self.match(XplorMRParser.For)
            self.state = 3006
            self.match(XplorMRParser.Symbol_name_CF)
            self.state = 3007
            self.match(XplorMRParser.In_CF)
            self.state = 3008
            self.match(XplorMRParser.L_paren_CF)
            self.state = 3027
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,343,self._ctx)
            if la_ == 1:
                self.state = 3012
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Integer_CF:
                    self.state = 3009
                    self.match(XplorMRParser.Integer_CF)
                    self.state = 3014
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 3018
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Real_CF:
                    self.state = 3015
                    self.match(XplorMRParser.Real_CF)
                    self.state = 3020
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 3024
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Simple_name_CF:
                    self.state = 3021
                    self.match(XplorMRParser.Simple_name_CF)
                    self.state = 3026
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 3029
            self.match(XplorMRParser.R_paren_CF)
            self.state = 3030
            self.match(XplorMRParser.Loop)
            self.state = 3031
            self.match(XplorMRParser.Simple_name_LL)
            self.state = 3037
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Planar) | (1 << XplorMRParser.Group))) != 0) or _la==XplorMRParser.Evaluate_Lp:
                self.state = 3035
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Evaluate_Lp]:
                    self.state = 3032
                    self.evaluate_statement()
                    pass
                elif token in [XplorMRParser.Group]:
                    self.state = 3033
                    self.planar_group()
                    pass
                elif token in [XplorMRParser.Restraints, XplorMRParser.Planar]:
                    self.state = 3034
                    self.planar_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 3040
            self.match(XplorMRParser.End)
            self.state = 3041
            self.match(XplorMRParser.Loop)
            self.state = 3042
            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)
         




