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

class CnsMRParser ( Parser ):

    grammarFileName = "CnsMRParser.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>", "<INVALID>", "'BHIG'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'CV'", "'DEN'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'OUTD'", "<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>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'ZERO'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'SIZE'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'ALL'", "<INVALID>", "'ATOM'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'FBOX'", "<INVALID>", 
                     "'ID'", "<INVALID>", "'NAME'", "'NONE'", "<INVALID>", 
                     "'CUT'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'SFBOX'", "'STORE1'", "'STORE2'", 
                     "'STORE3'", "'STORE4'", "'STORE5'", "'STORE6'", "'STORE7'", 
                     "'STORE8'", "'STORE9'", "'TAG'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'SHOW'", "<INVALID>", "'FOR'", "'LOOP'", 
                     "'TAIL'", "'HEAD'", "'OR'", "'AND'", "'NOT'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "':'", "<INVALID>", "'<'", "'>'", "'<='", 
                     "'>='", "'#'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'+'", "'-'", "<INVALID>", "'/'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'ACOS'", "'ASIN'", "'COS'", "'DECODE'", "'ENCODE'", 
                     "'EXP'", "'GAUSS'", "'HEAVY'", "'INT'", "'LOG10'", 
                     "'LOG'", "<INVALID>", "'MAXW'", "<INVALID>", "'MOD'", 
                     "<INVALID>", "<INVALID>", "'SIGN'", "'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", "Analysis", "Assign", 
                      "Asymptote", "Average", "Bhig", "Ceiling", "Classification", 
                      "CountViol", "Cv", "Den", "Distribute", "Ensemble", 
                      "Monomers", "Ncount", "Nrestraints", "Outd", "Partition", 
                      "Potential", "Predict", "Print", "Raverage", "Threshold", 
                      "Reset", "Rswitch", "Scale", "SoExponent", "SqConstant", 
                      "SqExponent", "SqOffset", "Taverage", "Temperature", 
                      "Initialize", "Update", "Gamma", "Kappa", "Cutoff", 
                      "Cuton", "From", "To", "Peak", "Spectrum", "Volume", 
                      "Ppm1", "Ppm2", "Restraints", "Dihedral", "Nassign", 
                      "Print_any", "Plane", "Group", "Selection", "Weight", 
                      "Harmonic", "Exponent", "Normal", "Sanisotropy", "Coefficients", 
                      "ForceConstant", "Coupling", "Carbon", "Expectation", 
                      "PhiStep", "PsiStep", "Rcoil", "Zero", "Proton", "Observed", 
                      "Anisotropy", "Amides", "Nitrogens", "Oxygens", "RingAtoms", 
                      "AlphasAndAmides", "Error", "Conformation", "Compressed", 
                      "Phase", "Size", "Dimensions", "Danisotropy", "OneBond", 
                      "AngleDb", "DerivFlag", "Angle_or_Dihedral", "Flags", 
                      "All", "Around", "Atom", "Attribute", "BondedTo", 
                      "ByGroup", "ByRes", "Chemical", "Fbox", "Hydrogen", 
                      "Id", "Known", "Name", "NONE", "Point", "Cut", "Previous", 
                      "Pseudo", "Residue", "Resname", "Saround", "SegIdentifier", 
                      "Sfbox", "Store_1", "Store_2", "Store_3", "Store_4", 
                      "Store_5", "Store_6", "Store_7", "Store_8", "Store_9", 
                      "Tag", "Vector", "Do_Lp", "Identify_Lp", "Show", "Evaluate_Lp", 
                      "For", "Loop", "Tail", "Head", "Or_op", "And_op", 
                      "Not_op", "Comma", "Complex", "Integer", "Logical", 
                      "Real", "Double_quote_string", "SHARP_COMMENT", "EXCLM_COMMENT", 
                      "SMCLN_COMMENT", "Simple_name", "Simple_names", "Integers", 
                      "L_paren", "R_paren", "Colon", "Equ_op", "Lt_op", 
                      "Gt_op", "Leq_op", "Geq_op", "Neq_op", "Symbol_name", 
                      "SPACE", "COMMENT", "SECTION_COMMENT", "LINE_COMMENT", 
                      "SET_VARIABLE", "Abs", "Attr_properties", "Comparison_ops", 
                      "SPACE_ATTR", "Averaging_methods", "Simple_name_A", 
                      "SPACE_AVER", "Equ_op_P", "Potential_types", "Simple_name_P", 
                      "SPACE_POTE", "Noe_analysis", "SPACE_ANAL", "Exclude", 
                      "Include", "End_F", "Class_name", "Any_class", "SPACE_FLAG", 
                      "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_cns_mr = 0
    RULE_distance_restraint = 1
    RULE_dihedral_angle_restraint = 2
    RULE_plane_restraint = 3
    RULE_harmonic_restraint = 4
    RULE_rdc_restraint = 5
    RULE_coupling_restraint = 6
    RULE_carbon_shift_restraint = 7
    RULE_proton_shift_restraint = 8
    RULE_conformation_db_restraint = 9
    RULE_diffusion_anisotropy_restraint = 10
    RULE_one_bond_coupling_restraint = 11
    RULE_angle_db_restraint = 12
    RULE_noe_statement = 13
    RULE_noe_assign = 14
    RULE_predict_statement = 15
    RULE_noe_annotation = 16
    RULE_dihedral_statement = 17
    RULE_dihedral_assign = 18
    RULE_plane_statement = 19
    RULE_group_statement = 20
    RULE_harmonic_statement = 21
    RULE_harmonic_assign = 22
    RULE_sani_statement = 23
    RULE_sani_assign = 24
    RULE_coupling_statement = 25
    RULE_coup_assign = 26
    RULE_carbon_shift_statement = 27
    RULE_carbon_shift_assign = 28
    RULE_carbon_shift_rcoil = 29
    RULE_proton_shift_statement = 30
    RULE_observed = 31
    RULE_proton_shift_rcoil = 32
    RULE_proton_shift_anisotropy = 33
    RULE_proton_shift_amides = 34
    RULE_proton_shift_carbons = 35
    RULE_proton_shift_nitrogens = 36
    RULE_proton_shift_oxygens = 37
    RULE_proton_shift_ring_atoms = 38
    RULE_proton_shift_alphas_and_amides = 39
    RULE_conformation_statement = 40
    RULE_conf_assign = 41
    RULE_diffusion_statement = 42
    RULE_dani_assign = 43
    RULE_one_bond_coupling_statement = 44
    RULE_one_bond_assign = 45
    RULE_angle_db_statement = 46
    RULE_angle_db_assign = 47
    RULE_selection = 48
    RULE_selection_expression = 49
    RULE_term = 50
    RULE_factor = 51
    RULE_number = 52
    RULE_number_f = 53
    RULE_number_s = 54
    RULE_number_a = 55
    RULE_flag_statement = 56
    RULE_vector_statement = 57
    RULE_vector_mode = 58
    RULE_vector_expression = 59
    RULE_vector_operation = 60
    RULE_vflc = 61
    RULE_vector_func_call = 62
    RULE_vector_show_property = 63
    RULE_evaluate_statement = 64
    RULE_evaluate_operation = 65
    RULE_noe_assign_loop = 66
    RULE_dihedral_assign_loop = 67
    RULE_sani_assign_loop = 68
    RULE_coup_assign_loop = 69
    RULE_carbon_shift_assign_loop = 70

    ruleNames =  [ "cns_mr", "distance_restraint", "dihedral_angle_restraint", 
                   "plane_restraint", "harmonic_restraint", "rdc_restraint", 
                   "coupling_restraint", "carbon_shift_restraint", "proton_shift_restraint", 
                   "conformation_db_restraint", "diffusion_anisotropy_restraint", 
                   "one_bond_coupling_restraint", "angle_db_restraint", 
                   "noe_statement", "noe_assign", "predict_statement", "noe_annotation", 
                   "dihedral_statement", "dihedral_assign", "plane_statement", 
                   "group_statement", "harmonic_statement", "harmonic_assign", 
                   "sani_statement", "sani_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", 
                   "conformation_statement", "conf_assign", "diffusion_statement", 
                   "dani_assign", "one_bond_coupling_statement", "one_bond_assign", 
                   "angle_db_statement", "angle_db_assign", "selection", 
                   "selection_expression", "term", "factor", "number", "number_f", 
                   "number_s", "number_a", "flag_statement", "vector_statement", 
                   "vector_mode", "vector_expression", "vector_operation", 
                   "vflc", "vector_func_call", "vector_show_property", "evaluate_statement", 
                   "evaluate_operation", "noe_assign_loop", "dihedral_assign_loop", 
                   "sani_assign_loop", "coup_assign_loop", "carbon_shift_assign_loop" ]

    EOF = Token.EOF
    Set=1
    End=2
    Noe=3
    Analysis=4
    Assign=5
    Asymptote=6
    Average=7
    Bhig=8
    Ceiling=9
    Classification=10
    CountViol=11
    Cv=12
    Den=13
    Distribute=14
    Ensemble=15
    Monomers=16
    Ncount=17
    Nrestraints=18
    Outd=19
    Partition=20
    Potential=21
    Predict=22
    Print=23
    Raverage=24
    Threshold=25
    Reset=26
    Rswitch=27
    Scale=28
    SoExponent=29
    SqConstant=30
    SqExponent=31
    SqOffset=32
    Taverage=33
    Temperature=34
    Initialize=35
    Update=36
    Gamma=37
    Kappa=38
    Cutoff=39
    Cuton=40
    From=41
    To=42
    Peak=43
    Spectrum=44
    Volume=45
    Ppm1=46
    Ppm2=47
    Restraints=48
    Dihedral=49
    Nassign=50
    Print_any=51
    Plane=52
    Group=53
    Selection=54
    Weight=55
    Harmonic=56
    Exponent=57
    Normal=58
    Sanisotropy=59
    Coefficients=60
    ForceConstant=61
    Coupling=62
    Carbon=63
    Expectation=64
    PhiStep=65
    PsiStep=66
    Rcoil=67
    Zero=68
    Proton=69
    Observed=70
    Anisotropy=71
    Amides=72
    Nitrogens=73
    Oxygens=74
    RingAtoms=75
    AlphasAndAmides=76
    Error=77
    Conformation=78
    Compressed=79
    Phase=80
    Size=81
    Dimensions=82
    Danisotropy=83
    OneBond=84
    AngleDb=85
    DerivFlag=86
    Angle_or_Dihedral=87
    Flags=88
    All=89
    Around=90
    Atom=91
    Attribute=92
    BondedTo=93
    ByGroup=94
    ByRes=95
    Chemical=96
    Fbox=97
    Hydrogen=98
    Id=99
    Known=100
    Name=101
    NONE=102
    Point=103
    Cut=104
    Previous=105
    Pseudo=106
    Residue=107
    Resname=108
    Saround=109
    SegIdentifier=110
    Sfbox=111
    Store_1=112
    Store_2=113
    Store_3=114
    Store_4=115
    Store_5=116
    Store_6=117
    Store_7=118
    Store_8=119
    Store_9=120
    Tag=121
    Vector=122
    Do_Lp=123
    Identify_Lp=124
    Show=125
    Evaluate_Lp=126
    For=127
    Loop=128
    Tail=129
    Head=130
    Or_op=131
    And_op=132
    Not_op=133
    Comma=134
    Complex=135
    Integer=136
    Logical=137
    Real=138
    Double_quote_string=139
    SHARP_COMMENT=140
    EXCLM_COMMENT=141
    SMCLN_COMMENT=142
    Simple_name=143
    Simple_names=144
    Integers=145
    L_paren=146
    R_paren=147
    Colon=148
    Equ_op=149
    Lt_op=150
    Gt_op=151
    Leq_op=152
    Geq_op=153
    Neq_op=154
    Symbol_name=155
    SPACE=156
    COMMENT=157
    SECTION_COMMENT=158
    LINE_COMMENT=159
    SET_VARIABLE=160
    Abs=161
    Attr_properties=162
    Comparison_ops=163
    SPACE_ATTR=164
    Averaging_methods=165
    Simple_name_A=166
    SPACE_AVER=167
    Equ_op_P=168
    Potential_types=169
    Simple_name_P=170
    SPACE_POTE=171
    Noe_analysis=172
    SPACE_ANAL=173
    Exclude=174
    Include=175
    End_F=176
    Class_name=177
    Any_class=178
    SPACE_FLAG=179
    R_paren_VE=180
    Equ_op_VE=181
    Add_op_VE=182
    Sub_op_VE=183
    Mul_op_VE=184
    Div_op_VE=185
    Exp_op_VE=186
    Comma_VE=187
    Integer_VE=188
    Real_VE=189
    Atom_properties_VE=190
    Abs_VE=191
    Acos_VE=192
    Asin_VE=193
    Cos_VE=194
    Decode_VE=195
    Encode_VE=196
    Exp_VE=197
    Gauss_VE=198
    Heavy_VE=199
    Int_VE=200
    Log10_VE=201
    Log_VE=202
    Max_VE=203
    Maxw_VE=204
    Min_VE=205
    Mod_VE=206
    Norm_VE=207
    Random_VE=208
    Sign_VE=209
    Sin_VE=210
    Sqrt_VE=211
    Tan_VE=212
    Symbol_name_VE=213
    Simple_name_VE=214
    Double_quote_string_VE=215
    SPACE_VE=216
    L_paren_VF=217
    SPACE_VF=218
    L_paren_VS=219
    R_paren_VS=220
    Average_VS=221
    Element_VS=222
    Max_VS=223
    Min_VS=224
    Norm_VS=225
    Rms_VS=226
    Sum_VS=227
    Atom_properties_VS=228
    SPACE_VS=229
    L_paren_CF=230
    R_paren_CF=231
    In_CF=232
    Integer_CF=233
    Real_CF=234
    Symbol_name_CF=235
    Simple_name_CF=236
    SPACE_CF=237
    COMMENT_CF=238
    Simple_name_LL=239
    SPACE_LL=240

    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 Cns_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(CnsMRParser.EOF, 0)

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


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


        def plane_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Plane_restraintContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Plane_restraintContext,i)


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


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


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


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


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


        def conformation_db_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Conformation_db_restraintContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Conformation_db_restraintContext,i)


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


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


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


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


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


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


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


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


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


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


        def carbon_shift_assign_loop(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Carbon_shift_assign_loopContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Carbon_shift_assign_loopContext,i)


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


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


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


        def plane_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Plane_statementContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Plane_statementContext,i)


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


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


        def carbon_shift_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Carbon_shift_assignContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Carbon_shift_assignContext,i)


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


        def getRuleIndex(self):
            return CnsMRParser.RULE_cns_mr

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

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




    def cns_mr(self):

        localctx = CnsMRParser.Cns_mrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_cns_mr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 172
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Noe) | (1 << CnsMRParser.Assign) | (1 << CnsMRParser.Initialize) | (1 << CnsMRParser.Restraints) | (1 << CnsMRParser.Dihedral) | (1 << CnsMRParser.Print_any) | (1 << CnsMRParser.Plane) | (1 << CnsMRParser.Group) | (1 << CnsMRParser.Harmonic) | (1 << CnsMRParser.Sanisotropy) | (1 << CnsMRParser.Coupling) | (1 << CnsMRParser.Carbon))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (CnsMRParser.Proton - 69)) | (1 << (CnsMRParser.Observed - 69)) | (1 << (CnsMRParser.Conformation - 69)) | (1 << (CnsMRParser.Danisotropy - 69)) | (1 << (CnsMRParser.OneBond - 69)) | (1 << (CnsMRParser.AngleDb - 69)) | (1 << (CnsMRParser.Flags - 69)) | (1 << (CnsMRParser.Vector - 69)) | (1 << (CnsMRParser.Evaluate_Lp - 69)) | (1 << (CnsMRParser.For - 69)))) != 0):
                self.state = 170
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 142
                    self.distance_restraint()
                    pass

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

                elif la_ == 3:
                    self.state = 144
                    self.plane_restraint()
                    pass

                elif la_ == 4:
                    self.state = 145
                    self.harmonic_restraint()
                    pass

                elif la_ == 5:
                    self.state = 146
                    self.rdc_restraint()
                    pass

                elif la_ == 6:
                    self.state = 147
                    self.coupling_restraint()
                    pass

                elif la_ == 7:
                    self.state = 148
                    self.carbon_shift_restraint()
                    pass

                elif la_ == 8:
                    self.state = 149
                    self.proton_shift_restraint()
                    pass

                elif la_ == 9:
                    self.state = 150
                    self.conformation_db_restraint()
                    pass

                elif la_ == 10:
                    self.state = 151
                    self.diffusion_anisotropy_restraint()
                    pass

                elif la_ == 11:
                    self.state = 152
                    self.one_bond_coupling_restraint()
                    pass

                elif la_ == 12:
                    self.state = 153
                    self.angle_db_restraint()
                    pass

                elif la_ == 13:
                    self.state = 154
                    self.flag_statement()
                    pass

                elif la_ == 14:
                    self.state = 155
                    self.vector_statement()
                    pass

                elif la_ == 15:
                    self.state = 156
                    self.evaluate_statement()
                    pass

                elif la_ == 16:
                    self.state = 157
                    self.noe_assign_loop()
                    pass

                elif la_ == 17:
                    self.state = 158
                    self.dihedral_assign_loop()
                    pass

                elif la_ == 18:
                    self.state = 159
                    self.sani_assign_loop()
                    pass

                elif la_ == 19:
                    self.state = 160
                    self.coup_assign_loop()
                    pass

                elif la_ == 20:
                    self.state = 161
                    self.carbon_shift_assign_loop()
                    pass

                elif la_ == 21:
                    self.state = 162
                    self.noe_assign()
                    pass

                elif la_ == 22:
                    self.state = 163
                    self.dihedral_assign()
                    pass

                elif la_ == 23:
                    self.state = 164
                    self.sani_assign()
                    pass

                elif la_ == 24:
                    self.state = 165
                    self.plane_statement()
                    pass

                elif la_ == 25:
                    self.state = 166
                    self.harmonic_assign()
                    pass

                elif la_ == 26:
                    self.state = 167
                    self.coup_assign()
                    pass

                elif la_ == 27:
                    self.state = 168
                    self.carbon_shift_assign()
                    pass

                elif la_ == 28:
                    self.state = 169
                    self.observed()
                    pass


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

            self.state = 175
            self.match(CnsMRParser.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(CnsMRParser.Noe, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Distance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_distance_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self.match(CnsMRParser.Noe)
            self.state = 181
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 178
                    self.noe_statement() 
                self.state = 183
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

            self.state = 184
            self.match(CnsMRParser.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(CnsMRParser.Dihedral, 0)

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

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.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 = 187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.Restraints:
                self.state = 186
                self.match(CnsMRParser.Restraints)


            self.state = 189
            self.match(CnsMRParser.Dihedral)
            self.state = 193
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Cv) | (1 << CnsMRParser.Partition) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.Scale) | (1 << CnsMRParser.Nassign) | (1 << CnsMRParser.Print_any))) != 0) or _la==CnsMRParser.For:
                self.state = 190
                self.dihedral_statement()
                self.state = 195
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Plane_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Plane(self):
            return self.getToken(CnsMRParser.Plane, 0)

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

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

        def plane_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Plane_statementContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Plane_statementContext,i)


        def getRuleIndex(self):
            return CnsMRParser.RULE_plane_restraint

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

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




    def plane_restraint(self):

        localctx = CnsMRParser.Plane_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_plane_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 199
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.Restraints:
                self.state = 198
                self.match(CnsMRParser.Restraints)


            self.state = 201
            self.match(CnsMRParser.Plane)
            self.state = 205
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Initialize) | (1 << CnsMRParser.Print_any) | (1 << CnsMRParser.Group))) != 0):
                self.state = 202
                self.plane_statement()
                self.state = 207
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 208
            self.match(CnsMRParser.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(CnsMRParser.Harmonic, 0)

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

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Harmonic_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_harmonic_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.Restraints:
                self.state = 210
                self.match(CnsMRParser.Restraints)


            self.state = 213
            self.match(CnsMRParser.Harmonic)
            self.state = 217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Exponent or _la==CnsMRParser.Normal:
                self.state = 214
                self.harmonic_statement()
                self.state = 219
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 220
            self.match(CnsMRParser.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(CnsMRParser.Sanisotropy, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Rdc_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_rdc_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 222
            self.match(CnsMRParser.Sanisotropy)
            self.state = 226
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.Coefficients) | (1 << CnsMRParser.ForceConstant))) != 0) or _la==CnsMRParser.For:
                self.state = 223
                self.sani_statement()
                self.state = 228
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 229
            self.match(CnsMRParser.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(CnsMRParser.Coupling, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_coupling_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 231
            self.match(CnsMRParser.Coupling)
            self.state = 235
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Cv) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Partition) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.Coefficients) | (1 << CnsMRParser.ForceConstant))) != 0) or _la==CnsMRParser.For:
                self.state = 232
                self.coupling_statement()
                self.state = 237
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 238
            self.match(CnsMRParser.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(CnsMRParser.Carbon, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Carbon_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_carbon_shift_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 240
            self.match(CnsMRParser.Carbon)
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.ForceConstant))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CnsMRParser.Expectation - 64)) | (1 << (CnsMRParser.PhiStep - 64)) | (1 << (CnsMRParser.PsiStep - 64)) | (1 << (CnsMRParser.Rcoil - 64)) | (1 << (CnsMRParser.Zero - 64)) | (1 << (CnsMRParser.For - 64)))) != 0):
                self.state = 241
                self.carbon_shift_statement()
                self.state = 246
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 247
            self.match(CnsMRParser.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(CnsMRParser.Proton, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_proton_shift_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 249
            self.match(CnsMRParser.Proton)
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Classification) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.ForceConstant) | (1 << CnsMRParser.Carbon))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CnsMRParser.Rcoil - 67)) | (1 << (CnsMRParser.Observed - 67)) | (1 << (CnsMRParser.Anisotropy - 67)) | (1 << (CnsMRParser.Amides - 67)) | (1 << (CnsMRParser.Nitrogens - 67)) | (1 << (CnsMRParser.Oxygens - 67)) | (1 << (CnsMRParser.RingAtoms - 67)) | (1 << (CnsMRParser.AlphasAndAmides - 67)) | (1 << (CnsMRParser.Error - 67)))) != 0):
                self.state = 250
                self.proton_shift_statement()
                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Conformation_db_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Conformation(self):
            return self.getToken(CnsMRParser.Conformation, 0)

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

        def conformation_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Conformation_statementContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Conformation_statementContext,i)


        def getRuleIndex(self):
            return CnsMRParser.RULE_conformation_db_restraint

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

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




    def conformation_db_restraint(self):

        localctx = CnsMRParser.Conformation_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_conformation_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            self.match(CnsMRParser.Conformation)
            self.state = 262
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.ForceConstant))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CnsMRParser.Expectation - 64)) | (1 << (CnsMRParser.Zero - 64)) | (1 << (CnsMRParser.Error - 64)) | (1 << (CnsMRParser.Compressed - 64)) | (1 << (CnsMRParser.Phase - 64)) | (1 << (CnsMRParser.Size - 64)))) != 0):
                self.state = 259
                self.conformation_statement()
                self.state = 264
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 265
            self.match(CnsMRParser.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(CnsMRParser.Danisotropy, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Diffusion_anisotropy_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_diffusion_anisotropy_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 267
            self.match(CnsMRParser.Danisotropy)
            self.state = 271
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.Coefficients) | (1 << CnsMRParser.ForceConstant))) != 0):
                self.state = 268
                self.diffusion_statement()
                self.state = 273
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 274
            self.match(CnsMRParser.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(CnsMRParser.OneBond, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.One_bond_coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_one_bond_coupling_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 276
            self.match(CnsMRParser.OneBond)
            self.state = 280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.Coefficients) | (1 << CnsMRParser.ForceConstant))) != 0):
                self.state = 277
                self.one_bond_coupling_statement()
                self.state = 282
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 283
            self.match(CnsMRParser.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(CnsMRParser.AngleDb, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Angle_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_angle_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 285
            self.match(CnsMRParser.AngleDb)
            self.state = 289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CnsMRParser.Assign) | (1 << CnsMRParser.Classification) | (1 << CnsMRParser.Nrestraints) | (1 << CnsMRParser.Potential) | (1 << CnsMRParser.Print) | (1 << CnsMRParser.Reset) | (1 << CnsMRParser.ForceConstant))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CnsMRParser.Expectation - 64)) | (1 << (CnsMRParser.Zero - 64)) | (1 << (CnsMRParser.Error - 64)) | (1 << (CnsMRParser.Size - 64)) | (1 << (CnsMRParser.DerivFlag - 64)))) != 0):
                self.state = 286
                self.angle_db_statement()
                self.state = 291
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 292
            self.match(CnsMRParser.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 Analysis(self):
            return self.getToken(CnsMRParser.Analysis, 0)

        def Noe_analysis(self):
            return self.getToken(CnsMRParser.Noe_analysis, 0)

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

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


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


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

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

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


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

        def Simple_name_A(self):
            return self.getToken(CnsMRParser.Simple_name_A, 0)

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

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

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

        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

        def Den(self):
            return self.getToken(CnsMRParser.Den, 0)

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

        def Update(self):
            return self.getToken(CnsMRParser.Update, 0)

        def Gamma(self):
            return self.getToken(CnsMRParser.Gamma, 0)

        def Kappa(self):
            return self.getToken(CnsMRParser.Kappa, 0)

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

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

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

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

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

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

        def Outd(self):
            return self.getToken(CnsMRParser.Outd, 0)

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

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

        def Simple_name_P(self):
            return self.getToken(CnsMRParser.Simple_name_P, 0)

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

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

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


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

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

        def Raverage(self):
            return self.getToken(CnsMRParser.Raverage, 0)

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

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

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

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

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

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

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

        def Taverage(self):
            return self.getToken(CnsMRParser.Taverage, 0)

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Noe_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_noe_statement)
        self._la = 0 # Token type
        try:
            self.state = 423
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 294
                self.match(CnsMRParser.Analysis)
                self.state = 296
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 295
                    self.match(CnsMRParser.Equ_op)


                self.state = 298
                self.match(CnsMRParser.Noe_analysis)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 299
                self.noe_assign()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 300
                self.noe_assign_loop()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 301
                self.match(CnsMRParser.Asymptote)
                self.state = 302
                self.match(CnsMRParser.Simple_name)
                self.state = 303
                self.number_s()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 304
                self.match(CnsMRParser.Average)
                self.state = 305
                self.match(CnsMRParser.Simple_name_A)
                self.state = 306
                self.match(CnsMRParser.Averaging_methods)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 307
                self.match(CnsMRParser.Bhig)
                self.state = 308
                self.match(CnsMRParser.Simple_name)
                self.state = 309
                self.number_s()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 310
                self.match(CnsMRParser.Ceiling)
                self.state = 312
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 311
                    self.match(CnsMRParser.Equ_op)


                self.state = 314
                self.number_s()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 315
                self.match(CnsMRParser.Classification)
                self.state = 317
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 316
                    self.match(CnsMRParser.Equ_op)


                self.state = 319
                self.match(CnsMRParser.Simple_name)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 320
                self.match(CnsMRParser.CountViol)
                self.state = 321
                self.match(CnsMRParser.Simple_name)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 322
                self.match(CnsMRParser.Cv)
                self.state = 324
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 323
                    self.match(CnsMRParser.Equ_op)


                self.state = 326
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 327
                self.match(CnsMRParser.Den)
                self.state = 328
                self.match(CnsMRParser.Initialize)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 329
                self.match(CnsMRParser.Den)
                self.state = 330
                self.match(CnsMRParser.Update)
                self.state = 331
                self.match(CnsMRParser.Gamma)
                self.state = 333
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 332
                    self.match(CnsMRParser.Equ_op)


                self.state = 335
                self.number_s()
                self.state = 336
                self.match(CnsMRParser.Kappa)
                self.state = 338
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 337
                    self.match(CnsMRParser.Equ_op)


                self.state = 340
                self.number_s()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 342
                self.match(CnsMRParser.Distribute)
                self.state = 343
                self.match(CnsMRParser.Simple_name)
                self.state = 344
                self.match(CnsMRParser.Simple_name)
                self.state = 345
                self.number_s()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 349
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 346
                        self.match(CnsMRParser.Ensemble) 
                    self.state = 351
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,23,self._ctx)

                self.state = 352
                self.match(CnsMRParser.End)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 353
                self.match(CnsMRParser.Monomers)
                self.state = 354
                self.match(CnsMRParser.Simple_name)
                self.state = 355
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 356
                self.match(CnsMRParser.Ncount)
                self.state = 357
                self.match(CnsMRParser.Simple_name)
                self.state = 358
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 359
                self.match(CnsMRParser.Nrestraints)
                self.state = 361
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 360
                    self.match(CnsMRParser.Equ_op)


                self.state = 363
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 364
                self.match(CnsMRParser.Outd)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 365
                self.match(CnsMRParser.Partition)
                self.state = 367
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 366
                    self.match(CnsMRParser.Equ_op)


                self.state = 369
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 370
                self.match(CnsMRParser.Potential)
                self.state = 371
                self.match(CnsMRParser.Simple_name_P)
                self.state = 372
                self.match(CnsMRParser.Potential_types)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 373
                self.match(CnsMRParser.Predict)
                self.state = 374
                self.predict_statement()
                self.state = 375
                self.match(CnsMRParser.End)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 377
                self.match(CnsMRParser.Print)
                self.state = 378
                self.match(CnsMRParser.Threshold)
                self.state = 380
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 379
                    self.match(CnsMRParser.Equ_op)


                self.state = 382
                self.number_s()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 383
                self.match(CnsMRParser.Raverage)
                self.state = 387
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 384
                        self.match(CnsMRParser.Simple_name) 
                    self.state = 389
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,27,self._ctx)

                self.state = 390
                self.match(CnsMRParser.End)
                pass

            elif la_ == 24:
                self.enterOuterAlt(localctx, 24)
                self.state = 391
                self.match(CnsMRParser.Reset)
                pass

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 392
                self.match(CnsMRParser.Rswitch)
                self.state = 393
                self.match(CnsMRParser.Simple_name)
                self.state = 394
                self.number_s()
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 395
                self.match(CnsMRParser.Scale)
                self.state = 396
                self.match(CnsMRParser.Simple_name)
                self.state = 397
                self.number_s()
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 398
                self.match(CnsMRParser.SoExponent)
                self.state = 399
                self.match(CnsMRParser.Simple_name)
                self.state = 400
                self.number_s()
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 401
                self.match(CnsMRParser.SqConstant)
                self.state = 402
                self.match(CnsMRParser.Simple_name)
                self.state = 403
                self.number_s()
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 404
                self.match(CnsMRParser.SqExponent)
                self.state = 405
                self.match(CnsMRParser.Simple_name)
                self.state = 406
                self.number_s()
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 407
                self.match(CnsMRParser.SqOffset)
                self.state = 408
                self.match(CnsMRParser.Simple_name)
                self.state = 409
                self.number_s()
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 410
                self.match(CnsMRParser.Taverage)
                self.state = 414
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 411
                        self.match(CnsMRParser.Simple_name) 
                    self.state = 416
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,28,self._ctx)

                self.state = 417
                self.match(CnsMRParser.End)
                pass

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 418
                self.match(CnsMRParser.Temperature)
                self.state = 420
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 419
                    self.match(CnsMRParser.Equ_op)


                self.state = 422
                self.number_s()
                pass


        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(CnsMRParser.Assign)
            else:
                return self.getToken(CnsMRParser.Assign, i)

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


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


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


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Noe_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_noe_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 425
            self.match(CnsMRParser.Assign)
            self.state = 426
            self.selection()
            self.state = 427
            self.selection()
            self.state = 428
            self.number()
            self.state = 430
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 429
                self.number()


            self.state = 433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                self.state = 432
                self.number()


            self.state = 438
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 435
                    self.noe_annotation() 
                self.state = 440
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,33,self._ctx)

            self.state = 458
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Or_op:
                self.state = 441
                self.match(CnsMRParser.Or_op)
                self.state = 443
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Assign:
                    self.state = 442
                    self.match(CnsMRParser.Assign)


                self.state = 445
                self.selection()
                self.state = 446
                self.selection()
                self.state = 448
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                if la_ == 1:
                    self.state = 447
                    self.number()


                self.state = 451
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
                if la_ == 1:
                    self.state = 450
                    self.number()


                self.state = 454
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                    self.state = 453
                    self.number()


                self.state = 460
                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(CnsMRParser.Cutoff, 0)

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


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

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

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

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


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Predict_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_predict_statement)
        self._la = 0 # Token type
        try:
            self.state = 475
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 1)
                self.state = 461
                self.match(CnsMRParser.Cutoff)
                self.state = 463
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 462
                    self.match(CnsMRParser.Equ_op)


                self.state = 465
                self.number_s()
                pass
            elif token in [CnsMRParser.Cuton]:
                self.enterOuterAlt(localctx, 2)
                self.state = 466
                self.match(CnsMRParser.Cuton)
                self.state = 468
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 467
                    self.match(CnsMRParser.Equ_op)


                self.state = 470
                self.number_s()
                pass
            elif token in [CnsMRParser.From]:
                self.enterOuterAlt(localctx, 3)
                self.state = 471
                self.match(CnsMRParser.From)
                self.state = 472
                self.selection()
                pass
            elif token in [CnsMRParser.To]:
                self.enterOuterAlt(localctx, 4)
                self.state = 473
                self.match(CnsMRParser.To)
                self.state = 474
                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(CnsMRParser.Peak, 0)

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


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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Noe_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_noe_annotation)
        self._la = 0 # Token type
        try:
            self.state = 512
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Peak]:
                self.enterOuterAlt(localctx, 1)
                self.state = 477
                self.match(CnsMRParser.Peak)
                self.state = 479
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 478
                    self.match(CnsMRParser.Equ_op)


                self.state = 481
                self.number_a()
                pass
            elif token in [CnsMRParser.Spectrum]:
                self.enterOuterAlt(localctx, 2)
                self.state = 482
                self.match(CnsMRParser.Spectrum)
                self.state = 484
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 483
                    self.match(CnsMRParser.Equ_op)


                self.state = 486
                self.number_a()
                pass
            elif token in [CnsMRParser.Weight]:
                self.enterOuterAlt(localctx, 3)
                self.state = 487
                self.match(CnsMRParser.Weight)
                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 488
                    self.match(CnsMRParser.Equ_op)


                self.state = 491
                self.number_a()
                pass
            elif token in [CnsMRParser.Volume]:
                self.enterOuterAlt(localctx, 4)
                self.state = 492
                self.match(CnsMRParser.Volume)
                self.state = 494
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 493
                    self.match(CnsMRParser.Equ_op)


                self.state = 496
                self.number_a()
                pass
            elif token in [CnsMRParser.Ppm1]:
                self.enterOuterAlt(localctx, 5)
                self.state = 497
                self.match(CnsMRParser.Ppm1)
                self.state = 499
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 498
                    self.match(CnsMRParser.Equ_op)


                self.state = 501
                self.number_a()
                pass
            elif token in [CnsMRParser.Ppm2]:
                self.enterOuterAlt(localctx, 6)
                self.state = 502
                self.match(CnsMRParser.Ppm2)
                self.state = 504
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 503
                    self.match(CnsMRParser.Equ_op)


                self.state = 506
                self.number_a()
                pass
            elif token in [CnsMRParser.Cv]:
                self.enterOuterAlt(localctx, 7)
                self.state = 507
                self.match(CnsMRParser.Cv)
                self.state = 509
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 508
                    self.match(CnsMRParser.Equ_op)


                self.state = 511
                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 dihedral_assign(self):
            return self.getTypedRuleContext(CnsMRParser.Dihedral_assignContext,0)


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


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

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

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

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

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

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

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

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


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Dihedral_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_dihedral_statement)
        self._la = 0 # Token type
        try:
            self.state = 538
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 514
                self.dihedral_assign()
                pass
            elif token in [CnsMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 515
                self.dihedral_assign_loop()
                pass
            elif token in [CnsMRParser.Cv]:
                self.enterOuterAlt(localctx, 3)
                self.state = 516
                self.match(CnsMRParser.Cv)
                self.state = 518
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 517
                    self.match(CnsMRParser.Equ_op)


                self.state = 520
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Nassign]:
                self.enterOuterAlt(localctx, 4)
                self.state = 521
                self.match(CnsMRParser.Nassign)
                self.state = 523
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 522
                    self.match(CnsMRParser.Equ_op)


                self.state = 525
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Partition]:
                self.enterOuterAlt(localctx, 5)
                self.state = 526
                self.match(CnsMRParser.Partition)
                self.state = 528
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 527
                    self.match(CnsMRParser.Equ_op)


                self.state = 530
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 531
                self.match(CnsMRParser.Reset)
                pass
            elif token in [CnsMRParser.Scale]:
                self.enterOuterAlt(localctx, 7)
                self.state = 532
                self.match(CnsMRParser.Scale)
                self.state = 534
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 533
                    self.match(CnsMRParser.Equ_op)


                self.state = 536
                self.number_s()
                pass
            elif token in [CnsMRParser.Print_any]:
                self.enterOuterAlt(localctx, 8)
                self.state = 537
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


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


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Dihedral_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_dihedral_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 540
            self.match(CnsMRParser.Assign)
            self.state = 541
            self.selection()
            self.state = 542
            self.selection()
            self.state = 543
            self.selection()
            self.state = 544
            self.selection()
            self.state = 545
            self.number()
            self.state = 546
            self.number()
            self.state = 547
            self.number()
            self.state = 548
            self.match(CnsMRParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Plane_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(CnsMRParser.Group, 0)

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

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


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

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

        def getRuleIndex(self):
            return CnsMRParser.RULE_plane_statement

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

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




    def plane_statement(self):

        localctx = CnsMRParser.Plane_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_plane_statement)
        self._la = 0 # Token type
        try:
            self.state = 560
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Group]:
                self.enterOuterAlt(localctx, 1)
                self.state = 550
                self.match(CnsMRParser.Group)
                self.state = 554
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Selection or _la==CnsMRParser.Weight:
                    self.state = 551
                    self.group_statement()
                    self.state = 556
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 557
                self.match(CnsMRParser.End)
                pass
            elif token in [CnsMRParser.Initialize]:
                self.enterOuterAlt(localctx, 2)
                self.state = 558
                self.match(CnsMRParser.Initialize)
                pass
            elif token in [CnsMRParser.Print_any]:
                self.enterOuterAlt(localctx, 3)
                self.state = 559
                self.match(CnsMRParser.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 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(CnsMRParser.Selection, 0)

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


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

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Group_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 572
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Selection]:
                self.enterOuterAlt(localctx, 1)
                self.state = 562
                self.match(CnsMRParser.Selection)
                self.state = 564
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 563
                    self.match(CnsMRParser.Equ_op)


                self.state = 566
                self.selection()
                pass
            elif token in [CnsMRParser.Weight]:
                self.enterOuterAlt(localctx, 2)
                self.state = 567
                self.match(CnsMRParser.Weight)
                self.state = 569
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 568
                    self.match(CnsMRParser.Equ_op)


                self.state = 571
                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 Exponent(self):
            return self.getToken(CnsMRParser.Exponent, 0)

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

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

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

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

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

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


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

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


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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Harmonic_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_harmonic_statement)
        self._la = 0 # Token type
        try:
            self.state = 613
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Exponent]:
                self.enterOuterAlt(localctx, 1)
                self.state = 574
                self.match(CnsMRParser.Exponent)
                self.state = 576
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 575
                    self.match(CnsMRParser.Equ_op)


                self.state = 578
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Normal]:
                self.enterOuterAlt(localctx, 2)
                self.state = 579
                self.match(CnsMRParser.Normal)
                self.state = 581
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 580
                    self.match(CnsMRParser.Equ_op)


                self.state = 583
                self.match(CnsMRParser.L_paren)
                self.state = 609
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Integer, CnsMRParser.Real, CnsMRParser.Symbol_name]:
                    self.state = 584
                    self.number_s()
                    self.state = 586
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Comma:
                        self.state = 585
                        self.match(CnsMRParser.Comma)


                    self.state = 588
                    self.number_s()
                    self.state = 590
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Comma:
                        self.state = 589
                        self.match(CnsMRParser.Comma)


                    self.state = 592
                    self.number_s()
                    pass
                elif token in [CnsMRParser.Tail]:
                    self.state = 594
                    self.match(CnsMRParser.Tail)
                    self.state = 596
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Equ_op:
                        self.state = 595
                        self.match(CnsMRParser.Equ_op)


                    self.state = 598
                    self.selection()
                    self.state = 600
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Comma:
                        self.state = 599
                        self.match(CnsMRParser.Comma)


                    self.state = 607
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Head:
                        self.state = 602
                        self.match(CnsMRParser.Head)
                        self.state = 604
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CnsMRParser.Equ_op:
                            self.state = 603
                            self.match(CnsMRParser.Equ_op)


                        self.state = 606
                        self.selection()


                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 611
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Harmonic_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_harmonic_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 615
            self.match(CnsMRParser.Assign)
            self.state = 616
            self.selection()
            self.state = 617
            self.number()
            self.state = 618
            self.number()
            self.state = 619
            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 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(CnsMRParser.Sani_assignContext,0)


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


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

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


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

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

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

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Sani_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_sani_statement)
        self._la = 0 # Token type
        try:
            self.state = 652
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 621
                self.sani_assign()
                pass
            elif token in [CnsMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 622
                self.sani_assign_loop()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 623
                self.match(CnsMRParser.Classification)
                self.state = 625
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 624
                    self.match(CnsMRParser.Equ_op)


                self.state = 627
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 628
                self.match(CnsMRParser.Coefficients)
                self.state = 629
                self.number_s()
                self.state = 630
                self.number_s()
                self.state = 631
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 633
                self.match(CnsMRParser.ForceConstant)
                self.state = 635
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 634
                    self.match(CnsMRParser.Equ_op)


                self.state = 637
                self.number_s()
                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 638
                self.match(CnsMRParser.Nrestraints)
                self.state = 640
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 639
                    self.match(CnsMRParser.Equ_op)


                self.state = 642
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 7)
                self.state = 643
                self.match(CnsMRParser.Potential)
                self.state = 645
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 644
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 647
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 648
                self.match(CnsMRParser.Print)
                self.state = 649
                self.match(CnsMRParser.Threshold)
                self.state = 650
                self.number_s()
                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 9)
                self.state = 651
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Sani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_sani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 654
            self.match(CnsMRParser.Assign)
            self.state = 655
            self.selection()
            self.state = 656
            self.selection()
            self.state = 657
            self.selection()
            self.state = 658
            self.selection()
            self.state = 659
            self.selection()
            self.state = 660
            self.selection()
            self.state = 661
            self.number()
            self.state = 663
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 662
                self.number()


            self.state = 666
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                self.state = 665
                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 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(CnsMRParser.Coup_assignContext,0)


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


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

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


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

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

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

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

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

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Coupling_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 718
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 668
                self.coup_assign()
                pass
            elif token in [CnsMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 669
                self.coup_assign_loop()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 670
                self.match(CnsMRParser.Classification)
                self.state = 672
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 671
                    self.match(CnsMRParser.Equ_op)


                self.state = 674
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 675
                self.match(CnsMRParser.Coefficients)
                self.state = 676
                self.number_s()
                self.state = 677
                self.number_s()
                self.state = 678
                self.number_s()
                self.state = 679
                self.number_s()
                pass
            elif token in [CnsMRParser.Cv]:
                self.enterOuterAlt(localctx, 5)
                self.state = 681
                self.match(CnsMRParser.Cv)
                self.state = 683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 682
                    self.match(CnsMRParser.Equ_op)


                self.state = 685
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 686
                self.match(CnsMRParser.ForceConstant)
                self.state = 687
                self.number_s()
                self.state = 689
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                    self.state = 688
                    self.number_s()


                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 691
                self.match(CnsMRParser.Nrestraints)
                self.state = 693
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 692
                    self.match(CnsMRParser.Equ_op)


                self.state = 695
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Partition]:
                self.enterOuterAlt(localctx, 8)
                self.state = 696
                self.match(CnsMRParser.Partition)
                self.state = 698
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 697
                    self.match(CnsMRParser.Equ_op)


                self.state = 700
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 701
                self.match(CnsMRParser.Potential)
                self.state = 703
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 702
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 705
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 706
                self.match(CnsMRParser.Print)
                self.state = 707
                self.match(CnsMRParser.Threshold)
                self.state = 708
                self.number_s()
                self.state = 715
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.All]:
                    self.state = 709
                    self.match(CnsMRParser.All)
                    pass
                elif token in [CnsMRParser.Classification]:
                    self.state = 710
                    self.match(CnsMRParser.Classification)
                    self.state = 712
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Equ_op:
                        self.state = 711
                        self.match(CnsMRParser.Equ_op)


                    self.state = 714
                    self.match(CnsMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 717
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Coup_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_coup_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 720
            self.match(CnsMRParser.Assign)
            self.state = 721
            self.selection()
            self.state = 722
            self.selection()
            self.state = 723
            self.selection()
            self.state = 724
            self.selection()
            self.state = 730
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.L_paren:
                self.state = 725
                self.selection()
                self.state = 726
                self.selection()
                self.state = 727
                self.selection()
                self.state = 728
                self.selection()


            self.state = 732
            self.number()
            self.state = 733
            self.number()
            self.state = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                self.state = 734
                self.number()
                self.state = 735
                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(CnsMRParser.Carbon_shift_assignContext,0)


        def carbon_shift_assign_loop(self):
            return self.getTypedRuleContext(CnsMRParser.Carbon_shift_assign_loopContext,0)


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

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

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


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

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

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

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

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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


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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Carbon_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_carbon_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 784
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 739
                self.carbon_shift_assign()
                pass
            elif token in [CnsMRParser.For]:
                self.enterOuterAlt(localctx, 2)
                self.state = 740
                self.carbon_shift_assign_loop()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 741
                self.match(CnsMRParser.Classification)
                self.state = 743
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 742
                    self.match(CnsMRParser.Equ_op)


                self.state = 745
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 746
                self.match(CnsMRParser.Expectation)
                self.state = 747
                self.match(CnsMRParser.Integer)
                self.state = 748
                self.match(CnsMRParser.Integer)
                self.state = 749
                self.number_s()
                self.state = 750
                self.number_s()
                self.state = 751
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 753
                self.match(CnsMRParser.ForceConstant)
                self.state = 755
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 754
                    self.match(CnsMRParser.Equ_op)


                self.state = 757
                self.number_s()
                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 758
                self.match(CnsMRParser.Nrestraints)
                self.state = 760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 759
                    self.match(CnsMRParser.Equ_op)


                self.state = 762
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.PhiStep]:
                self.enterOuterAlt(localctx, 7)
                self.state = 763
                self.match(CnsMRParser.PhiStep)
                self.state = 765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 764
                    self.match(CnsMRParser.Equ_op)


                self.state = 767
                self.number_s()
                pass
            elif token in [CnsMRParser.PsiStep]:
                self.enterOuterAlt(localctx, 8)
                self.state = 768
                self.match(CnsMRParser.PsiStep)
                self.state = 770
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 769
                    self.match(CnsMRParser.Equ_op)


                self.state = 772
                self.number_s()
                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 773
                self.match(CnsMRParser.Potential)
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 774
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 777
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 778
                self.match(CnsMRParser.Print)
                self.state = 779
                self.match(CnsMRParser.Threshold)
                self.state = 780
                self.number_s()
                pass
            elif token in [CnsMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 11)
                self.state = 781
                self.carbon_shift_rcoil()
                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 782
                self.match(CnsMRParser.Reset)
                pass
            elif token in [CnsMRParser.Zero]:
                self.enterOuterAlt(localctx, 13)
                self.state = 783
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Carbon_shift_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_carbon_shift_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 786
            self.match(CnsMRParser.Assign)
            self.state = 787
            self.selection()
            self.state = 788
            self.selection()
            self.state = 789
            self.selection()
            self.state = 790
            self.selection()
            self.state = 791
            self.selection()
            self.state = 792
            self.number()
            self.state = 793
            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(CnsMRParser.Rcoil, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Carbon_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_carbon_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 795
            self.match(CnsMRParser.Rcoil)
            self.state = 796
            self.selection()
            self.state = 797
            self.number()
            self.state = 798
            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(CnsMRParser.ObservedContext,0)


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


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


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


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


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


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


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


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


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

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


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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_proton_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 840
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Observed]:
                self.enterOuterAlt(localctx, 1)
                self.state = 800
                self.observed()
                pass
            elif token in [CnsMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 2)
                self.state = 801
                self.proton_shift_rcoil()
                pass
            elif token in [CnsMRParser.Anisotropy]:
                self.enterOuterAlt(localctx, 3)
                self.state = 802
                self.proton_shift_anisotropy()
                pass
            elif token in [CnsMRParser.Amides]:
                self.enterOuterAlt(localctx, 4)
                self.state = 803
                self.proton_shift_amides()
                pass
            elif token in [CnsMRParser.Carbon]:
                self.enterOuterAlt(localctx, 5)
                self.state = 804
                self.proton_shift_carbons()
                pass
            elif token in [CnsMRParser.Nitrogens]:
                self.enterOuterAlt(localctx, 6)
                self.state = 805
                self.proton_shift_nitrogens()
                pass
            elif token in [CnsMRParser.Oxygens]:
                self.enterOuterAlt(localctx, 7)
                self.state = 806
                self.proton_shift_oxygens()
                pass
            elif token in [CnsMRParser.RingAtoms]:
                self.enterOuterAlt(localctx, 8)
                self.state = 807
                self.proton_shift_ring_atoms()
                pass
            elif token in [CnsMRParser.AlphasAndAmides]:
                self.enterOuterAlt(localctx, 9)
                self.state = 808
                self.proton_shift_alphas_and_amides()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 10)
                self.state = 809
                self.match(CnsMRParser.Classification)
                self.state = 811
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 810
                    self.match(CnsMRParser.Equ_op)


                self.state = 813
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Error]:
                self.enterOuterAlt(localctx, 11)
                self.state = 814
                self.match(CnsMRParser.Error)
                self.state = 816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 815
                    self.match(CnsMRParser.Equ_op)


                self.state = 818
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 12)
                self.state = 819
                self.match(CnsMRParser.ForceConstant)
                self.state = 820
                self.number_s()
                self.state = 822
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                    self.state = 821
                    self.number_s()


                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 13)
                self.state = 824
                self.match(CnsMRParser.Potential)
                self.state = 825
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 14)
                self.state = 826
                self.match(CnsMRParser.Print)
                self.state = 827
                self.match(CnsMRParser.Threshold)
                self.state = 828
                self.number_s()
                self.state = 835
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.All]:
                    self.state = 829
                    self.match(CnsMRParser.All)
                    pass
                elif token in [CnsMRParser.Classification]:
                    self.state = 830
                    self.match(CnsMRParser.Classification)
                    self.state = 832
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Equ_op:
                        self.state = 831
                        self.match(CnsMRParser.Equ_op)


                    self.state = 834
                    self.match(CnsMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 837
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 15)
                self.state = 839
                self.match(CnsMRParser.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(CnsMRParser.Observed, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.ObservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_observed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 842
            self.match(CnsMRParser.Observed)
            self.state = 843
            self.selection()
            self.state = 845
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.L_paren:
                self.state = 844
                self.selection()


            self.state = 847
            self.number()
            self.state = 849
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                self.state = 848
                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(CnsMRParser.Rcoil, 0)

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


        def number(self):
            return self.getTypedRuleContext(CnsMRParser.NumberContext,0)


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_proton_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self.match(CnsMRParser.Rcoil)
            self.state = 852
            self.selection()
            self.state = 853
            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(CnsMRParser.Anisotropy, 0)

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


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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_anisotropyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_proton_shift_anisotropy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 855
            self.match(CnsMRParser.Anisotropy)
            self.state = 856
            self.selection()
            self.state = 857
            self.selection()
            self.state = 858
            self.selection()
            self.state = 859
            self.match(CnsMRParser.Simple_name)
            self.state = 861
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.Logical:
                self.state = 860
                self.match(CnsMRParser.Logical)


            self.state = 863
            self.match(CnsMRParser.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(CnsMRParser.Amides, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_amidesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_proton_shift_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 865
            self.match(CnsMRParser.Amides)
            self.state = 866
            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(CnsMRParser.Carbon, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_carbonsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_proton_shift_carbons)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 868
            self.match(CnsMRParser.Carbon)
            self.state = 869
            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(CnsMRParser.Nitrogens, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_nitrogensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_proton_shift_nitrogens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 871
            self.match(CnsMRParser.Nitrogens)
            self.state = 872
            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(CnsMRParser.Oxygens, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_oxygensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_proton_shift_oxygens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 874
            self.match(CnsMRParser.Oxygens)
            self.state = 875
            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(CnsMRParser.RingAtoms, 0)

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

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_ring_atomsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_proton_shift_ring_atoms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 877
            self.match(CnsMRParser.RingAtoms)
            self.state = 878
            self.match(CnsMRParser.Simple_name)
            self.state = 879
            self.selection()
            self.state = 880
            self.selection()
            self.state = 881
            self.selection()
            self.state = 882
            self.selection()
            self.state = 883
            self.selection()
            self.state = 885
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.L_paren:
                self.state = 884
                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(CnsMRParser.AlphasAndAmides, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Proton_shift_alphas_and_amidesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_proton_shift_alphas_and_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 887
            self.match(CnsMRParser.AlphasAndAmides)
            self.state = 888
            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 Conformation_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def conf_assign(self):
            return self.getTypedRuleContext(CnsMRParser.Conf_assignContext,0)


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

        def Compressed(self):
            return self.getToken(CnsMRParser.Compressed, 0)

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

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

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


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

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

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

        def Phase(self):
            return self.getToken(CnsMRParser.Phase, 0)

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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

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

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

        def Dimensions(self):
            return self.getToken(CnsMRParser.Dimensions, 0)

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

        def getRuleIndex(self):
            return CnsMRParser.RULE_conformation_statement

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

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




    def conformation_statement(self):

        localctx = CnsMRParser.Conformation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_conformation_statement)
        self._la = 0 # Token type
        try:
            self.state = 973
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 890
                self.conf_assign()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 891
                self.match(CnsMRParser.Classification)
                self.state = 893
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 892
                    self.match(CnsMRParser.Equ_op)


                self.state = 895
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Compressed]:
                self.enterOuterAlt(localctx, 3)
                self.state = 896
                self.match(CnsMRParser.Compressed)
                pass
            elif token in [CnsMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 897
                self.match(CnsMRParser.Expectation)
                self.state = 898
                self.match(CnsMRParser.Integer)
                self.state = 900
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
                if la_ == 1:
                    self.state = 899
                    self.match(CnsMRParser.Integer)


                self.state = 903
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
                if la_ == 1:
                    self.state = 902
                    self.match(CnsMRParser.Integer)


                self.state = 906
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
                if la_ == 1:
                    self.state = 905
                    self.match(CnsMRParser.Integer)


                self.state = 908
                self.number_s()
                pass
            elif token in [CnsMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 909
                self.match(CnsMRParser.Error)
                self.state = 911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 910
                    self.match(CnsMRParser.Equ_op)


                self.state = 913
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 914
                self.match(CnsMRParser.ForceConstant)
                self.state = 916
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 915
                    self.match(CnsMRParser.Equ_op)


                self.state = 918
                self.number_s()
                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 919
                self.match(CnsMRParser.Nrestraints)
                self.state = 921
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 920
                    self.match(CnsMRParser.Equ_op)


                self.state = 923
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Phase]:
                self.enterOuterAlt(localctx, 8)
                self.state = 924
                self.match(CnsMRParser.Phase)
                self.state = 925
                self.match(CnsMRParser.Integer)
                self.state = 926
                self.match(CnsMRParser.Integer)
                self.state = 927
                self.match(CnsMRParser.Integer)
                self.state = 931
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
                if la_ == 1:
                    self.state = 928
                    self.match(CnsMRParser.Integer)
                    self.state = 929
                    self.match(CnsMRParser.Integer)
                    self.state = 930
                    self.match(CnsMRParser.Integer)


                self.state = 936
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
                if la_ == 1:
                    self.state = 933
                    self.match(CnsMRParser.Integer)
                    self.state = 934
                    self.match(CnsMRParser.Integer)
                    self.state = 935
                    self.match(CnsMRParser.Integer)


                self.state = 941
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Integer:
                    self.state = 938
                    self.match(CnsMRParser.Integer)
                    self.state = 939
                    self.match(CnsMRParser.Integer)
                    self.state = 940
                    self.match(CnsMRParser.Integer)


                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 943
                self.match(CnsMRParser.Potential)
                self.state = 945
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 944
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 947
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 948
                self.match(CnsMRParser.Print)
                self.state = 949
                self.match(CnsMRParser.Threshold)
                self.state = 950
                self.number_s()
                self.state = 957
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.All]:
                    self.state = 951
                    self.match(CnsMRParser.All)
                    pass
                elif token in [CnsMRParser.Classification]:
                    self.state = 952
                    self.match(CnsMRParser.Classification)
                    self.state = 954
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Equ_op:
                        self.state = 953
                        self.match(CnsMRParser.Equ_op)


                    self.state = 956
                    self.match(CnsMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 959
                self.match(CnsMRParser.Reset)
                pass
            elif token in [CnsMRParser.Size]:
                self.enterOuterAlt(localctx, 12)
                self.state = 960
                self.match(CnsMRParser.Size)
                self.state = 961
                self.match(CnsMRParser.Dimensions)
                self.state = 962
                self.match(CnsMRParser.Integer)
                self.state = 964
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
                if la_ == 1:
                    self.state = 963
                    self.match(CnsMRParser.Integer)


                self.state = 967
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
                if la_ == 1:
                    self.state = 966
                    self.match(CnsMRParser.Integer)


                self.state = 970
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Integer:
                    self.state = 969
                    self.match(CnsMRParser.Integer)


                pass
            elif token in [CnsMRParser.Zero]:
                self.enterOuterAlt(localctx, 13)
                self.state = 972
                self.match(CnsMRParser.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 Conf_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(CnsMRParser.Assign, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.RULE_conf_assign

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

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




    def conf_assign(self):

        localctx = CnsMRParser.Conf_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_conf_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 975
            self.match(CnsMRParser.Assign)
            self.state = 976
            self.selection()
            self.state = 977
            self.selection()
            self.state = 978
            self.selection()
            self.state = 979
            self.selection()
            self.state = 985
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.state = 980
                self.selection()
                self.state = 981
                self.selection()
                self.state = 982
                self.selection()
                self.state = 983
                self.selection()


            self.state = 992
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.state = 987
                self.selection()
                self.state = 988
                self.selection()
                self.state = 989
                self.selection()
                self.state = 990
                self.selection()


            self.state = 999
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.L_paren:
                self.state = 994
                self.selection()
                self.state = 995
                self.selection()
                self.state = 996
                self.selection()
                self.state = 997
                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 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(CnsMRParser.Dani_assignContext,0)


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

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


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

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

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

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Diffusion_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_diffusion_statement)
        self._la = 0 # Token type
        try:
            self.state = 1033
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1001
                self.dani_assign()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1002
                self.match(CnsMRParser.Classification)
                self.state = 1004
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1003
                    self.match(CnsMRParser.Equ_op)


                self.state = 1006
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1007
                self.match(CnsMRParser.Coefficients)
                self.state = 1008
                self.number_s()
                self.state = 1009
                self.number_s()
                self.state = 1010
                self.number_s()
                self.state = 1011
                self.number_s()
                self.state = 1012
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1014
                self.match(CnsMRParser.ForceConstant)
                self.state = 1016
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1015
                    self.match(CnsMRParser.Equ_op)


                self.state = 1018
                self.number_s()
                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1019
                self.match(CnsMRParser.Nrestraints)
                self.state = 1021
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1020
                    self.match(CnsMRParser.Equ_op)


                self.state = 1023
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1024
                self.match(CnsMRParser.Potential)
                self.state = 1026
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 1025
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 1028
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1029
                self.match(CnsMRParser.Print)
                self.state = 1030
                self.match(CnsMRParser.Threshold)
                self.state = 1031
                self.number_s()
                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1032
                self.match(CnsMRParser.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 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(CnsMRParser.Assign, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Dani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_dani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1035
            self.match(CnsMRParser.Assign)
            self.state = 1036
            self.selection()
            self.state = 1037
            self.selection()
            self.state = 1038
            self.selection()
            self.state = 1039
            self.selection()
            self.state = 1040
            self.selection()
            self.state = 1041
            self.selection()
            self.state = 1042
            self.number()
            self.state = 1044
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 0):
                self.state = 1043
                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 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(CnsMRParser.One_bond_assignContext,0)


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

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

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


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

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

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

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.One_bond_coupling_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_one_bond_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 1080
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1046
                self.one_bond_assign()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1047
                self.match(CnsMRParser.Classification)
                self.state = 1049
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1048
                    self.match(CnsMRParser.Equ_op)


                self.state = 1051
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1052
                self.match(CnsMRParser.Coefficients)
                self.state = 1053
                self.number_s()
                self.state = 1054
                self.number_s()
                self.state = 1055
                self.number_s()
                self.state = 1056
                self.number_s()
                self.state = 1057
                self.number_s()
                self.state = 1058
                self.number_s()
                self.state = 1059
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1061
                self.match(CnsMRParser.ForceConstant)
                self.state = 1063
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1062
                    self.match(CnsMRParser.Equ_op)


                self.state = 1065
                self.number_s()
                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1066
                self.match(CnsMRParser.Nrestraints)
                self.state = 1068
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1067
                    self.match(CnsMRParser.Equ_op)


                self.state = 1070
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1071
                self.match(CnsMRParser.Potential)
                self.state = 1073
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 1072
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 1075
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1076
                self.match(CnsMRParser.Print)
                self.state = 1077
                self.match(CnsMRParser.Threshold)
                self.state = 1078
                self.number_s()
                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1079
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.One_bond_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_one_bond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1082
            self.match(CnsMRParser.Assign)
            self.state = 1083
            self.selection()
            self.state = 1084
            self.selection()
            self.state = 1085
            self.selection()
            self.state = 1086
            self.selection()
            self.state = 1087
            self.selection()
            self.state = 1088
            self.selection()
            self.state = 1089
            self.selection()
            self.state = 1090
            self.selection()
            self.state = 1091
            self.number()
            self.state = 1092
            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(CnsMRParser.Angle_db_assignContext,0)


        def Classification(self):
            return self.getToken(CnsMRParser.Classification, 0)

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

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

        def DerivFlag(self):
            return self.getToken(CnsMRParser.DerivFlag, 0)

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

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

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


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

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

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

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

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

        def Equ_op_P(self):
            return self.getToken(CnsMRParser.Equ_op_P, 0)

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

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

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

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

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

        def Angle_or_Dihedral(self):
            return self.getToken(CnsMRParser.Angle_or_Dihedral, 0)

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Angle_db_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_angle_db_statement)
        self._la = 0 # Token type
        try:
            self.state = 1146
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1094
                self.angle_db_assign()
                pass
            elif token in [CnsMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1095
                self.match(CnsMRParser.Classification)
                self.state = 1097
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1096
                    self.match(CnsMRParser.Equ_op)


                self.state = 1099
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.DerivFlag]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1100
                self.match(CnsMRParser.DerivFlag)
                self.state = 1102
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1101
                    self.match(CnsMRParser.Equ_op)


                self.state = 1104
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [CnsMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1105
                self.match(CnsMRParser.Expectation)
                self.state = 1106
                self.match(CnsMRParser.Integer)
                self.state = 1107
                self.match(CnsMRParser.Integer)
                self.state = 1108
                self.number_s()
                pass
            elif token in [CnsMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1109
                self.match(CnsMRParser.Error)
                self.state = 1111
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1110
                    self.match(CnsMRParser.Equ_op)


                self.state = 1113
                self.number_s()
                pass
            elif token in [CnsMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1114
                self.match(CnsMRParser.ForceConstant)
                self.state = 1116
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1115
                    self.match(CnsMRParser.Equ_op)


                self.state = 1118
                self.number_s()
                pass
            elif token in [CnsMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1119
                self.match(CnsMRParser.Nrestraints)
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1120
                    self.match(CnsMRParser.Equ_op)


                self.state = 1123
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1124
                self.match(CnsMRParser.Potential)
                self.state = 1126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op_P:
                    self.state = 1125
                    self.match(CnsMRParser.Equ_op_P)


                self.state = 1128
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [CnsMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1129
                self.match(CnsMRParser.Print)
                self.state = 1130
                self.match(CnsMRParser.Threshold)
                self.state = 1131
                self.number_s()
                self.state = 1138
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.All]:
                    self.state = 1132
                    self.match(CnsMRParser.All)
                    pass
                elif token in [CnsMRParser.Classification]:
                    self.state = 1133
                    self.match(CnsMRParser.Classification)
                    self.state = 1135
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Equ_op:
                        self.state = 1134
                        self.match(CnsMRParser.Equ_op)


                    self.state = 1137
                    self.match(CnsMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [CnsMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1140
                self.match(CnsMRParser.Reset)
                pass
            elif token in [CnsMRParser.Size]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1141
                self.match(CnsMRParser.Size)
                self.state = 1142
                self.match(CnsMRParser.Angle_or_Dihedral)
                self.state = 1143
                self.match(CnsMRParser.Integer)
                self.state = 1144
                self.match(CnsMRParser.Integer)
                pass
            elif token in [CnsMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1145
                self.match(CnsMRParser.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(CnsMRParser.Assign, 0)

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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Angle_db_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_angle_db_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1148
            self.match(CnsMRParser.Assign)
            self.state = 1149
            self.selection()
            self.state = 1150
            self.selection()
            self.state = 1151
            self.selection()
            self.state = 1152
            self.selection()
            self.state = 1153
            self.selection()
            self.state = 1154
            self.selection()
            self.state = 1155
            self.selection()
            self.state = 1156
            self.selection()
            self.state = 1157
            self.selection()
            self.state = 1158
            self.selection()
            self.state = 1159
            self.selection()
            self.state = 1161
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.L_paren:
                self.state = 1160
                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 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(CnsMRParser.L_paren, 0)

        def selection_expression(self):
            return self.getTypedRuleContext(CnsMRParser.Selection_expressionContext,0)


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_selection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1163
            self.match(CnsMRParser.L_paren)
            self.state = 1164
            self.selection_expression()
            self.state = 1165
            self.match(CnsMRParser.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(CnsMRParser.TermContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.TermContext,i)


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Selection_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_selection_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1167
            self.term()
            self.state = 1172
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Or_op:
                self.state = 1168
                self.match(CnsMRParser.Or_op)
                self.state = 1169
                self.term()
                self.state = 1174
                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(CnsMRParser.FactorContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.FactorContext,i)


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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.TermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1175
            self.factor(0)
            self.state = 1180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.And_op:
                self.state = 1176
                self.match(CnsMRParser.And_op)
                self.state = 1177
                self.factor(0)
                self.state = 1182
                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(CnsMRParser.L_paren, 0)

        def selection_expression(self):
            return self.getTypedRuleContext(CnsMRParser.Selection_expressionContext,0)


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

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

        def Atom(self):
            return self.getToken(CnsMRParser.Atom, 0)

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

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

        def Integers(self):
            return self.getToken(CnsMRParser.Integers, 0)

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

        def Attribute(self):
            return self.getToken(CnsMRParser.Attribute, 0)

        def Attr_properties(self):
            return self.getToken(CnsMRParser.Attr_properties, 0)

        def Comparison_ops(self):
            return self.getToken(CnsMRParser.Comparison_ops, 0)

        def number_f(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Number_fContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Number_fContext,i)


        def Abs(self):
            return self.getToken(CnsMRParser.Abs, 0)

        def BondedTo(self):
            return self.getToken(CnsMRParser.BondedTo, 0)

        def factor(self):
            return self.getTypedRuleContext(CnsMRParser.FactorContext,0)


        def ByGroup(self):
            return self.getToken(CnsMRParser.ByGroup, 0)

        def ByRes(self):
            return self.getToken(CnsMRParser.ByRes, 0)

        def Chemical(self):
            return self.getToken(CnsMRParser.Chemical, 0)

        def Symbol_name(self):
            return self.getToken(CnsMRParser.Symbol_name, 0)

        def Colon(self):
            return self.getToken(CnsMRParser.Colon, 0)

        def Fbox(self):
            return self.getToken(CnsMRParser.Fbox, 0)

        def Hydrogen(self):
            return self.getToken(CnsMRParser.Hydrogen, 0)

        def Id(self):
            return self.getToken(CnsMRParser.Id, 0)

        def Known(self):
            return self.getToken(CnsMRParser.Known, 0)

        def Name(self):
            return self.getToken(CnsMRParser.Name, 0)

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

        def NONE(self):
            return self.getToken(CnsMRParser.NONE, 0)

        def Not_op(self):
            return self.getToken(CnsMRParser.Not_op, 0)

        def Point(self):
            return self.getToken(CnsMRParser.Point, 0)

        def Cut(self):
            return self.getToken(CnsMRParser.Cut, 0)

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

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

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


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

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

        def Previous(self):
            return self.getToken(CnsMRParser.Previous, 0)

        def Pseudo(self):
            return self.getToken(CnsMRParser.Pseudo, 0)

        def Residue(self):
            return self.getToken(CnsMRParser.Residue, 0)

        def Resname(self):
            return self.getToken(CnsMRParser.Resname, 0)

        def SegIdentifier(self):
            return self.getToken(CnsMRParser.SegIdentifier, 0)

        def Sfbox(self):
            return self.getToken(CnsMRParser.Sfbox, 0)

        def Store_1(self):
            return self.getToken(CnsMRParser.Store_1, 0)

        def Store_2(self):
            return self.getToken(CnsMRParser.Store_2, 0)

        def Store_3(self):
            return self.getToken(CnsMRParser.Store_3, 0)

        def Store_4(self):
            return self.getToken(CnsMRParser.Store_4, 0)

        def Store_5(self):
            return self.getToken(CnsMRParser.Store_5, 0)

        def Store_6(self):
            return self.getToken(CnsMRParser.Store_6, 0)

        def Store_7(self):
            return self.getToken(CnsMRParser.Store_7, 0)

        def Store_8(self):
            return self.getToken(CnsMRParser.Store_8, 0)

        def Store_9(self):
            return self.getToken(CnsMRParser.Store_9, 0)

        def Tag(self):
            return self.getToken(CnsMRParser.Tag, 0)

        def Around(self):
            return self.getToken(CnsMRParser.Around, 0)

        def Saround(self):
            return self.getToken(CnsMRParser.Saround, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.FactorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 102
        self.enterRecursionRule(localctx, 102, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1337
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.state = 1184
                self.match(CnsMRParser.L_paren)
                self.state = 1185
                self.selection_expression()
                self.state = 1186
                self.match(CnsMRParser.R_paren)
                pass

            elif la_ == 2:
                self.state = 1188
                self.match(CnsMRParser.All)
                pass

            elif la_ == 3:
                self.state = 1189
                self.match(CnsMRParser.Atom)
                self.state = 1190
                _la = self._input.LA(1)
                if not(_la==CnsMRParser.Simple_name or _la==CnsMRParser.Simple_names):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1191
                _la = self._input.LA(1)
                if not(_la==CnsMRParser.Integer or _la==CnsMRParser.Integers):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1192
                _la = self._input.LA(1)
                if not(_la==CnsMRParser.Simple_name or _la==CnsMRParser.Simple_names):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                self.state = 1193
                self.match(CnsMRParser.Attribute)
                self.state = 1195
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Abs:
                    self.state = 1194
                    self.match(CnsMRParser.Abs)


                self.state = 1197
                self.match(CnsMRParser.Attr_properties)
                self.state = 1198
                self.match(CnsMRParser.Comparison_ops)
                self.state = 1199
                self.number_f()
                pass

            elif la_ == 5:
                self.state = 1200
                self.match(CnsMRParser.BondedTo)
                self.state = 1201
                self.factor(30)
                pass

            elif la_ == 6:
                self.state = 1202
                self.match(CnsMRParser.ByGroup)
                self.state = 1203
                self.factor(29)
                pass

            elif la_ == 7:
                self.state = 1204
                self.match(CnsMRParser.ByRes)
                self.state = 1205
                self.factor(28)
                pass

            elif la_ == 8:
                self.state = 1206
                self.match(CnsMRParser.Chemical)
                self.state = 1214
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Simple_names]:
                    self.state = 1207
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [CnsMRParser.Simple_name]:
                    self.state = 1208
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1211
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,149,self._ctx)
                    if la_ == 1:
                        self.state = 1209
                        self.match(CnsMRParser.Colon)
                        self.state = 1210
                        self.match(CnsMRParser.Simple_name)


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

                pass

            elif la_ == 9:
                self.state = 1216
                self.match(CnsMRParser.Fbox)
                self.state = 1217
                self.number_f()
                self.state = 1218
                self.number_f()
                self.state = 1219
                self.number_f()
                self.state = 1220
                self.number_f()
                self.state = 1221
                self.number_f()
                self.state = 1222
                self.number_f()
                pass

            elif la_ == 10:
                self.state = 1224
                self.match(CnsMRParser.Hydrogen)
                pass

            elif la_ == 11:
                self.state = 1225
                self.match(CnsMRParser.Id)
                self.state = 1226
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 12:
                self.state = 1227
                self.match(CnsMRParser.Known)
                pass

            elif la_ == 13:
                self.state = 1228
                self.match(CnsMRParser.Name)
                self.state = 1241
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Simple_names]:
                    self.state = 1229
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [CnsMRParser.Simple_name]:
                    self.state = 1230
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1233
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
                    if la_ == 1:
                        self.state = 1231
                        self.match(CnsMRParser.Colon)
                        self.state = 1232
                        self.match(CnsMRParser.Simple_name)


                    pass
                elif token in [CnsMRParser.Double_quote_string]:
                    self.state = 1235
                    self.match(CnsMRParser.Double_quote_string)
                    self.state = 1238
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,152,self._ctx)
                    if la_ == 1:
                        self.state = 1236
                        self.match(CnsMRParser.Colon)
                        self.state = 1237
                        self.match(CnsMRParser.Double_quote_string)


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

                pass

            elif la_ == 14:
                self.state = 1243
                self.match(CnsMRParser.NONE)
                pass

            elif la_ == 15:
                self.state = 1244
                self.match(CnsMRParser.Not_op)
                self.state = 1245
                self.factor(20)
                pass

            elif la_ == 16:
                self.state = 1246
                self.match(CnsMRParser.Point)
                self.state = 1247
                self.match(CnsMRParser.L_paren)
                self.state = 1248
                self.number_f()
                self.state = 1250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Comma:
                    self.state = 1249
                    self.match(CnsMRParser.Comma)


                self.state = 1252
                self.number_f()
                self.state = 1254
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Comma:
                    self.state = 1253
                    self.match(CnsMRParser.Comma)


                self.state = 1256
                self.number_f()
                self.state = 1257
                self.match(CnsMRParser.R_paren)
                self.state = 1258
                self.match(CnsMRParser.Cut)
                self.state = 1259
                self.number_f()
                pass

            elif la_ == 17:
                self.state = 1261
                self.match(CnsMRParser.Point)
                self.state = 1262
                self.match(CnsMRParser.L_paren)
                self.state = 1263
                self.match(CnsMRParser.Tail)
                self.state = 1265
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Equ_op:
                    self.state = 1264
                    self.match(CnsMRParser.Equ_op)


                self.state = 1267
                self.selection()
                self.state = 1269
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Comma:
                    self.state = 1268
                    self.match(CnsMRParser.Comma)


                self.state = 1276
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CnsMRParser.Head:
                    self.state = 1271
                    self.match(CnsMRParser.Head)
                    self.state = 1273
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CnsMRParser.Equ_op:
                        self.state = 1272
                        self.match(CnsMRParser.Equ_op)


                    self.state = 1275
                    self.selection()


                self.state = 1278
                self.match(CnsMRParser.R_paren)
                self.state = 1279
                self.match(CnsMRParser.Cut)
                self.state = 1280
                self.number_f()
                pass

            elif la_ == 18:
                self.state = 1282
                self.match(CnsMRParser.Previous)
                pass

            elif la_ == 19:
                self.state = 1283
                self.match(CnsMRParser.Pseudo)
                pass

            elif la_ == 20:
                self.state = 1284
                self.match(CnsMRParser.Residue)
                self.state = 1292
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Integers]:
                    self.state = 1285
                    self.match(CnsMRParser.Integers)
                    pass
                elif token in [CnsMRParser.Integer]:
                    self.state = 1286
                    self.match(CnsMRParser.Integer)
                    self.state = 1289
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                    if la_ == 1:
                        self.state = 1287
                        self.match(CnsMRParser.Colon)
                        self.state = 1288
                        self.match(CnsMRParser.Integer)


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

                pass

            elif la_ == 21:
                self.state = 1294
                self.match(CnsMRParser.Resname)
                self.state = 1302
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Simple_names]:
                    self.state = 1295
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [CnsMRParser.Simple_name]:
                    self.state = 1296
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1299
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
                    if la_ == 1:
                        self.state = 1297
                        self.match(CnsMRParser.Colon)
                        self.state = 1298
                        self.match(CnsMRParser.Simple_name)


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

                pass

            elif la_ == 22:
                self.state = 1304
                self.match(CnsMRParser.SegIdentifier)
                self.state = 1317
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Simple_names]:
                    self.state = 1305
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [CnsMRParser.Simple_name]:
                    self.state = 1306
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1309
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
                    if la_ == 1:
                        self.state = 1307
                        self.match(CnsMRParser.Colon)
                        self.state = 1308
                        self.match(CnsMRParser.Simple_name)


                    pass
                elif token in [CnsMRParser.Double_quote_string]:
                    self.state = 1311
                    self.match(CnsMRParser.Double_quote_string)
                    self.state = 1314
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
                    if la_ == 1:
                        self.state = 1312
                        self.match(CnsMRParser.Colon)
                        self.state = 1313
                        self.match(CnsMRParser.Double_quote_string)


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

                pass

            elif la_ == 23:
                self.state = 1319
                self.match(CnsMRParser.Sfbox)
                self.state = 1320
                self.number_f()
                self.state = 1321
                self.number_f()
                self.state = 1322
                self.number_f()
                self.state = 1323
                self.number_f()
                self.state = 1324
                self.number_f()
                self.state = 1325
                self.number_f()
                pass

            elif la_ == 24:
                self.state = 1327
                self.match(CnsMRParser.Store_1)
                pass

            elif la_ == 25:
                self.state = 1328
                self.match(CnsMRParser.Store_2)
                pass

            elif la_ == 26:
                self.state = 1329
                self.match(CnsMRParser.Store_3)
                pass

            elif la_ == 27:
                self.state = 1330
                self.match(CnsMRParser.Store_4)
                pass

            elif la_ == 28:
                self.state = 1331
                self.match(CnsMRParser.Store_5)
                pass

            elif la_ == 29:
                self.state = 1332
                self.match(CnsMRParser.Store_6)
                pass

            elif la_ == 30:
                self.state = 1333
                self.match(CnsMRParser.Store_7)
                pass

            elif la_ == 31:
                self.state = 1334
                self.match(CnsMRParser.Store_8)
                pass

            elif la_ == 32:
                self.state = 1335
                self.match(CnsMRParser.Store_9)
                pass

            elif la_ == 33:
                self.state = 1336
                self.match(CnsMRParser.Tag)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1347
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,169,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 = 1345
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
                    if la_ == 1:
                        localctx = CnsMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1339
                        if not self.precpred(self._ctx, 33):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 33)")
                        self.state = 1340
                        self.match(CnsMRParser.Around)
                        self.state = 1341
                        self.number_f()
                        pass

                    elif la_ == 2:
                        localctx = CnsMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1342
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 1343
                        self.match(CnsMRParser.Saround)
                        self.state = 1344
                        self.number_f()
                        pass

             
                self.state = 1349
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,169,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(CnsMRParser.Real, 0)

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

        def Symbol_name(self):
            return self.getToken(CnsMRParser.Symbol_name, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1350
            _la = self._input.LA(1)
            if not(((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 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(CnsMRParser.Real, 0)

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Number_fContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_number_f)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1352
            _la = self._input.LA(1)
            if not(_la==CnsMRParser.Integer or _la==CnsMRParser.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(CnsMRParser.Real, 0)

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

        def Symbol_name(self):
            return self.getToken(CnsMRParser.Symbol_name, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Number_sContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_number_s)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1354
            _la = self._input.LA(1)
            if not(((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (CnsMRParser.Integer - 136)) | (1 << (CnsMRParser.Real - 136)) | (1 << (CnsMRParser.Symbol_name - 136)))) != 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(CnsMRParser.Real, 0)

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Number_aContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_number_a)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1356
            _la = self._input.LA(1)
            if not(_la==CnsMRParser.Integer or _la==CnsMRParser.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 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(CnsMRParser.Flags, 0)

        def Include(self):
            return self.getToken(CnsMRParser.Include, 0)

        def End_F(self):
            return self.getToken(CnsMRParser.End_F, 0)

        def Exclude(self):
            return self.getToken(CnsMRParser.Exclude, 0)

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

        def Any_class(self):
            return self.getToken(CnsMRParser.Any_class, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Flag_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_flag_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1358
            self.match(CnsMRParser.Flags)
            self.state = 1369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.Exclude:
                self.state = 1359
                self.match(CnsMRParser.Exclude)
                self.state = 1367
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Include, CnsMRParser.Class_name]:
                    self.state = 1363
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==CnsMRParser.Class_name:
                        self.state = 1360
                        self.match(CnsMRParser.Class_name)
                        self.state = 1365
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

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



            self.state = 1371
            self.match(CnsMRParser.Include)
            self.state = 1375
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Class_name:
                self.state = 1372
                self.match(CnsMRParser.Class_name)
                self.state = 1377
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1378
            self.match(CnsMRParser.End_F)
        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(CnsMRParser.Vector, 0)

        def vector_mode(self):
            return self.getTypedRuleContext(CnsMRParser.Vector_modeContext,0)


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


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Vector_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_vector_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1380
            self.match(CnsMRParser.Vector)
            self.state = 1381
            self.vector_mode()
            self.state = 1382
            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(CnsMRParser.Vector_expressionContext,0)


        def R_paren_VE(self):
            return self.getToken(CnsMRParser.R_paren_VE, 0)

        def Do_Lp(self):
            return self.getToken(CnsMRParser.Do_Lp, 0)

        def Identify_Lp(self):
            return self.getToken(CnsMRParser.Identify_Lp, 0)

        def Show(self):
            return self.getToken(CnsMRParser.Show, 0)

        def vector_show_property(self):
            return self.getTypedRuleContext(CnsMRParser.Vector_show_propertyContext,0)


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Vector_modeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_vector_mode)
        self._la = 0 # Token type
        try:
            self.state = 1390
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Do_Lp, CnsMRParser.Identify_Lp]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1384
                _la = self._input.LA(1)
                if not(_la==CnsMRParser.Do_Lp or _la==CnsMRParser.Identify_Lp):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1385
                self.vector_expression()
                self.state = 1386
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Show]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1388
                self.match(CnsMRParser.Show)
                self.state = 1389
                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(CnsMRParser.Atom_properties_VE, 0)

        def Equ_op_VE(self):
            return self.getToken(CnsMRParser.Equ_op_VE, 0)

        def vector_operation(self):
            return self.getTypedRuleContext(CnsMRParser.Vector_operationContext,0)


        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Vector_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_vector_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1392
            self.match(CnsMRParser.Atom_properties_VE)
            self.state = 1395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CnsMRParser.Equ_op_VE:
                self.state = 1393
                self.match(CnsMRParser.Equ_op_VE)
                self.state = 1394
                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(CnsMRParser.VflcContext,0)


        def vector_operation(self):
            return self.getTypedRuleContext(CnsMRParser.Vector_operationContext,0)


        def Add_op_VE(self):
            return self.getToken(CnsMRParser.Add_op_VE, 0)

        def Sub_op_VE(self):
            return self.getToken(CnsMRParser.Sub_op_VE, 0)

        def Mul_op_VE(self):
            return self.getToken(CnsMRParser.Mul_op_VE, 0)

        def Div_op_VE(self):
            return self.getToken(CnsMRParser.Div_op_VE, 0)

        def Exp_op_VE(self):
            return self.getToken(CnsMRParser.Exp_op_VE, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Vector_operationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_vector_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1397
            self.vflc()
            self.state = 1400
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & ((1 << (CnsMRParser.Add_op_VE - 182)) | (1 << (CnsMRParser.Sub_op_VE - 182)) | (1 << (CnsMRParser.Mul_op_VE - 182)) | (1 << (CnsMRParser.Div_op_VE - 182)) | (1 << (CnsMRParser.Exp_op_VE - 182)))) != 0):
                self.state = 1398
                _la = self._input.LA(1)
                if not(((((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & ((1 << (CnsMRParser.Add_op_VE - 182)) | (1 << (CnsMRParser.Sub_op_VE - 182)) | (1 << (CnsMRParser.Mul_op_VE - 182)) | (1 << (CnsMRParser.Div_op_VE - 182)) | (1 << (CnsMRParser.Exp_op_VE - 182)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1399
                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(CnsMRParser.Atom_properties_VE, 0)

        def vector_func_call(self):
            return self.getTypedRuleContext(CnsMRParser.Vector_func_callContext,0)


        def Integer_VE(self):
            return self.getToken(CnsMRParser.Integer_VE, 0)

        def Real_VE(self):
            return self.getToken(CnsMRParser.Real_VE, 0)

        def Simple_name_VE(self):
            return self.getToken(CnsMRParser.Simple_name_VE, 0)

        def Symbol_name_VE(self):
            return self.getToken(CnsMRParser.Symbol_name_VE, 0)

        def Double_quote_string_VE(self):
            return self.getToken(CnsMRParser.Double_quote_string_VE, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.VflcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_vflc)
        try:
            self.state = 1409
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Atom_properties_VE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1402
                self.match(CnsMRParser.Atom_properties_VE)
                pass
            elif token in [CnsMRParser.Abs_VE, CnsMRParser.Acos_VE, CnsMRParser.Cos_VE, CnsMRParser.Decode_VE, CnsMRParser.Encode_VE, CnsMRParser.Exp_VE, CnsMRParser.Gauss_VE, CnsMRParser.Heavy_VE, CnsMRParser.Int_VE, CnsMRParser.Log10_VE, CnsMRParser.Log_VE, CnsMRParser.Max_VE, CnsMRParser.Maxw_VE, CnsMRParser.Min_VE, CnsMRParser.Mod_VE, CnsMRParser.Norm_VE, CnsMRParser.Random_VE, CnsMRParser.Sign_VE, CnsMRParser.Sin_VE, CnsMRParser.Sqrt_VE, CnsMRParser.Tan_VE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1403
                self.vector_func_call()
                pass
            elif token in [CnsMRParser.Integer_VE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1404
                self.match(CnsMRParser.Integer_VE)
                pass
            elif token in [CnsMRParser.Real_VE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1405
                self.match(CnsMRParser.Real_VE)
                pass
            elif token in [CnsMRParser.Simple_name_VE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1406
                self.match(CnsMRParser.Simple_name_VE)
                pass
            elif token in [CnsMRParser.Symbol_name_VE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1407
                self.match(CnsMRParser.Symbol_name_VE)
                pass
            elif token in [CnsMRParser.Double_quote_string_VE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1408
                self.match(CnsMRParser.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(CnsMRParser.Abs_VE, 0)

        def L_paren_VF(self):
            return self.getToken(CnsMRParser.L_paren_VF, 0)

        def vflc(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.VflcContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.VflcContext,i)


        def R_paren_VE(self):
            return self.getToken(CnsMRParser.R_paren_VE, 0)

        def Acos_VE(self):
            return self.getToken(CnsMRParser.Acos_VE, 0)

        def Cos_VE(self):
            return self.getToken(CnsMRParser.Cos_VE, 0)

        def Decode_VE(self):
            return self.getToken(CnsMRParser.Decode_VE, 0)

        def Encode_VE(self):
            return self.getToken(CnsMRParser.Encode_VE, 0)

        def Exp_VE(self):
            return self.getToken(CnsMRParser.Exp_VE, 0)

        def Gauss_VE(self):
            return self.getToken(CnsMRParser.Gauss_VE, 0)

        def Heavy_VE(self):
            return self.getToken(CnsMRParser.Heavy_VE, 0)

        def Int_VE(self):
            return self.getToken(CnsMRParser.Int_VE, 0)

        def Log10_VE(self):
            return self.getToken(CnsMRParser.Log10_VE, 0)

        def Log_VE(self):
            return self.getToken(CnsMRParser.Log_VE, 0)

        def Max_VE(self):
            return self.getToken(CnsMRParser.Max_VE, 0)

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

        def Maxw_VE(self):
            return self.getToken(CnsMRParser.Maxw_VE, 0)

        def Min_VE(self):
            return self.getToken(CnsMRParser.Min_VE, 0)

        def Mod_VE(self):
            return self.getToken(CnsMRParser.Mod_VE, 0)

        def Norm_VE(self):
            return self.getToken(CnsMRParser.Norm_VE, 0)

        def Random_VE(self):
            return self.getToken(CnsMRParser.Random_VE, 0)

        def Sign_VE(self):
            return self.getToken(CnsMRParser.Sign_VE, 0)

        def Sin_VE(self):
            return self.getToken(CnsMRParser.Sin_VE, 0)

        def Sqrt_VE(self):
            return self.getToken(CnsMRParser.Sqrt_VE, 0)

        def Tan_VE(self):
            return self.getToken(CnsMRParser.Tan_VE, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Vector_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_vector_func_call)
        self._la = 0 # Token type
        try:
            self.state = 1530
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CnsMRParser.Abs_VE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1411
                self.match(CnsMRParser.Abs_VE)
                self.state = 1412
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1413
                self.vflc()
                self.state = 1414
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Acos_VE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1416
                self.match(CnsMRParser.Acos_VE)
                self.state = 1417
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1418
                self.vflc()
                self.state = 1419
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Cos_VE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1421
                self.match(CnsMRParser.Cos_VE)
                self.state = 1422
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1423
                self.vflc()
                self.state = 1424
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Decode_VE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1426
                self.match(CnsMRParser.Decode_VE)
                self.state = 1427
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1428
                self.vflc()
                self.state = 1429
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Encode_VE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1431
                self.match(CnsMRParser.Encode_VE)
                self.state = 1432
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1433
                self.vflc()
                self.state = 1434
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Exp_VE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1436
                self.match(CnsMRParser.Exp_VE)
                self.state = 1437
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1438
                self.vflc()
                self.state = 1439
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Gauss_VE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1441
                self.match(CnsMRParser.Gauss_VE)
                self.state = 1442
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1443
                self.vflc()
                self.state = 1444
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Heavy_VE]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1446
                self.match(CnsMRParser.Heavy_VE)
                self.state = 1447
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1448
                self.vflc()
                self.state = 1449
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Int_VE]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1451
                self.match(CnsMRParser.Int_VE)
                self.state = 1452
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1453
                self.vflc()
                self.state = 1454
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Log10_VE]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1456
                self.match(CnsMRParser.Log10_VE)
                self.state = 1457
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1458
                self.vflc()
                self.state = 1459
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Log_VE]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1461
                self.match(CnsMRParser.Log_VE)
                self.state = 1462
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1463
                self.vflc()
                self.state = 1464
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Max_VE]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1466
                self.match(CnsMRParser.Max_VE)
                self.state = 1467
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1468
                self.vflc()
                self.state = 1473
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Comma_VE:
                    self.state = 1469
                    self.match(CnsMRParser.Comma_VE)
                    self.state = 1470
                    self.vflc()
                    self.state = 1475
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1476
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Maxw_VE]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1478
                self.match(CnsMRParser.Maxw_VE)
                self.state = 1479
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1480
                self.vflc()
                self.state = 1481
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Min_VE]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1483
                self.match(CnsMRParser.Min_VE)
                self.state = 1484
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1485
                self.vflc()
                self.state = 1490
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Comma_VE:
                    self.state = 1486
                    self.match(CnsMRParser.Comma_VE)
                    self.state = 1487
                    self.vflc()
                    self.state = 1492
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1493
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Mod_VE]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1495
                self.match(CnsMRParser.Mod_VE)
                self.state = 1496
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1497
                self.vflc()
                self.state = 1498
                self.match(CnsMRParser.Comma_VE)
                self.state = 1499
                self.vflc()
                self.state = 1500
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Norm_VE]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1502
                self.match(CnsMRParser.Norm_VE)
                self.state = 1503
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1504
                self.vflc()
                self.state = 1505
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Random_VE]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1507
                self.match(CnsMRParser.Random_VE)
                self.state = 1508
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1509
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Sign_VE]:
                self.enterOuterAlt(localctx, 18)
                self.state = 1510
                self.match(CnsMRParser.Sign_VE)
                self.state = 1511
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1512
                self.vflc()
                self.state = 1513
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Sin_VE]:
                self.enterOuterAlt(localctx, 19)
                self.state = 1515
                self.match(CnsMRParser.Sin_VE)
                self.state = 1516
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1517
                self.vflc()
                self.state = 1518
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Sqrt_VE]:
                self.enterOuterAlt(localctx, 20)
                self.state = 1520
                self.match(CnsMRParser.Sqrt_VE)
                self.state = 1521
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1522
                self.vflc()
                self.state = 1523
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [CnsMRParser.Tan_VE]:
                self.enterOuterAlt(localctx, 21)
                self.state = 1525
                self.match(CnsMRParser.Tan_VE)
                self.state = 1526
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1527
                self.vflc()
                self.state = 1528
                self.match(CnsMRParser.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(CnsMRParser.L_paren_VS, 0)

        def Atom_properties_VS(self):
            return self.getToken(CnsMRParser.Atom_properties_VS, 0)

        def R_paren_VS(self):
            return self.getToken(CnsMRParser.R_paren_VS, 0)

        def Average_VS(self):
            return self.getToken(CnsMRParser.Average_VS, 0)

        def Element_VS(self):
            return self.getToken(CnsMRParser.Element_VS, 0)

        def Max_VS(self):
            return self.getToken(CnsMRParser.Max_VS, 0)

        def Min_VS(self):
            return self.getToken(CnsMRParser.Min_VS, 0)

        def Norm_VS(self):
            return self.getToken(CnsMRParser.Norm_VS, 0)

        def Rms_VS(self):
            return self.getToken(CnsMRParser.Rms_VS, 0)

        def Sum_VS(self):
            return self.getToken(CnsMRParser.Sum_VS, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Vector_show_propertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_vector_show_property)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1532
            _la = self._input.LA(1)
            if not(((((_la - 221)) & ~0x3f) == 0 and ((1 << (_la - 221)) & ((1 << (CnsMRParser.Average_VS - 221)) | (1 << (CnsMRParser.Element_VS - 221)) | (1 << (CnsMRParser.Max_VS - 221)) | (1 << (CnsMRParser.Min_VS - 221)) | (1 << (CnsMRParser.Norm_VS - 221)) | (1 << (CnsMRParser.Rms_VS - 221)) | (1 << (CnsMRParser.Sum_VS - 221)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1533
            self.match(CnsMRParser.L_paren_VS)
            self.state = 1534
            self.match(CnsMRParser.Atom_properties_VS)
            self.state = 1535
            self.match(CnsMRParser.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(CnsMRParser.Evaluate_Lp, 0)

        def Symbol_name_VE(self):
            return self.getToken(CnsMRParser.Symbol_name_VE, 0)

        def Equ_op_VE(self):
            return self.getToken(CnsMRParser.Equ_op_VE, 0)

        def evaluate_operation(self):
            return self.getTypedRuleContext(CnsMRParser.Evaluate_operationContext,0)


        def R_paren_VE(self):
            return self.getToken(CnsMRParser.R_paren_VE, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Evaluate_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_evaluate_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1537
            self.match(CnsMRParser.Evaluate_Lp)
            self.state = 1538
            self.match(CnsMRParser.Symbol_name_VE)
            self.state = 1539
            self.match(CnsMRParser.Equ_op_VE)
            self.state = 1540
            self.evaluate_operation()
            self.state = 1541
            self.match(CnsMRParser.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(CnsMRParser.VflcContext,0)


        def evaluate_operation(self):
            return self.getTypedRuleContext(CnsMRParser.Evaluate_operationContext,0)


        def Add_op_VE(self):
            return self.getToken(CnsMRParser.Add_op_VE, 0)

        def Sub_op_VE(self):
            return self.getToken(CnsMRParser.Sub_op_VE, 0)

        def Mul_op_VE(self):
            return self.getToken(CnsMRParser.Mul_op_VE, 0)

        def Div_op_VE(self):
            return self.getToken(CnsMRParser.Div_op_VE, 0)

        def Exp_op_VE(self):
            return self.getToken(CnsMRParser.Exp_op_VE, 0)

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Evaluate_operationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_evaluate_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1543
            self.vflc()
            self.state = 1546
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & ((1 << (CnsMRParser.Add_op_VE - 182)) | (1 << (CnsMRParser.Sub_op_VE - 182)) | (1 << (CnsMRParser.Mul_op_VE - 182)) | (1 << (CnsMRParser.Div_op_VE - 182)) | (1 << (CnsMRParser.Exp_op_VE - 182)))) != 0):
                self.state = 1544
                _la = self._input.LA(1)
                if not(((((_la - 182)) & ~0x3f) == 0 and ((1 << (_la - 182)) & ((1 << (CnsMRParser.Add_op_VE - 182)) | (1 << (CnsMRParser.Sub_op_VE - 182)) | (1 << (CnsMRParser.Mul_op_VE - 182)) | (1 << (CnsMRParser.Div_op_VE - 182)) | (1 << (CnsMRParser.Exp_op_VE - 182)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1545
                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 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(CnsMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(CnsMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(CnsMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(CnsMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(CnsMRParser.R_paren_CF, 0)

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

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

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

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


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


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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Noe_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_noe_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1548
            self.match(CnsMRParser.For)
            self.state = 1549
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1550
            self.match(CnsMRParser.In_CF)
            self.state = 1551
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1570
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
            if la_ == 1:
                self.state = 1555
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Integer_CF:
                    self.state = 1552
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1557
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1561
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Real_CF:
                    self.state = 1558
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1563
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1567
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Simple_name_CF:
                    self.state = 1564
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1569
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1572
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1573
            self.match(CnsMRParser.Loop)
            self.state = 1574
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1579
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Assign or _la==CnsMRParser.Evaluate_Lp:
                self.state = 1577
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Evaluate_Lp]:
                    self.state = 1575
                    self.evaluate_statement()
                    pass
                elif token in [CnsMRParser.Assign]:
                    self.state = 1576
                    self.noe_assign()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1582
            self.match(CnsMRParser.End)
            self.state = 1583
            self.match(CnsMRParser.Loop)
            self.state = 1584
            self.match(CnsMRParser.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(CnsMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(CnsMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(CnsMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(CnsMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(CnsMRParser.R_paren_CF, 0)

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

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

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

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


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


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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Dihedral_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_dihedral_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1586
            self.match(CnsMRParser.For)
            self.state = 1587
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1588
            self.match(CnsMRParser.In_CF)
            self.state = 1589
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1608
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
            if la_ == 1:
                self.state = 1593
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Integer_CF:
                    self.state = 1590
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1595
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1599
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Real_CF:
                    self.state = 1596
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1601
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1605
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Simple_name_CF:
                    self.state = 1602
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1607
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1610
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1611
            self.match(CnsMRParser.Loop)
            self.state = 1612
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1617
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Assign or _la==CnsMRParser.Evaluate_Lp:
                self.state = 1615
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Evaluate_Lp]:
                    self.state = 1613
                    self.evaluate_statement()
                    pass
                elif token in [CnsMRParser.Assign]:
                    self.state = 1614
                    self.dihedral_assign()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1620
            self.match(CnsMRParser.End)
            self.state = 1621
            self.match(CnsMRParser.Loop)
            self.state = 1622
            self.match(CnsMRParser.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(CnsMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(CnsMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(CnsMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(CnsMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(CnsMRParser.R_paren_CF, 0)

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

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

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

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


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


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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Sani_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_sani_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1624
            self.match(CnsMRParser.For)
            self.state = 1625
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1626
            self.match(CnsMRParser.In_CF)
            self.state = 1627
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1646
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
            if la_ == 1:
                self.state = 1631
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Integer_CF:
                    self.state = 1628
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1633
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1637
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Real_CF:
                    self.state = 1634
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1639
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1643
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Simple_name_CF:
                    self.state = 1640
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1645
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1648
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1649
            self.match(CnsMRParser.Loop)
            self.state = 1650
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1655
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Assign or _la==CnsMRParser.Evaluate_Lp:
                self.state = 1653
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Evaluate_Lp]:
                    self.state = 1651
                    self.evaluate_statement()
                    pass
                elif token in [CnsMRParser.Assign]:
                    self.state = 1652
                    self.sani_assign()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1658
            self.match(CnsMRParser.End)
            self.state = 1659
            self.match(CnsMRParser.Loop)
            self.state = 1660
            self.match(CnsMRParser.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(CnsMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(CnsMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(CnsMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(CnsMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(CnsMRParser.R_paren_CF, 0)

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

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

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

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


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


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

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

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

        def getRuleIndex(self):
            return CnsMRParser.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 = CnsMRParser.Coup_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_coup_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1662
            self.match(CnsMRParser.For)
            self.state = 1663
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1664
            self.match(CnsMRParser.In_CF)
            self.state = 1665
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1684
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.state = 1669
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Integer_CF:
                    self.state = 1666
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1671
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1675
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Real_CF:
                    self.state = 1672
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1677
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1681
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Simple_name_CF:
                    self.state = 1678
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1683
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1686
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1687
            self.match(CnsMRParser.Loop)
            self.state = 1688
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1693
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Assign or _la==CnsMRParser.Evaluate_Lp:
                self.state = 1691
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Evaluate_Lp]:
                    self.state = 1689
                    self.evaluate_statement()
                    pass
                elif token in [CnsMRParser.Assign]:
                    self.state = 1690
                    self.coup_assign()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1696
            self.match(CnsMRParser.End)
            self.state = 1697
            self.match(CnsMRParser.Loop)
            self.state = 1698
            self.match(CnsMRParser.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 Carbon_shift_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(CnsMRParser.For, 0)

        def Symbol_name_CF(self):
            return self.getToken(CnsMRParser.Symbol_name_CF, 0)

        def In_CF(self):
            return self.getToken(CnsMRParser.In_CF, 0)

        def L_paren_CF(self):
            return self.getToken(CnsMRParser.L_paren_CF, 0)

        def R_paren_CF(self):
            return self.getToken(CnsMRParser.R_paren_CF, 0)

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

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

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

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


        def carbon_shift_assign(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Carbon_shift_assignContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Carbon_shift_assignContext,i)


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

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

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

        def getRuleIndex(self):
            return CnsMRParser.RULE_carbon_shift_assign_loop

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

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




    def carbon_shift_assign_loop(self):

        localctx = CnsMRParser.Carbon_shift_assign_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_carbon_shift_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1700
            self.match(CnsMRParser.For)
            self.state = 1701
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1702
            self.match(CnsMRParser.In_CF)
            self.state = 1703
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1722
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.state = 1707
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Integer_CF:
                    self.state = 1704
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1709
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1713
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Real_CF:
                    self.state = 1710
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1715
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1719
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CnsMRParser.Simple_name_CF:
                    self.state = 1716
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1721
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1724
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1725
            self.match(CnsMRParser.Loop)
            self.state = 1726
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1731
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CnsMRParser.Assign or _la==CnsMRParser.Evaluate_Lp:
                self.state = 1729
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CnsMRParser.Evaluate_Lp]:
                    self.state = 1727
                    self.evaluate_statement()
                    pass
                elif token in [CnsMRParser.Assign]:
                    self.state = 1728
                    self.carbon_shift_assign()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1734
            self.match(CnsMRParser.End)
            self.state = 1735
            self.match(CnsMRParser.Loop)
            self.state = 1736
            self.match(CnsMRParser.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[51] = 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, 33)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 13)
         




