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

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

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'", "'VOL'", "'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>", "'NCS'", "<INVALID>", 
                     "'SIGB'", "<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>", "<INVALID>", "<INVALID>", "'NIL'", 
                     "<INVALID>", "'UB'", "'MULT'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'NONB'", "<INVALID>", "<INVALID>", "'FOR'", 
                     "'LOOP'", "'TAIL'", "'HEAD'", "'OR'", "'AND'", "'NOT'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "':'", "<INVALID>", "'<'", 
                     "'>'", "'<='", "'>='", "'#'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'+'", "'-'", "<INVALID>", "'/'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'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", 
                      "Vol", "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", "Ncs", "Equivalence", "Sigb", 
                      "Flags", "All", "Around", "Atom", "Attribute", "BondedTo", 
                      "ByGroup", "ByRes", "Chemical", "Fbox", "Hydrogen", 
                      "Id", "Known", "Name", "NONE", "Point", "Cut", "Previous", 
                      "Pseudo", "Residue", "Resname", "Saround", "SegIdentifier", 
                      "Sfbox", "Store1", "Store2", "Store3", "Store4", "Store5", 
                      "Store6", "Store7", "Store8", "Store9", "Tag", "Vector", 
                      "Do_Lp", "Identity_Lp", "Show", "Evaluate_Lp", "Patch", 
                      "Reference", "Nil", "Parameter", "UB", "Mult", "HBonded", 
                      "Improper", "NBFix", "NonB", "VDWOff", "Verbose", 
                      "For", "Loop", "Tail", "Head", "Or_op", "And_op", 
                      "Not_op", "Comma", "Complex", "Integer", "Logical", 
                      "Real", "Double_quote_string", "SHARP_COMMENT", "EXCLM_COMMENT", 
                      "SMCLN_COMMENT", "Simple_name", "Simple_names", "Integers", 
                      "L_paren", "R_paren", "Colon", "Equ_op", "Lt_op", 
                      "Gt_op", "Leq_op", "Geq_op", "Neq_op", "Symbol_name", 
                      "SPACE", "ENCLOSE_COMMENT", "SECTION_COMMENT", "LINE_COMMENT", 
                      "SET_VARIABLE", "Abs", "Attr_properties", "Comparison_ops", 
                      "SPACE_AP", "Averaging_methods", "Class_name_AM", 
                      "SPACE_AM", "Equ_op_PT", "Potential_types", "Class_name_PT", 
                      "SPACE_PT", "Noe_analysis", "SPACE_NA", "Exclude", 
                      "Include", "End_FL", "Class_name", "Any_class", "SPACE_FL", 
                      "R_paren_VE", "Equ_op_VE", "Add_op_VE", "Sub_op_VE", 
                      "Mul_op_VE", "Div_op_VE", "Exp_op_VE", "Comma_VE", 
                      "Integer_VE", "Real_VE", "Atom_properties_VE", "Abs_VE", 
                      "Acos_VE", "Asin_VE", "Cos_VE", "Decode_VE", "Encode_VE", 
                      "Exp_VE", "Gauss_VE", "Heavy_VE", "Int_VE", "Log10_VE", 
                      "Log_VE", "Max_VE", "Maxw_VE", "Min_VE", "Mod_VE", 
                      "Norm_VE", "Random_VE", "Sign_VE", "Sin_VE", "Sqrt_VE", 
                      "Tan_VE", "Symbol_name_VE", "Simple_name_VE", "Double_quote_string_VE", 
                      "SPACE_VE", "L_paren_VF", "SPACE_VF", "L_paren_VS", 
                      "R_paren_VS", "Average_VS", "Element_VS", "Max_VS", 
                      "Min_VS", "Norm_VS", "Rms_VS", "Sum_VS", "Atom_properties_VS", 
                      "SPACE_VS", "L_paren_CF", "R_paren_CF", "In_CF", "Integer_CF", 
                      "Real_CF", "Symbol_name_CF", "Simple_name_CF", "SPACE_CF", 
                      "COMMENT_CF", "Simple_name_LL", "SPACE_LL" ]

    RULE_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_plane_group = 20
    RULE_group_statement = 21
    RULE_harmonic_statement = 22
    RULE_harmonic_assign = 23
    RULE_sani_statement = 24
    RULE_sani_assign = 25
    RULE_coupling_statement = 26
    RULE_coup_assign = 27
    RULE_carbon_shift_statement = 28
    RULE_carbon_shift_assign = 29
    RULE_carbon_shift_rcoil = 30
    RULE_proton_shift_statement = 31
    RULE_observed = 32
    RULE_proton_shift_rcoil = 33
    RULE_proton_shift_anisotropy = 34
    RULE_proton_shift_amides = 35
    RULE_proton_shift_carbons = 36
    RULE_proton_shift_nitrogens = 37
    RULE_proton_shift_oxygens = 38
    RULE_proton_shift_ring_atoms = 39
    RULE_proton_shift_alphas_and_amides = 40
    RULE_conformation_statement = 41
    RULE_conf_assign = 42
    RULE_diffusion_statement = 43
    RULE_dani_assign = 44
    RULE_one_bond_coupling_statement = 45
    RULE_one_bond_assign = 46
    RULE_angle_db_statement = 47
    RULE_angle_db_assign = 48
    RULE_ncs_restraint = 49
    RULE_ncs_statement = 50
    RULE_ncs_group_statement = 51
    RULE_selection = 52
    RULE_selection_expression = 53
    RULE_term = 54
    RULE_factor = 55
    RULE_number = 56
    RULE_number_f = 57
    RULE_number_s = 58
    RULE_number_a = 59
    RULE_classification = 60
    RULE_class_name = 61
    RULE_flag_statement = 62
    RULE_vector_statement = 63
    RULE_vector_mode = 64
    RULE_vector_expression = 65
    RULE_vector_operation = 66
    RULE_vflc = 67
    RULE_vector_func_call = 68
    RULE_vector_show_property = 69
    RULE_evaluate_statement = 70
    RULE_evaluate_operation = 71
    RULE_patch_statement = 72
    RULE_parameter_setting = 73
    RULE_parameter_statement = 74
    RULE_noe_assign_loop = 75
    RULE_dihedral_assign_loop = 76
    RULE_sani_assign_loop = 77
    RULE_coup_assign_loop = 78
    RULE_carbon_shift_assign_loop = 79
    RULE_plane_group_loop = 80

    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", 
                   "plane_group", "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", "ncs_restraint", 
                   "ncs_statement", "ncs_group_statement", "selection", 
                   "selection_expression", "term", "factor", "number", "number_f", 
                   "number_s", "number_a", "classification", "class_name", 
                   "flag_statement", "vector_statement", "vector_mode", 
                   "vector_expression", "vector_operation", "vflc", "vector_func_call", 
                   "vector_show_property", "evaluate_statement", "evaluate_operation", 
                   "patch_statement", "parameter_setting", "parameter_statement", 
                   "noe_assign_loop", "dihedral_assign_loop", "sani_assign_loop", 
                   "coup_assign_loop", "carbon_shift_assign_loop", "plane_group_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
    Vol=46
    Ppm1=47
    Ppm2=48
    Restraints=49
    Dihedral=50
    Nassign=51
    Print_any=52
    Plane=53
    Group=54
    Selection=55
    Weight=56
    Harmonic=57
    Exponent=58
    Normal=59
    Sanisotropy=60
    Coefficients=61
    ForceConstant=62
    Coupling=63
    Carbon=64
    Expectation=65
    PhiStep=66
    PsiStep=67
    Rcoil=68
    Zero=69
    Proton=70
    Observed=71
    Anisotropy=72
    Amides=73
    Nitrogens=74
    Oxygens=75
    RingAtoms=76
    AlphasAndAmides=77
    Error=78
    Conformation=79
    Compressed=80
    Phase=81
    Size=82
    Dimensions=83
    Danisotropy=84
    OneBond=85
    AngleDb=86
    DerivFlag=87
    Ncs=88
    Equivalence=89
    Sigb=90
    Flags=91
    All=92
    Around=93
    Atom=94
    Attribute=95
    BondedTo=96
    ByGroup=97
    ByRes=98
    Chemical=99
    Fbox=100
    Hydrogen=101
    Id=102
    Known=103
    Name=104
    NONE=105
    Point=106
    Cut=107
    Previous=108
    Pseudo=109
    Residue=110
    Resname=111
    Saround=112
    SegIdentifier=113
    Sfbox=114
    Store1=115
    Store2=116
    Store3=117
    Store4=118
    Store5=119
    Store6=120
    Store7=121
    Store8=122
    Store9=123
    Tag=124
    Vector=125
    Do_Lp=126
    Identity_Lp=127
    Show=128
    Evaluate_Lp=129
    Patch=130
    Reference=131
    Nil=132
    Parameter=133
    UB=134
    Mult=135
    HBonded=136
    Improper=137
    NBFix=138
    NonB=139
    VDWOff=140
    Verbose=141
    For=142
    Loop=143
    Tail=144
    Head=145
    Or_op=146
    And_op=147
    Not_op=148
    Comma=149
    Complex=150
    Integer=151
    Logical=152
    Real=153
    Double_quote_string=154
    SHARP_COMMENT=155
    EXCLM_COMMENT=156
    SMCLN_COMMENT=157
    Simple_name=158
    Simple_names=159
    Integers=160
    L_paren=161
    R_paren=162
    Colon=163
    Equ_op=164
    Lt_op=165
    Gt_op=166
    Leq_op=167
    Geq_op=168
    Neq_op=169
    Symbol_name=170
    SPACE=171
    ENCLOSE_COMMENT=172
    SECTION_COMMENT=173
    LINE_COMMENT=174
    SET_VARIABLE=175
    Abs=176
    Attr_properties=177
    Comparison_ops=178
    SPACE_AP=179
    Averaging_methods=180
    Class_name_AM=181
    SPACE_AM=182
    Equ_op_PT=183
    Potential_types=184
    Class_name_PT=185
    SPACE_PT=186
    Noe_analysis=187
    SPACE_NA=188
    Exclude=189
    Include=190
    End_FL=191
    Class_name=192
    Any_class=193
    SPACE_FL=194
    R_paren_VE=195
    Equ_op_VE=196
    Add_op_VE=197
    Sub_op_VE=198
    Mul_op_VE=199
    Div_op_VE=200
    Exp_op_VE=201
    Comma_VE=202
    Integer_VE=203
    Real_VE=204
    Atom_properties_VE=205
    Abs_VE=206
    Acos_VE=207
    Asin_VE=208
    Cos_VE=209
    Decode_VE=210
    Encode_VE=211
    Exp_VE=212
    Gauss_VE=213
    Heavy_VE=214
    Int_VE=215
    Log10_VE=216
    Log_VE=217
    Max_VE=218
    Maxw_VE=219
    Min_VE=220
    Mod_VE=221
    Norm_VE=222
    Random_VE=223
    Sign_VE=224
    Sin_VE=225
    Sqrt_VE=226
    Tan_VE=227
    Symbol_name_VE=228
    Simple_name_VE=229
    Double_quote_string_VE=230
    SPACE_VE=231
    L_paren_VF=232
    SPACE_VF=233
    L_paren_VS=234
    R_paren_VS=235
    Average_VS=236
    Element_VS=237
    Max_VS=238
    Min_VS=239
    Norm_VS=240
    Rms_VS=241
    Sum_VS=242
    Atom_properties_VS=243
    SPACE_VS=244
    L_paren_CF=245
    R_paren_CF=246
    In_CF=247
    Integer_CF=248
    Real_CF=249
    Symbol_name_CF=250
    Simple_name_CF=251
    SPACE_CF=252
    COMMENT_CF=253
    Simple_name_LL=254
    SPACE_LL=255

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




    class 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 ncs_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Ncs_restraintContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Ncs_restraintContext,i)


        def classification(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.ClassificationContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.ClassificationContext,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 patch_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Patch_statementContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Patch_statementContext,i)


        def parameter_setting(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Parameter_settingContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Parameter_settingContext,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 parameter_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Parameter_statementContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Parameter_statementContext,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 = 197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & -7893121262493367256) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 2305843013667029185) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & 16275) != 0):
                self.state = 195
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 162
                    self.distance_restraint()
                    pass

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

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

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

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

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

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

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

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

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

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

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

                elif la_ == 13:
                    self.state = 174
                    self.ncs_restraint()
                    pass

                elif la_ == 14:
                    self.state = 175
                    self.classification()
                    pass

                elif la_ == 15:
                    self.state = 176
                    self.flag_statement()
                    pass

                elif la_ == 16:
                    self.state = 177
                    self.vector_statement()
                    pass

                elif la_ == 17:
                    self.state = 178
                    self.evaluate_statement()
                    pass

                elif la_ == 18:
                    self.state = 179
                    self.patch_statement()
                    pass

                elif la_ == 19:
                    self.state = 180
                    self.parameter_setting()
                    pass

                elif la_ == 20:
                    self.state = 181
                    self.noe_assign_loop()
                    pass

                elif la_ == 21:
                    self.state = 182
                    self.dihedral_assign_loop()
                    pass

                elif la_ == 22:
                    self.state = 183
                    self.sani_assign_loop()
                    pass

                elif la_ == 23:
                    self.state = 184
                    self.coup_assign_loop()
                    pass

                elif la_ == 24:
                    self.state = 185
                    self.carbon_shift_assign_loop()
                    pass

                elif la_ == 25:
                    self.state = 186
                    self.noe_assign()
                    pass

                elif la_ == 26:
                    self.state = 187
                    self.dihedral_assign()
                    pass

                elif la_ == 27:
                    self.state = 188
                    self.sani_assign()
                    pass

                elif la_ == 28:
                    self.state = 189
                    self.plane_statement()
                    pass

                elif la_ == 29:
                    self.state = 190
                    self.harmonic_assign()
                    pass

                elif la_ == 30:
                    self.state = 191
                    self.coup_assign()
                    pass

                elif la_ == 31:
                    self.state = 192
                    self.carbon_shift_assign()
                    pass

                elif la_ == 32:
                    self.state = 193
                    self.observed()
                    pass

                elif la_ == 33:
                    self.state = 194
                    self.parameter_statement()
                    pass


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

            self.state = 200
            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 = 202
            self.match(CnsMRParser.Noe)
            self.state = 206
            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 = 203
                    self.noe_statement() 
                self.state = 208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

            self.state = 209
            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 = 212
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==49:
                self.state = 211
                self.match(CnsMRParser.Restraints)


            self.state = 214
            self.match(CnsMRParser.Dihedral)
            self.state = 218
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 6755399777652768) != 0) or _la==125 or _la==142:
                self.state = 215
                self.dihedral_statement()
                self.state = 220
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 221
            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 = 224
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==49:
                self.state = 223
                self.match(CnsMRParser.Restraints)


            self.state = 226
            self.match(CnsMRParser.Plane)
            self.state = 230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 22518032496590848) != 0) or _la==125 or _la==142:
                self.state = 227
                self.plane_statement()
                self.state = 232
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 233
            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 = 236
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==49:
                self.state = 235
                self.match(CnsMRParser.Restraints)


            self.state = 238
            self.match(CnsMRParser.Harmonic)
            self.state = 242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==58 or _la==59 or _la==125:
                self.state = 239
                self.harmonic_statement()
                self.state = 244
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 245
            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 = 247
            self.match(CnsMRParser.Sanisotropy)
            self.state = 251
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 6917529027718939680) != 0) or _la==142:
                self.state = 248
                self.sani_statement()
                self.state = 253
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 254
            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 = 256
            self.match(CnsMRParser.Coupling)
            self.state = 260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 6917529027719992352) != 0) or _la==142:
                self.state = 257
                self.coupling_statement()
                self.state = 262
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 263
            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 = 265
            self.match(CnsMRParser.Carbon)
            self.state = 269
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4611686018505245728) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 31) != 0) or _la==142:
                self.state = 266
                self.carbon_shift_statement()
                self.state = 271
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 272
            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 = 274
            self.match(CnsMRParser.Proton)
            self.state = 278
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4611686018504983552) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 32657) != 0):
                self.state = 275
                self.proton_shift_statement()
                self.state = 280
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 281
            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 = 283
            self.match(CnsMRParser.Conformation)
            self.state = 287
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4611686018505245728) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 237585) != 0):
                self.state = 284
                self.conformation_statement()
                self.state = 289
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 290
            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 = 292
            self.match(CnsMRParser.Danisotropy)
            self.state = 296
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 6917529027718939680) != 0):
                self.state = 293
                self.diffusion_statement()
                self.state = 298
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 299
            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 = 301
            self.match(CnsMRParser.OneBond)
            self.state = 305
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 6917529027718939680) != 0):
                self.state = 302
                self.one_bond_coupling_statement()
                self.state = 307
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 308
            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 = 310
            self.match(CnsMRParser.AngleDb)
            self.state = 314
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4611686018505245728) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 4333585) != 0):
                self.state = 311
                self.angle_db_statement()
                self.state = 316
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 317
            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 class_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Class_nameContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Class_nameContext,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 Class_name_AM(self):
            return self.getToken(CnsMRParser.Class_name_AM, 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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Class_name_PT(self):
            return self.getToken(CnsMRParser.Class_name_PT, 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 = 455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 319
                self.match(CnsMRParser.Analysis)
                self.state = 321
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 320
                    self.match(CnsMRParser.Equ_op)


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

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

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

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 326
                self.match(CnsMRParser.Asymptote)
                self.state = 327
                self.class_name()
                self.state = 328
                self.number_s()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 330
                self.match(CnsMRParser.Average)
                self.state = 331
                self.match(CnsMRParser.Class_name_AM)
                self.state = 332
                self.match(CnsMRParser.Averaging_methods)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 333
                self.match(CnsMRParser.Bhig)
                self.state = 334
                self.class_name()
                self.state = 335
                self.number_s()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 337
                self.match(CnsMRParser.Ceiling)
                self.state = 339
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 338
                    self.match(CnsMRParser.Equ_op)


                self.state = 341
                self.number_s()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 342
                self.classification()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 343
                self.match(CnsMRParser.CountViol)
                self.state = 344
                self.class_name()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 345
                self.match(CnsMRParser.Cv)
                self.state = 347
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 346
                    self.match(CnsMRParser.Equ_op)


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

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

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 352
                self.match(CnsMRParser.Den)
                self.state = 353
                self.match(CnsMRParser.Update)
                self.state = 354
                self.match(CnsMRParser.Gamma)
                self.state = 356
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 355
                    self.match(CnsMRParser.Equ_op)


                self.state = 358
                self.number_s()
                self.state = 359
                self.match(CnsMRParser.Kappa)
                self.state = 361
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 360
                    self.match(CnsMRParser.Equ_op)


                self.state = 363
                self.number_s()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 365
                self.match(CnsMRParser.Distribute)
                self.state = 366
                self.class_name()
                self.state = 367
                self.class_name()
                self.state = 368
                self.number_s()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 373
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 370
                        self.match(CnsMRParser.Ensemble) 
                    self.state = 375
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

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

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 377
                self.match(CnsMRParser.Monomers)
                self.state = 378
                self.class_name()
                self.state = 379
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 381
                self.match(CnsMRParser.Ncount)
                self.state = 382
                self.class_name()
                self.state = 383
                self.match(CnsMRParser.Integer)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 385
                self.match(CnsMRParser.Nrestraints)
                self.state = 387
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 386
                    self.match(CnsMRParser.Equ_op)


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

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

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 391
                self.match(CnsMRParser.Partition)
                self.state = 393
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 392
                    self.match(CnsMRParser.Equ_op)


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

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 396
                self.match(CnsMRParser.Potential)
                self.state = 397
                self.match(CnsMRParser.Class_name_PT)
                self.state = 398
                self.match(CnsMRParser.Potential_types)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 399
                self.match(CnsMRParser.Predict)
                self.state = 400
                self.predict_statement()
                self.state = 401
                self.match(CnsMRParser.End)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 403
                self.match(CnsMRParser.Print)
                self.state = 404
                self.match(CnsMRParser.Threshold)
                self.state = 406
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 405
                    self.match(CnsMRParser.Equ_op)


                self.state = 408
                self.number_s()
                pass

            elif la_ == 23:
                self.enterOuterAlt(localctx, 23)
                self.state = 409
                self.match(CnsMRParser.Raverage)
                self.state = 413
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
                while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1+1:
                        self.state = 410
                        self.class_name() 
                    self.state = 415
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,26,self._ctx)

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

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

            elif la_ == 25:
                self.enterOuterAlt(localctx, 25)
                self.state = 418
                self.match(CnsMRParser.Rswitch)
                self.state = 419
                self.class_name()
                self.state = 420
                self.number_s()
                pass

            elif la_ == 26:
                self.enterOuterAlt(localctx, 26)
                self.state = 422
                self.match(CnsMRParser.Scale)
                self.state = 423
                self.class_name()
                self.state = 424
                self.number_s()
                pass

            elif la_ == 27:
                self.enterOuterAlt(localctx, 27)
                self.state = 426
                self.match(CnsMRParser.SoExponent)
                self.state = 427
                self.class_name()
                self.state = 428
                self.number_s()
                pass

            elif la_ == 28:
                self.enterOuterAlt(localctx, 28)
                self.state = 430
                self.match(CnsMRParser.SqConstant)
                self.state = 431
                self.class_name()
                self.state = 432
                self.number_s()
                pass

            elif la_ == 29:
                self.enterOuterAlt(localctx, 29)
                self.state = 434
                self.match(CnsMRParser.SqExponent)
                self.state = 435
                self.class_name()
                self.state = 436
                self.number_s()
                pass

            elif la_ == 30:
                self.enterOuterAlt(localctx, 30)
                self.state = 438
                self.match(CnsMRParser.SqOffset)
                self.state = 439
                self.class_name()
                self.state = 440
                self.number_s()
                pass

            elif la_ == 31:
                self.enterOuterAlt(localctx, 31)
                self.state = 442
                self.match(CnsMRParser.Taverage)
                self.state = 446
                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 = 443
                        self.class_name() 
                    self.state = 448
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,27,self._ctx)

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

            elif la_ == 32:
                self.enterOuterAlt(localctx, 32)
                self.state = 450
                self.match(CnsMRParser.Temperature)
                self.state = 452
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 451
                    self.match(CnsMRParser.Equ_op)


                self.state = 454
                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 = 457
            self.match(CnsMRParser.Assign)
            self.state = 458
            self.selection()
            self.state = 459
            self.selection()
            self.state = 460
            self.number()
            self.state = 462
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 461
                self.number()


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


            self.state = 470
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 467
                    self.noe_annotation() 
                self.state = 472
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,32,self._ctx)

            self.state = 490
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==146:
                self.state = 473
                self.match(CnsMRParser.Or_op)
                self.state = 475
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 474
                    self.match(CnsMRParser.Assign)


                self.state = 477
                self.selection()
                self.state = 478
                self.selection()
                self.state = 480
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                if la_ == 1:
                    self.state = 479
                    self.number()


                self.state = 483
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                if la_ == 1:
                    self.state = 482
                    self.number()


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


                self.state = 492
                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 = 507
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [39]:
                self.enterOuterAlt(localctx, 1)
                self.state = 493
                self.match(CnsMRParser.Cutoff)
                self.state = 495
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 494
                    self.match(CnsMRParser.Equ_op)


                self.state = 497
                self.number_s()
                pass
            elif token in [40]:
                self.enterOuterAlt(localctx, 2)
                self.state = 498
                self.match(CnsMRParser.Cuton)
                self.state = 500
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 499
                    self.match(CnsMRParser.Equ_op)


                self.state = 502
                self.number_s()
                pass
            elif token in [41]:
                self.enterOuterAlt(localctx, 3)
                self.state = 503
                self.match(CnsMRParser.From)
                self.state = 504
                self.selection()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 4)
                self.state = 505
                self.match(CnsMRParser.To)
                self.state = 506
                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 Vol(self):
            return self.getToken(CnsMRParser.Vol, 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 Comma(self):
            return self.getToken(CnsMRParser.Comma, 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 = 545
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [43]:
                self.enterOuterAlt(localctx, 1)
                self.state = 509
                self.match(CnsMRParser.Peak)
                self.state = 511
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 510
                    self.match(CnsMRParser.Equ_op)


                self.state = 513
                self.number_a()
                pass
            elif token in [44]:
                self.enterOuterAlt(localctx, 2)
                self.state = 514
                self.match(CnsMRParser.Spectrum)
                self.state = 516
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 515
                    self.match(CnsMRParser.Equ_op)


                self.state = 518
                self.number_a()
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 3)
                self.state = 519
                self.match(CnsMRParser.Weight)
                self.state = 521
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 520
                    self.match(CnsMRParser.Equ_op)


                self.state = 523
                self.number_a()
                pass
            elif token in [45, 46]:
                self.enterOuterAlt(localctx, 4)
                self.state = 524
                _la = self._input.LA(1)
                if not(_la==45 or _la==46):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 525
                    self.match(CnsMRParser.Equ_op)


                self.state = 528
                self.number_a()
                pass
            elif token in [47]:
                self.enterOuterAlt(localctx, 5)
                self.state = 529
                self.match(CnsMRParser.Ppm1)
                self.state = 531
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 530
                    self.match(CnsMRParser.Equ_op)


                self.state = 533
                self.number_a()
                pass
            elif token in [48]:
                self.enterOuterAlt(localctx, 6)
                self.state = 534
                self.match(CnsMRParser.Ppm2)
                self.state = 536
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 535
                    self.match(CnsMRParser.Equ_op)


                self.state = 538
                self.number_a()
                pass
            elif token in [12]:
                self.enterOuterAlt(localctx, 7)
                self.state = 539
                self.match(CnsMRParser.Cv)
                self.state = 541
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 540
                    self.match(CnsMRParser.Equ_op)


                self.state = 543
                self.number_a()
                pass
            elif token in [149]:
                self.enterOuterAlt(localctx, 8)
                self.state = 544
                self.match(CnsMRParser.Comma)
                pass
            else:
                raise NoViableAltException(self)

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


    class Dihedral_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        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 = 572
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [125]:
                self.enterOuterAlt(localctx, 1)
                self.state = 547
                self.vector_statement()
                pass
            elif token in [5]:
                self.enterOuterAlt(localctx, 2)
                self.state = 548
                self.dihedral_assign()
                pass
            elif token in [142]:
                self.enterOuterAlt(localctx, 3)
                self.state = 549
                self.dihedral_assign_loop()
                pass
            elif token in [12]:
                self.enterOuterAlt(localctx, 4)
                self.state = 550
                self.match(CnsMRParser.Cv)
                self.state = 552
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 551
                    self.match(CnsMRParser.Equ_op)


                self.state = 554
                self.match(CnsMRParser.Integer)
                pass
            elif token in [51]:
                self.enterOuterAlt(localctx, 5)
                self.state = 555
                self.match(CnsMRParser.Nassign)
                self.state = 557
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 556
                    self.match(CnsMRParser.Equ_op)


                self.state = 559
                self.match(CnsMRParser.Integer)
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 6)
                self.state = 560
                self.match(CnsMRParser.Partition)
                self.state = 562
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 561
                    self.match(CnsMRParser.Equ_op)


                self.state = 564
                self.match(CnsMRParser.Integer)
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 7)
                self.state = 565
                self.match(CnsMRParser.Reset)
                pass
            elif token in [28]:
                self.enterOuterAlt(localctx, 8)
                self.state = 566
                self.match(CnsMRParser.Scale)
                self.state = 568
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 567
                    self.match(CnsMRParser.Equ_op)


                self.state = 570
                self.number_s()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 9)
                self.state = 571
                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 = 574
            self.match(CnsMRParser.Assign)
            self.state = 575
            self.selection()
            self.state = 576
            self.selection()
            self.state = 577
            self.selection()
            self.state = 578
            self.selection()
            self.state = 579
            self.number()
            self.state = 580
            self.number()
            self.state = 581
            self.number()
            self.state = 582
            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 vector_statement(self):
            return self.getTypedRuleContext(CnsMRParser.Vector_statementContext,0)


        def plane_group(self):
            return self.getTypedRuleContext(CnsMRParser.Plane_groupContext,0)


        def plane_group_loop(self):
            return self.getTypedRuleContext(CnsMRParser.Plane_group_loopContext,0)


        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)
        try:
            self.state = 589
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [125]:
                self.enterOuterAlt(localctx, 1)
                self.state = 584
                self.vector_statement()
                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 585
                self.plane_group()
                pass
            elif token in [142]:
                self.enterOuterAlt(localctx, 3)
                self.state = 586
                self.plane_group_loop()
                pass
            elif token in [35]:
                self.enterOuterAlt(localctx, 4)
                self.state = 587
                self.match(CnsMRParser.Initialize)
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 5)
                self.state = 588
                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 Plane_groupContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Group(self):
            return self.getToken(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 getRuleIndex(self):
            return CnsMRParser.RULE_plane_group

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

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




    def plane_group(self):

        localctx = CnsMRParser.Plane_groupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_plane_group)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 591
            self.match(CnsMRParser.Group)
            self.state = 595
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==55 or _la==56:
                self.state = 592
                self.group_statement()
                self.state = 597
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 598
            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 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, 42, self.RULE_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 610
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [55]:
                self.enterOuterAlt(localctx, 1)
                self.state = 600
                self.match(CnsMRParser.Selection)
                self.state = 602
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 601
                    self.match(CnsMRParser.Equ_op)


                self.state = 604
                self.selection()
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 2)
                self.state = 605
                self.match(CnsMRParser.Weight)
                self.state = 607
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 606
                    self.match(CnsMRParser.Equ_op)


                self.state = 609
                self.number_s()
                pass
            else:
                raise NoViableAltException(self)

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


    class Harmonic_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        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, 44, self.RULE_harmonic_statement)
        self._la = 0 # Token type
        try:
            self.state = 652
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [125]:
                self.enterOuterAlt(localctx, 1)
                self.state = 612
                self.vector_statement()
                pass
            elif token in [58]:
                self.enterOuterAlt(localctx, 2)
                self.state = 613
                self.match(CnsMRParser.Exponent)
                self.state = 615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 614
                    self.match(CnsMRParser.Equ_op)


                self.state = 617
                self.match(CnsMRParser.Integer)
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 3)
                self.state = 618
                self.match(CnsMRParser.Normal)
                self.state = 620
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 619
                    self.match(CnsMRParser.Equ_op)


                self.state = 622
                self.match(CnsMRParser.L_paren)
                self.state = 648
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [151, 153, 170]:
                    self.state = 623
                    self.number_s()
                    self.state = 625
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==149:
                        self.state = 624
                        self.match(CnsMRParser.Comma)


                    self.state = 627
                    self.number_s()
                    self.state = 629
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==149:
                        self.state = 628
                        self.match(CnsMRParser.Comma)


                    self.state = 631
                    self.number_s()
                    pass
                elif token in [144]:
                    self.state = 633
                    self.match(CnsMRParser.Tail)
                    self.state = 635
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==164:
                        self.state = 634
                        self.match(CnsMRParser.Equ_op)


                    self.state = 637
                    self.selection()
                    self.state = 639
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==149:
                        self.state = 638
                        self.match(CnsMRParser.Comma)


                    self.state = 646
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==145:
                        self.state = 641
                        self.match(CnsMRParser.Head)
                        self.state = 643
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==164:
                            self.state = 642
                            self.match(CnsMRParser.Equ_op)


                        self.state = 645
                        self.selection()


                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 650
                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, 46, self.RULE_harmonic_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 654
            self.match(CnsMRParser.Assign)
            self.state = 655
            self.selection()
            self.state = 656
            self.number()
            self.state = 657
            self.number()
            self.state = 658
            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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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, 48, self.RULE_sani_statement)
        self._la = 0 # Token type
        try:
            self.state = 687
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 660
                self.sani_assign()
                pass
            elif token in [142]:
                self.enterOuterAlt(localctx, 2)
                self.state = 661
                self.sani_assign_loop()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 3)
                self.state = 662
                self.classification()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 4)
                self.state = 663
                self.match(CnsMRParser.Coefficients)
                self.state = 664
                self.number_s()
                self.state = 665
                self.number_s()
                self.state = 666
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 5)
                self.state = 668
                self.match(CnsMRParser.ForceConstant)
                self.state = 670
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 669
                    self.match(CnsMRParser.Equ_op)


                self.state = 672
                self.number_s()
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 6)
                self.state = 673
                self.match(CnsMRParser.Nrestraints)
                self.state = 675
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 674
                    self.match(CnsMRParser.Equ_op)


                self.state = 677
                self.match(CnsMRParser.Integer)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 7)
                self.state = 678
                self.match(CnsMRParser.Potential)
                self.state = 680
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 679
                    self.match(CnsMRParser.Equ_op_PT)


                self.state = 682
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 8)
                self.state = 683
                self.match(CnsMRParser.Print)
                self.state = 684
                self.match(CnsMRParser.Threshold)
                self.state = 685
                self.number_s()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 9)
                self.state = 686
                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, 50, self.RULE_sani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 689
            self.match(CnsMRParser.Assign)
            self.state = 690
            self.selection()
            self.state = 691
            self.selection()
            self.state = 692
            self.selection()
            self.state = 693
            self.selection()
            self.state = 694
            self.selection()
            self.state = 695
            self.selection()
            self.state = 696
            self.number()
            self.state = 698
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 697
                self.number()


            self.state = 701
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0):
                self.state = 700
                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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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, 52, self.RULE_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 745
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 703
                self.coup_assign()
                pass
            elif token in [142]:
                self.enterOuterAlt(localctx, 2)
                self.state = 704
                self.coup_assign_loop()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 3)
                self.state = 705
                self.classification()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 4)
                self.state = 706
                self.match(CnsMRParser.Coefficients)
                self.state = 707
                self.number_s()
                self.state = 708
                self.number_s()
                self.state = 709
                self.number_s()
                self.state = 710
                self.number_s()
                pass
            elif token in [12]:
                self.enterOuterAlt(localctx, 5)
                self.state = 712
                self.match(CnsMRParser.Cv)
                self.state = 714
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 713
                    self.match(CnsMRParser.Equ_op)


                self.state = 716
                self.match(CnsMRParser.Integer)
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 6)
                self.state = 717
                self.match(CnsMRParser.ForceConstant)
                self.state = 718
                self.number_s()
                self.state = 720
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0):
                    self.state = 719
                    self.number_s()


                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 7)
                self.state = 722
                self.match(CnsMRParser.Nrestraints)
                self.state = 724
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 723
                    self.match(CnsMRParser.Equ_op)


                self.state = 726
                self.match(CnsMRParser.Integer)
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 8)
                self.state = 727
                self.match(CnsMRParser.Partition)
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 728
                    self.match(CnsMRParser.Equ_op)


                self.state = 731
                self.match(CnsMRParser.Integer)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 9)
                self.state = 732
                self.match(CnsMRParser.Potential)
                self.state = 734
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 733
                    self.match(CnsMRParser.Equ_op_PT)


                self.state = 736
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 10)
                self.state = 737
                self.match(CnsMRParser.Print)
                self.state = 738
                self.match(CnsMRParser.Threshold)
                self.state = 739
                self.number_s()
                self.state = 742
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [92]:
                    self.state = 740
                    self.match(CnsMRParser.All)
                    pass
                elif token in [10]:
                    self.state = 741
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 11)
                self.state = 744
                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, 54, self.RULE_coup_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 747
            self.match(CnsMRParser.Assign)
            self.state = 748
            self.selection()
            self.state = 749
            self.selection()
            self.state = 750
            self.selection()
            self.state = 751
            self.selection()
            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 752
                self.selection()
                self.state = 753
                self.selection()
                self.state = 754
                self.selection()
                self.state = 755
                self.selection()


            self.state = 759
            self.number()
            self.state = 760
            self.number()
            self.state = 764
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0):
                self.state = 761
                self.number()
                self.state = 762
                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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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, 56, self.RULE_carbon_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 807
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 766
                self.carbon_shift_assign()
                pass
            elif token in [142]:
                self.enterOuterAlt(localctx, 2)
                self.state = 767
                self.carbon_shift_assign_loop()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 3)
                self.state = 768
                self.classification()
                pass
            elif token in [65]:
                self.enterOuterAlt(localctx, 4)
                self.state = 769
                self.match(CnsMRParser.Expectation)
                self.state = 770
                self.match(CnsMRParser.Integer)
                self.state = 771
                self.match(CnsMRParser.Integer)
                self.state = 772
                self.number_s()
                self.state = 773
                self.number_s()
                self.state = 774
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 5)
                self.state = 776
                self.match(CnsMRParser.ForceConstant)
                self.state = 778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 777
                    self.match(CnsMRParser.Equ_op)


                self.state = 780
                self.number_s()
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 6)
                self.state = 781
                self.match(CnsMRParser.Nrestraints)
                self.state = 783
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 782
                    self.match(CnsMRParser.Equ_op)


                self.state = 785
                self.match(CnsMRParser.Integer)
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 7)
                self.state = 786
                self.match(CnsMRParser.PhiStep)
                self.state = 788
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 787
                    self.match(CnsMRParser.Equ_op)


                self.state = 790
                self.number_s()
                pass
            elif token in [67]:
                self.enterOuterAlt(localctx, 8)
                self.state = 791
                self.match(CnsMRParser.PsiStep)
                self.state = 793
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 792
                    self.match(CnsMRParser.Equ_op)


                self.state = 795
                self.number_s()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 9)
                self.state = 796
                self.match(CnsMRParser.Potential)
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 797
                    self.match(CnsMRParser.Equ_op_PT)


                self.state = 800
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 10)
                self.state = 801
                self.match(CnsMRParser.Print)
                self.state = 802
                self.match(CnsMRParser.Threshold)
                self.state = 803
                self.number_s()
                pass
            elif token in [68]:
                self.enterOuterAlt(localctx, 11)
                self.state = 804
                self.carbon_shift_rcoil()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 12)
                self.state = 805
                self.match(CnsMRParser.Reset)
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 13)
                self.state = 806
                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, 58, self.RULE_carbon_shift_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 809
            self.match(CnsMRParser.Assign)
            self.state = 810
            self.selection()
            self.state = 811
            self.selection()
            self.state = 812
            self.selection()
            self.state = 813
            self.selection()
            self.state = 814
            self.selection()
            self.state = 815
            self.number()
            self.state = 816
            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, 60, self.RULE_carbon_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 818
            self.match(CnsMRParser.Rcoil)
            self.state = 819
            self.selection()
            self.state = 820
            self.number()
            self.state = 821
            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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 0)

        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 Simple_name(self):
            return self.getToken(CnsMRParser.Simple_name, 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, 62, self.RULE_proton_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 855
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [71]:
                self.enterOuterAlt(localctx, 1)
                self.state = 823
                self.observed()
                pass
            elif token in [68]:
                self.enterOuterAlt(localctx, 2)
                self.state = 824
                self.proton_shift_rcoil()
                pass
            elif token in [72]:
                self.enterOuterAlt(localctx, 3)
                self.state = 825
                self.proton_shift_anisotropy()
                pass
            elif token in [73]:
                self.enterOuterAlt(localctx, 4)
                self.state = 826
                self.proton_shift_amides()
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 5)
                self.state = 827
                self.proton_shift_carbons()
                pass
            elif token in [74]:
                self.enterOuterAlt(localctx, 6)
                self.state = 828
                self.proton_shift_nitrogens()
                pass
            elif token in [75]:
                self.enterOuterAlt(localctx, 7)
                self.state = 829
                self.proton_shift_oxygens()
                pass
            elif token in [76]:
                self.enterOuterAlt(localctx, 8)
                self.state = 830
                self.proton_shift_ring_atoms()
                pass
            elif token in [77]:
                self.enterOuterAlt(localctx, 9)
                self.state = 831
                self.proton_shift_alphas_and_amides()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 10)
                self.state = 832
                self.classification()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 11)
                self.state = 833
                self.match(CnsMRParser.Error)
                self.state = 835
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 834
                    self.match(CnsMRParser.Equ_op)


                self.state = 837
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 12)
                self.state = 838
                self.match(CnsMRParser.ForceConstant)
                self.state = 839
                self.number_s()
                self.state = 841
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0):
                    self.state = 840
                    self.number_s()


                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 13)
                self.state = 843
                self.match(CnsMRParser.Potential)
                self.state = 844
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 14)
                self.state = 845
                self.match(CnsMRParser.Print)
                self.state = 846
                self.match(CnsMRParser.Threshold)
                self.state = 847
                self.number_s()
                self.state = 850
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [92]:
                    self.state = 848
                    self.match(CnsMRParser.All)
                    pass
                elif token in [10]:
                    self.state = 849
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 852
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 15)
                self.state = 854
                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, 64, self.RULE_observed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 857
            self.match(CnsMRParser.Observed)
            self.state = 858
            self.selection()
            self.state = 860
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 859
                self.selection()


            self.state = 862
            self.number()
            self.state = 864
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0):
                self.state = 863
                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, 66, self.RULE_proton_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 866
            self.match(CnsMRParser.Rcoil)
            self.state = 867
            self.selection()
            self.state = 868
            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, 68, self.RULE_proton_shift_anisotropy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 870
            self.match(CnsMRParser.Anisotropy)
            self.state = 871
            self.selection()
            self.state = 872
            self.selection()
            self.state = 873
            self.selection()
            self.state = 874
            self.match(CnsMRParser.Simple_name)
            self.state = 876
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==152:
                self.state = 875
                self.match(CnsMRParser.Logical)


            self.state = 878
            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, 70, self.RULE_proton_shift_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 880
            self.match(CnsMRParser.Amides)
            self.state = 881
            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, 72, self.RULE_proton_shift_carbons)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 883
            self.match(CnsMRParser.Carbon)
            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_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, 74, self.RULE_proton_shift_nitrogens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 886
            self.match(CnsMRParser.Nitrogens)
            self.state = 887
            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, 76, self.RULE_proton_shift_oxygens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self.match(CnsMRParser.Oxygens)
            self.state = 890
            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, 78, self.RULE_proton_shift_ring_atoms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 892
            self.match(CnsMRParser.RingAtoms)
            self.state = 893
            self.match(CnsMRParser.Simple_name)
            self.state = 894
            self.selection()
            self.state = 895
            self.selection()
            self.state = 896
            self.selection()
            self.state = 897
            self.selection()
            self.state = 898
            self.selection()
            self.state = 900
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 899
                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, 80, self.RULE_proton_shift_alphas_and_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 902
            self.match(CnsMRParser.AlphasAndAmides)
            self.state = 903
            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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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, 82, self.RULE_conformation_statement)
        self._la = 0 # Token type
        try:
            self.state = 980
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 905
                self.conf_assign()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 906
                self.classification()
                pass
            elif token in [80]:
                self.enterOuterAlt(localctx, 3)
                self.state = 907
                self.match(CnsMRParser.Compressed)
                pass
            elif token in [65]:
                self.enterOuterAlt(localctx, 4)
                self.state = 908
                self.match(CnsMRParser.Expectation)
                self.state = 909
                self.match(CnsMRParser.Integer)
                self.state = 911
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
                if la_ == 1:
                    self.state = 910
                    self.match(CnsMRParser.Integer)


                self.state = 914
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
                if la_ == 1:
                    self.state = 913
                    self.match(CnsMRParser.Integer)


                self.state = 917
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
                if la_ == 1:
                    self.state = 916
                    self.match(CnsMRParser.Integer)


                self.state = 919
                self.number_s()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 5)
                self.state = 920
                self.match(CnsMRParser.Error)
                self.state = 922
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 921
                    self.match(CnsMRParser.Equ_op)


                self.state = 924
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 6)
                self.state = 925
                self.match(CnsMRParser.ForceConstant)
                self.state = 927
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 926
                    self.match(CnsMRParser.Equ_op)


                self.state = 929
                self.number_s()
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 7)
                self.state = 930
                self.match(CnsMRParser.Nrestraints)
                self.state = 932
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 931
                    self.match(CnsMRParser.Equ_op)


                self.state = 934
                self.match(CnsMRParser.Integer)
                pass
            elif token in [81]:
                self.enterOuterAlt(localctx, 8)
                self.state = 935
                self.match(CnsMRParser.Phase)
                self.state = 936
                self.match(CnsMRParser.Integer)
                self.state = 937
                self.match(CnsMRParser.Integer)
                self.state = 938
                self.match(CnsMRParser.Integer)
                self.state = 942
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
                if la_ == 1:
                    self.state = 939
                    self.match(CnsMRParser.Integer)
                    self.state = 940
                    self.match(CnsMRParser.Integer)
                    self.state = 941
                    self.match(CnsMRParser.Integer)


                self.state = 947
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
                if la_ == 1:
                    self.state = 944
                    self.match(CnsMRParser.Integer)
                    self.state = 945
                    self.match(CnsMRParser.Integer)
                    self.state = 946
                    self.match(CnsMRParser.Integer)


                self.state = 952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==151:
                    self.state = 949
                    self.match(CnsMRParser.Integer)
                    self.state = 950
                    self.match(CnsMRParser.Integer)
                    self.state = 951
                    self.match(CnsMRParser.Integer)


                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 9)
                self.state = 954
                self.match(CnsMRParser.Potential)
                self.state = 956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 955
                    self.match(CnsMRParser.Equ_op_PT)


                self.state = 958
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 10)
                self.state = 959
                self.match(CnsMRParser.Print)
                self.state = 960
                self.match(CnsMRParser.Threshold)
                self.state = 961
                self.number_s()
                self.state = 964
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [92]:
                    self.state = 962
                    self.match(CnsMRParser.All)
                    pass
                elif token in [10]:
                    self.state = 963
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 11)
                self.state = 966
                self.match(CnsMRParser.Reset)
                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 12)
                self.state = 967
                self.match(CnsMRParser.Size)
                self.state = 968
                self.match(CnsMRParser.Dimensions)
                self.state = 969
                self.match(CnsMRParser.Integer)
                self.state = 971
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
                if la_ == 1:
                    self.state = 970
                    self.match(CnsMRParser.Integer)


                self.state = 974
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
                if la_ == 1:
                    self.state = 973
                    self.match(CnsMRParser.Integer)


                self.state = 977
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==151:
                    self.state = 976
                    self.match(CnsMRParser.Integer)


                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 13)
                self.state = 979
                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, 84, self.RULE_conf_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 982
            self.match(CnsMRParser.Assign)
            self.state = 983
            self.selection()
            self.state = 984
            self.selection()
            self.state = 985
            self.selection()
            self.state = 986
            self.selection()
            self.state = 992
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,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._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 994
                self.selection()
                self.state = 995
                self.selection()
                self.state = 996
                self.selection()
                self.state = 997
                self.selection()


            self.state = 1006
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1001
                self.selection()
                self.state = 1002
                self.selection()
                self.state = 1003
                self.selection()
                self.state = 1004
                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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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, 86, self.RULE_diffusion_statement)
        self._la = 0 # Token type
        try:
            self.state = 1036
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1008
                self.dani_assign()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1009
                self.classification()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1010
                self.match(CnsMRParser.Coefficients)
                self.state = 1011
                self.number_s()
                self.state = 1012
                self.number_s()
                self.state = 1013
                self.number_s()
                self.state = 1014
                self.number_s()
                self.state = 1015
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1017
                self.match(CnsMRParser.ForceConstant)
                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1018
                    self.match(CnsMRParser.Equ_op)


                self.state = 1021
                self.number_s()
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1022
                self.match(CnsMRParser.Nrestraints)
                self.state = 1024
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1023
                    self.match(CnsMRParser.Equ_op)


                self.state = 1026
                self.match(CnsMRParser.Integer)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1027
                self.match(CnsMRParser.Potential)
                self.state = 1029
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 1028
                    self.match(CnsMRParser.Equ_op_PT)


                self.state = 1031
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1032
                self.match(CnsMRParser.Print)
                self.state = 1033
                self.match(CnsMRParser.Threshold)
                self.state = 1034
                self.number_s()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1035
                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, 88, self.RULE_dani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1038
            self.match(CnsMRParser.Assign)
            self.state = 1039
            self.selection()
            self.state = 1040
            self.selection()
            self.state = 1041
            self.selection()
            self.state = 1042
            self.selection()
            self.state = 1043
            self.selection()
            self.state = 1044
            self.selection()
            self.state = 1045
            self.number()
            self.state = 1047
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0):
                self.state = 1046
                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.getTypedRuleContext(CnsMRParser.ClassificationContext,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 Equ_op(self):
            return self.getToken(CnsMRParser.Equ_op, 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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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, 90, self.RULE_one_bond_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 1079
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1049
                self.one_bond_assign()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1050
                self.classification()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1051
                self.match(CnsMRParser.Coefficients)
                self.state = 1052
                self.number_s()
                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()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1060
                self.match(CnsMRParser.ForceConstant)
                self.state = 1062
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1061
                    self.match(CnsMRParser.Equ_op)


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


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


                self.state = 1074
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1075
                self.match(CnsMRParser.Print)
                self.state = 1076
                self.match(CnsMRParser.Threshold)
                self.state = 1077
                self.number_s()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1078
                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, 92, self.RULE_one_bond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1081
            self.match(CnsMRParser.Assign)
            self.state = 1082
            self.selection()
            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.number()
            self.state = 1091
            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.getTypedRuleContext(CnsMRParser.ClassificationContext,0)


        def DerivFlag(self):
            return self.getToken(CnsMRParser.DerivFlag, 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):
            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_PT(self):
            return self.getToken(CnsMRParser.Equ_op_PT, 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 AngleDb(self):
            return self.getToken(CnsMRParser.AngleDb, 0)

        def Dihedral(self):
            return self.getToken(CnsMRParser.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, 94, self.RULE_angle_db_statement)
        self._la = 0 # Token type
        try:
            self.state = 1137
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1093
                self.angle_db_assign()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1094
                self.classification()
                pass
            elif token in [87]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1095
                self.match(CnsMRParser.DerivFlag)
                self.state = 1097
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1096
                    self.match(CnsMRParser.Equ_op)


                self.state = 1099
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [65]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1100
                self.match(CnsMRParser.Expectation)
                self.state = 1101
                self.match(CnsMRParser.Integer)
                self.state = 1102
                self.match(CnsMRParser.Integer)
                self.state = 1103
                self.number_s()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1104
                self.match(CnsMRParser.Error)
                self.state = 1106
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1105
                    self.match(CnsMRParser.Equ_op)


                self.state = 1108
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1109
                self.match(CnsMRParser.ForceConstant)
                self.state = 1111
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1110
                    self.match(CnsMRParser.Equ_op)


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


                self.state = 1118
                self.match(CnsMRParser.Integer)
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1119
                self.match(CnsMRParser.Potential)
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==183:
                    self.state = 1120
                    self.match(CnsMRParser.Equ_op_PT)


                self.state = 1123
                self.match(CnsMRParser.Potential_types)
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1124
                self.match(CnsMRParser.Print)
                self.state = 1125
                self.match(CnsMRParser.Threshold)
                self.state = 1126
                self.number_s()
                self.state = 1129
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [92]:
                    self.state = 1127
                    self.match(CnsMRParser.All)
                    pass
                elif token in [10]:
                    self.state = 1128
                    self.classification()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1131
                self.match(CnsMRParser.Reset)
                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1132
                self.match(CnsMRParser.Size)
                self.state = 1133
                _la = self._input.LA(1)
                if not(_la==50 or _la==86):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1134
                self.match(CnsMRParser.Integer)
                self.state = 1135
                self.match(CnsMRParser.Integer)
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1136
                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, 96, self.RULE_angle_db_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1139
            self.match(CnsMRParser.Assign)
            self.state = 1140
            self.selection()
            self.state = 1141
            self.selection()
            self.state = 1142
            self.selection()
            self.state = 1143
            self.selection()
            self.state = 1144
            self.selection()
            self.state = 1145
            self.selection()
            self.state = 1146
            self.selection()
            self.state = 1147
            self.selection()
            self.state = 1148
            self.selection()
            self.state = 1149
            self.selection()
            self.state = 1150
            self.selection()
            self.state = 1152
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==161:
                self.state = 1151
                self.selection()


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


    class Ncs_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


        def getRuleIndex(self):
            return CnsMRParser.RULE_ncs_restraint

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

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




    def ncs_restraint(self):

        localctx = CnsMRParser.Ncs_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_ncs_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1154
            self.match(CnsMRParser.Ncs)
            self.state = 1155
            self.match(CnsMRParser.Restraints)
            self.state = 1159
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 22518032496590848) != 0):
                self.state = 1156
                self.ncs_statement()
                self.state = 1161
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

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

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

        def ncs_group_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Ncs_group_statementContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Ncs_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_ncs_statement

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

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




    def ncs_statement(self):

        localctx = CnsMRParser.Ncs_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_ncs_statement)
        self._la = 0 # Token type
        try:
            self.state = 1174
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [54]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1164
                self.match(CnsMRParser.Group)
                self.state = 1168
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & 25769803777) != 0):
                    self.state = 1165
                    self.ncs_group_statement()
                    self.state = 1170
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1171
                self.match(CnsMRParser.End)
                pass
            elif token in [35]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1172
                self.match(CnsMRParser.Initialize)
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1173
                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 Ncs_group_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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


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

        def getRuleIndex(self):
            return CnsMRParser.RULE_ncs_group_statement

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

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




    def ncs_group_statement(self):

        localctx = CnsMRParser.Ncs_group_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_ncs_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 1191
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1176
                self.match(CnsMRParser.Equivalence)
                self.state = 1178
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1177
                    self.match(CnsMRParser.Equ_op)


                self.state = 1180
                self.selection()
                pass
            elif token in [90]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1181
                self.match(CnsMRParser.Sigb)
                self.state = 1183
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1182
                    self.match(CnsMRParser.Equ_op)


                self.state = 1185
                self.number_s()
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1186
                self.match(CnsMRParser.Weight)
                self.state = 1188
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1187
                    self.match(CnsMRParser.Equ_op)


                self.state = 1190
                self.number_s()
                pass
            else:
                raise NoViableAltException(self)

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


    class SelectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_paren(self):
            return self.getToken(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, 104, self.RULE_selection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1193
            self.match(CnsMRParser.L_paren)
            self.state = 1194
            self.selection_expression()
            self.state = 1195
            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, 106, self.RULE_selection_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1197
            self.term()
            self.state = 1202
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==146:
                self.state = 1198
                self.match(CnsMRParser.Or_op)
                self.state = 1199
                self.term()
                self.state = 1204
                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, 108, self.RULE_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1205
            self.factor(0)
            self.state = 1210
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==147:
                self.state = 1206
                self.match(CnsMRParser.And_op)
                self.state = 1207
                self.factor(0)
                self.state = 1212
                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 Store1(self):
            return self.getToken(CnsMRParser.Store1, 0)

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

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

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

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

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

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

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

        def Store9(self):
            return self.getToken(CnsMRParser.Store9, 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 = 110
        self.enterRecursionRule(localctx, 110, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1367
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,161,self._ctx)
            if la_ == 1:
                self.state = 1214
                self.match(CnsMRParser.L_paren)
                self.state = 1215
                self.selection_expression()
                self.state = 1216
                self.match(CnsMRParser.R_paren)
                pass

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

            elif la_ == 3:
                self.state = 1219
                self.match(CnsMRParser.Atom)
                self.state = 1220
                _la = self._input.LA(1)
                if not(_la==158 or _la==159):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1221
                _la = self._input.LA(1)
                if not(_la==151 or _la==160):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1222
                _la = self._input.LA(1)
                if not(_la==158 or _la==159):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                self.state = 1223
                self.match(CnsMRParser.Attribute)
                self.state = 1225
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==176:
                    self.state = 1224
                    self.match(CnsMRParser.Abs)


                self.state = 1227
                self.match(CnsMRParser.Attr_properties)
                self.state = 1228
                self.match(CnsMRParser.Comparison_ops)
                self.state = 1229
                self.number_f()
                pass

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

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

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

            elif la_ == 8:
                self.state = 1236
                self.match(CnsMRParser.Chemical)
                self.state = 1244
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [159]:
                    self.state = 1237
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [158]:
                    self.state = 1238
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1241
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,143,self._ctx)
                    if la_ == 1:
                        self.state = 1239
                        self.match(CnsMRParser.Colon)
                        self.state = 1240
                        self.match(CnsMRParser.Simple_name)


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

                pass

            elif la_ == 9:
                self.state = 1246
                self.match(CnsMRParser.Fbox)
                self.state = 1247
                self.number_f()
                self.state = 1248
                self.number_f()
                self.state = 1249
                self.number_f()
                self.state = 1250
                self.number_f()
                self.state = 1251
                self.number_f()
                self.state = 1252
                self.number_f()
                pass

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

            elif la_ == 11:
                self.state = 1255
                self.match(CnsMRParser.Id)
                self.state = 1256
                self.match(CnsMRParser.Integer)
                pass

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

            elif la_ == 13:
                self.state = 1258
                self.match(CnsMRParser.Name)
                self.state = 1271
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [159]:
                    self.state = 1259
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [158]:
                    self.state = 1260
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1263
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                    if la_ == 1:
                        self.state = 1261
                        self.match(CnsMRParser.Colon)
                        self.state = 1262
                        self.match(CnsMRParser.Simple_name)


                    pass
                elif token in [154]:
                    self.state = 1265
                    self.match(CnsMRParser.Double_quote_string)
                    self.state = 1268
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
                    if la_ == 1:
                        self.state = 1266
                        self.match(CnsMRParser.Colon)
                        self.state = 1267
                        self.match(CnsMRParser.Double_quote_string)


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

                pass

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

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

            elif la_ == 16:
                self.state = 1276
                self.match(CnsMRParser.Point)
                self.state = 1277
                self.match(CnsMRParser.L_paren)
                self.state = 1278
                self.number_f()
                self.state = 1280
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 1279
                    self.match(CnsMRParser.Comma)


                self.state = 1282
                self.number_f()
                self.state = 1284
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 1283
                    self.match(CnsMRParser.Comma)


                self.state = 1286
                self.number_f()
                self.state = 1287
                self.match(CnsMRParser.R_paren)
                self.state = 1288
                self.match(CnsMRParser.Cut)
                self.state = 1289
                self.number_f()
                pass

            elif la_ == 17:
                self.state = 1291
                self.match(CnsMRParser.Point)
                self.state = 1292
                self.match(CnsMRParser.L_paren)
                self.state = 1293
                self.match(CnsMRParser.Tail)
                self.state = 1295
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==164:
                    self.state = 1294
                    self.match(CnsMRParser.Equ_op)


                self.state = 1297
                self.selection()
                self.state = 1299
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 1298
                    self.match(CnsMRParser.Comma)


                self.state = 1306
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==145:
                    self.state = 1301
                    self.match(CnsMRParser.Head)
                    self.state = 1303
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==164:
                        self.state = 1302
                        self.match(CnsMRParser.Equ_op)


                    self.state = 1305
                    self.selection()


                self.state = 1308
                self.match(CnsMRParser.R_paren)
                self.state = 1309
                self.match(CnsMRParser.Cut)
                self.state = 1310
                self.number_f()
                pass

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

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

            elif la_ == 20:
                self.state = 1314
                self.match(CnsMRParser.Residue)
                self.state = 1322
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [160]:
                    self.state = 1315
                    self.match(CnsMRParser.Integers)
                    pass
                elif token in [151]:
                    self.state = 1316
                    self.match(CnsMRParser.Integer)
                    self.state = 1319
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,154,self._ctx)
                    if la_ == 1:
                        self.state = 1317
                        self.match(CnsMRParser.Colon)
                        self.state = 1318
                        self.match(CnsMRParser.Integer)


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

                pass

            elif la_ == 21:
                self.state = 1324
                self.match(CnsMRParser.Resname)
                self.state = 1332
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [159]:
                    self.state = 1325
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [158]:
                    self.state = 1326
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1329
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
                    if la_ == 1:
                        self.state = 1327
                        self.match(CnsMRParser.Colon)
                        self.state = 1328
                        self.match(CnsMRParser.Simple_name)


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

                pass

            elif la_ == 22:
                self.state = 1334
                self.match(CnsMRParser.SegIdentifier)
                self.state = 1347
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [159]:
                    self.state = 1335
                    self.match(CnsMRParser.Simple_names)
                    pass
                elif token in [158]:
                    self.state = 1336
                    self.match(CnsMRParser.Simple_name)
                    self.state = 1339
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
                    if la_ == 1:
                        self.state = 1337
                        self.match(CnsMRParser.Colon)
                        self.state = 1338
                        self.match(CnsMRParser.Simple_name)


                    pass
                elif token in [154]:
                    self.state = 1341
                    self.match(CnsMRParser.Double_quote_string)
                    self.state = 1344
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,159,self._ctx)
                    if la_ == 1:
                        self.state = 1342
                        self.match(CnsMRParser.Colon)
                        self.state = 1343
                        self.match(CnsMRParser.Double_quote_string)


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

                pass

            elif la_ == 23:
                self.state = 1349
                self.match(CnsMRParser.Sfbox)
                self.state = 1350
                self.number_f()
                self.state = 1351
                self.number_f()
                self.state = 1352
                self.number_f()
                self.state = 1353
                self.number_f()
                self.state = 1354
                self.number_f()
                self.state = 1355
                self.number_f()
                pass

            elif la_ == 24:
                self.state = 1357
                self.match(CnsMRParser.Store1)
                pass

            elif la_ == 25:
                self.state = 1358
                self.match(CnsMRParser.Store2)
                pass

            elif la_ == 26:
                self.state = 1359
                self.match(CnsMRParser.Store3)
                pass

            elif la_ == 27:
                self.state = 1360
                self.match(CnsMRParser.Store4)
                pass

            elif la_ == 28:
                self.state = 1361
                self.match(CnsMRParser.Store5)
                pass

            elif la_ == 29:
                self.state = 1362
                self.match(CnsMRParser.Store6)
                pass

            elif la_ == 30:
                self.state = 1363
                self.match(CnsMRParser.Store7)
                pass

            elif la_ == 31:
                self.state = 1364
                self.match(CnsMRParser.Store8)
                pass

            elif la_ == 32:
                self.state = 1365
                self.match(CnsMRParser.Store9)
                pass

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


            self._ctx.stop = self._input.LT(-1)
            self.state = 1377
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,163,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 = 1375
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
                    if la_ == 1:
                        localctx = CnsMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1369
                        if not self.precpred(self._ctx, 33):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 33)")
                        self.state = 1370
                        self.match(CnsMRParser.Around)
                        self.state = 1371
                        self.number_f()
                        pass

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

             
                self.state = 1379
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,163,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, 112, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1380
            _la = self._input.LA(1)
            if not(((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_fContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(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, 114, self.RULE_number_f)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1382
            _la = self._input.LA(1)
            if not(_la==151 or _la==153):
                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, 116, self.RULE_number_s)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1384
            _la = self._input.LA(1)
            if not(((((_la - 151)) & ~0x3f) == 0 and ((1 << (_la - 151)) & 524293) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_aContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Real(self):
            return self.getToken(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, 118, self.RULE_number_a)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1386
            _la = self._input.LA(1)
            if not(_la==151 or _la==153):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassificationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def class_name(self):
            return self.getTypedRuleContext(CnsMRParser.Class_nameContext,0)


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

        def getRuleIndex(self):
            return CnsMRParser.RULE_classification

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

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




    def classification(self):

        localctx = CnsMRParser.ClassificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_classification)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1388
            self.match(CnsMRParser.Classification)
            self.state = 1390
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==164:
                self.state = 1389
                self.match(CnsMRParser.Equ_op)


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


    class Class_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.RULE_class_name

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

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




    def class_name(self):

        localctx = CnsMRParser.Class_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_class_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1394
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1688849860263944) != 0) or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & 3377699720527873) != 0) or _la==158):
                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_FL(self):
            return self.getToken(CnsMRParser.End_FL, 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, 124, self.RULE_flag_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1396
            self.match(CnsMRParser.Flags)
            self.state = 1407
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==189:
                self.state = 1397
                self.match(CnsMRParser.Exclude)
                self.state = 1405
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [190, 192]:
                    self.state = 1401
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==192:
                        self.state = 1398
                        self.match(CnsMRParser.Class_name)
                        self.state = 1403
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

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



            self.state = 1409
            self.match(CnsMRParser.Include)
            self.state = 1413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==192:
                self.state = 1410
                self.match(CnsMRParser.Class_name)
                self.state = 1415
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Vector_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Vector(self):
            return self.getToken(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, 126, self.RULE_vector_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1418
            self.match(CnsMRParser.Vector)
            self.state = 1419
            self.vector_mode()
            self.state = 1420
            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 Identity_Lp(self):
            return self.getToken(CnsMRParser.Identity_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, 128, self.RULE_vector_mode)
        self._la = 0 # Token type
        try:
            self.state = 1428
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [126, 127]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1422
                _la = self._input.LA(1)
                if not(_la==126 or _la==127):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1423
                self.vector_expression()
                self.state = 1424
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [128]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1426
                self.match(CnsMRParser.Show)
                self.state = 1427
                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, 130, self.RULE_vector_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1430
            self.match(CnsMRParser.Atom_properties_VE)
            self.state = 1433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==196:
                self.state = 1431
                self.match(CnsMRParser.Equ_op_VE)
                self.state = 1432
                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, 132, self.RULE_vector_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1435
            self.vflc()
            self.state = 1438
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & 31) != 0):
                self.state = 1436
                _la = self._input.LA(1)
                if not(((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & 31) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1437
                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, 134, self.RULE_vflc)
        try:
            self.state = 1447
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [205]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1440
                self.match(CnsMRParser.Atom_properties_VE)
                pass
            elif token in [206, 207, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1441
                self.vector_func_call()
                pass
            elif token in [203]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1442
                self.match(CnsMRParser.Integer_VE)
                pass
            elif token in [204]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1443
                self.match(CnsMRParser.Real_VE)
                pass
            elif token in [229]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1444
                self.match(CnsMRParser.Simple_name_VE)
                pass
            elif token in [228]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1445
                self.match(CnsMRParser.Symbol_name_VE)
                pass
            elif token in [230]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1446
                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, 136, self.RULE_vector_func_call)
        self._la = 0 # Token type
        try:
            self.state = 1568
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [206]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1449
                self.match(CnsMRParser.Abs_VE)
                self.state = 1450
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1451
                self.vflc()
                self.state = 1452
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [207]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1454
                self.match(CnsMRParser.Acos_VE)
                self.state = 1455
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1456
                self.vflc()
                self.state = 1457
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [209]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1459
                self.match(CnsMRParser.Cos_VE)
                self.state = 1460
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1461
                self.vflc()
                self.state = 1462
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [210]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1464
                self.match(CnsMRParser.Decode_VE)
                self.state = 1465
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1466
                self.vflc()
                self.state = 1467
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [211]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1469
                self.match(CnsMRParser.Encode_VE)
                self.state = 1470
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1471
                self.vflc()
                self.state = 1472
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [212]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1474
                self.match(CnsMRParser.Exp_VE)
                self.state = 1475
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1476
                self.vflc()
                self.state = 1477
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [213]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1479
                self.match(CnsMRParser.Gauss_VE)
                self.state = 1480
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1481
                self.vflc()
                self.state = 1482
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [214]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1484
                self.match(CnsMRParser.Heavy_VE)
                self.state = 1485
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1486
                self.vflc()
                self.state = 1487
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [215]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1489
                self.match(CnsMRParser.Int_VE)
                self.state = 1490
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1491
                self.vflc()
                self.state = 1492
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [216]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1494
                self.match(CnsMRParser.Log10_VE)
                self.state = 1495
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1496
                self.vflc()
                self.state = 1497
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [217]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1499
                self.match(CnsMRParser.Log_VE)
                self.state = 1500
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1501
                self.vflc()
                self.state = 1502
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [218]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1504
                self.match(CnsMRParser.Max_VE)
                self.state = 1505
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1506
                self.vflc()
                self.state = 1511
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==202:
                    self.state = 1507
                    self.match(CnsMRParser.Comma_VE)
                    self.state = 1508
                    self.vflc()
                    self.state = 1513
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1514
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [219]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1516
                self.match(CnsMRParser.Maxw_VE)
                self.state = 1517
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1518
                self.vflc()
                self.state = 1519
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [220]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1521
                self.match(CnsMRParser.Min_VE)
                self.state = 1522
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1523
                self.vflc()
                self.state = 1528
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==202:
                    self.state = 1524
                    self.match(CnsMRParser.Comma_VE)
                    self.state = 1525
                    self.vflc()
                    self.state = 1530
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1531
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [221]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1533
                self.match(CnsMRParser.Mod_VE)
                self.state = 1534
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1535
                self.vflc()
                self.state = 1536
                self.match(CnsMRParser.Comma_VE)
                self.state = 1537
                self.vflc()
                self.state = 1538
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [222]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1540
                self.match(CnsMRParser.Norm_VE)
                self.state = 1541
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1542
                self.vflc()
                self.state = 1543
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [223]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1545
                self.match(CnsMRParser.Random_VE)
                self.state = 1546
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1547
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [224]:
                self.enterOuterAlt(localctx, 18)
                self.state = 1548
                self.match(CnsMRParser.Sign_VE)
                self.state = 1549
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1550
                self.vflc()
                self.state = 1551
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [225]:
                self.enterOuterAlt(localctx, 19)
                self.state = 1553
                self.match(CnsMRParser.Sin_VE)
                self.state = 1554
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1555
                self.vflc()
                self.state = 1556
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [226]:
                self.enterOuterAlt(localctx, 20)
                self.state = 1558
                self.match(CnsMRParser.Sqrt_VE)
                self.state = 1559
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1560
                self.vflc()
                self.state = 1561
                self.match(CnsMRParser.R_paren_VE)
                pass
            elif token in [227]:
                self.enterOuterAlt(localctx, 21)
                self.state = 1563
                self.match(CnsMRParser.Tan_VE)
                self.state = 1564
                self.match(CnsMRParser.L_paren_VF)
                self.state = 1565
                self.vflc()
                self.state = 1566
                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, 138, self.RULE_vector_show_property)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1570
            _la = self._input.LA(1)
            if not(((((_la - 236)) & ~0x3f) == 0 and ((1 << (_la - 236)) & 127) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1571
            self.match(CnsMRParser.L_paren_VS)
            self.state = 1572
            self.match(CnsMRParser.Atom_properties_VS)
            self.state = 1573
            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, 140, self.RULE_evaluate_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1575
            self.match(CnsMRParser.Evaluate_Lp)
            self.state = 1576
            self.match(CnsMRParser.Symbol_name_VE)
            self.state = 1577
            self.match(CnsMRParser.Equ_op_VE)
            self.state = 1578
            self.evaluate_operation()
            self.state = 1579
            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, 142, self.RULE_evaluate_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1581
            self.vflc()
            self.state = 1584
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & 31) != 0):
                self.state = 1582
                _la = self._input.LA(1)
                if not(((((_la - 197)) & ~0x3f) == 0 and ((1 << (_la - 197)) & 31) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1583
                self.evaluate_operation()


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


    class Patch_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def Reference(self, i:int=None):
            if i is None:
                return self.getTokens(CnsMRParser.Reference)
            else:
                return self.getToken(CnsMRParser.Reference, 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 selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.SelectionContext,i)


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

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

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

        def class_name(self):
            return self.getTypedRuleContext(CnsMRParser.Class_nameContext,0)


        def getRuleIndex(self):
            return CnsMRParser.RULE_patch_statement

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

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




    def patch_statement(self):

        localctx = CnsMRParser.Patch_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_patch_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1586
            self.match(CnsMRParser.Patch)
            self.state = 1588
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1688849860263944) != 0) or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & 3377699720527873) != 0) or _la==158:
                self.state = 1587
                self.class_name()


            self.state = 1590
            self.match(CnsMRParser.Reference)
            self.state = 1591
            self.match(CnsMRParser.Equ_op)
            self.state = 1592
            _la = self._input.LA(1)
            if not(_la==132 or _la==151):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1593
            self.match(CnsMRParser.Equ_op)
            self.state = 1594
            self.selection()
            self.state = 1600
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1595
                self.match(CnsMRParser.Reference)
                self.state = 1596
                self.match(CnsMRParser.Equ_op)
                self.state = 1597
                _la = self._input.LA(1)
                if not(_la==132 or _la==151):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1598
                self.match(CnsMRParser.Equ_op)
                self.state = 1599
                self.selection()


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

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

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

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

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


        def getRuleIndex(self):
            return CnsMRParser.RULE_parameter_setting

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

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




    def parameter_setting(self):

        localctx = CnsMRParser.Parameter_settingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_parameter_setting)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1604
            self.match(CnsMRParser.Parameter)
            self.state = 1608
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==26 or _la==50 or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & 70931694131086337) != 0):
                self.state = 1605
                self.parameter_statement()
                self.state = 1610
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

        def AngleDb(self):
            return self.getToken(CnsMRParser.AngleDb, 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 UB(self):
            return self.getToken(CnsMRParser.UB, 0)

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

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

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

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

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

        def HBonded(self):
            return self.getToken(CnsMRParser.HBonded, 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 NBFix(self):
            return self.getToken(CnsMRParser.NBFix, 0)

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

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

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

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

        def getRuleIndex(self):
            return CnsMRParser.RULE_parameter_statement

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

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




    def parameter_statement(self):

        localctx = CnsMRParser.Parameter_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_parameter_statement)
        self._la = 0 # Token type
        try:
            self.state = 1668
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [86]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1613
                self.match(CnsMRParser.AngleDb)
                self.state = 1614
                self.match(CnsMRParser.Simple_name)
                self.state = 1615
                self.match(CnsMRParser.Simple_name)
                self.state = 1616
                self.match(CnsMRParser.Simple_name)
                self.state = 1617
                self.number_s()
                self.state = 1618
                self.number_s()
                self.state = 1623
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==134:
                    self.state = 1619
                    self.match(CnsMRParser.UB)
                    self.state = 1620
                    self.number_s()
                    self.state = 1621
                    self.number_s()


                pass
            elif token in [96]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1625
                self.match(CnsMRParser.BondedTo)
                self.state = 1626
                self.match(CnsMRParser.Simple_name)
                self.state = 1627
                self.match(CnsMRParser.Simple_name)
                self.state = 1628
                self.number_s()
                self.state = 1629
                self.number_s()
                pass
            elif token in [50, 137]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1631
                _la = self._input.LA(1)
                if not(_la==50 or _la==137):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1632
                self.match(CnsMRParser.Simple_name)
                self.state = 1633
                self.match(CnsMRParser.Simple_name)
                self.state = 1634
                self.match(CnsMRParser.Simple_name)
                self.state = 1635
                self.match(CnsMRParser.Simple_name)
                self.state = 1638
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==135:
                    self.state = 1636
                    self.match(CnsMRParser.Mult)
                    self.state = 1637
                    self.match(CnsMRParser.Integer)


                self.state = 1640
                self.number_s()
                self.state = 1641
                self.match(CnsMRParser.Integer)
                self.state = 1642
                self.number_s()
                pass
            elif token in [136]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1644
                self.match(CnsMRParser.HBonded)
                self.state = 1645
                self.match(CnsMRParser.Simple_names)
                self.state = 1646
                self.match(CnsMRParser.Simple_names)
                self.state = 1647
                self.number_s()
                self.state = 1648
                self.number_s()
                pass
            elif token in [138]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1650
                self.match(CnsMRParser.NBFix)
                self.state = 1651
                self.match(CnsMRParser.Simple_name)
                self.state = 1652
                self.match(CnsMRParser.Simple_name)
                self.state = 1653
                self.number_s()
                self.state = 1654
                self.number_s()
                self.state = 1655
                self.number_s()
                self.state = 1656
                self.number_s()
                pass
            elif token in [139]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1658
                self.match(CnsMRParser.NonB)
                self.state = 1659
                self.match(CnsMRParser.Simple_name)
                self.state = 1660
                self.number_s()
                self.state = 1661
                self.number_s()
                self.state = 1662
                self.number_s()
                self.state = 1663
                self.number_s()
                pass
            elif token in [26, 140]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1665
                _la = self._input.LA(1)
                if not(_la==26 or _la==140):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1666
                self.match(CnsMRParser.Simple_name)
                pass
            elif token in [141]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1667
                self.match(CnsMRParser.Verbose)
                pass
            else:
                raise NoViableAltException(self)

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


    class Noe_assign_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(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 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 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, 150, self.RULE_noe_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1670
            self.match(CnsMRParser.For)
            self.state = 1671
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1672
            self.match(CnsMRParser.In_CF)
            self.state = 1673
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1692
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
            if la_ == 1:
                self.state = 1677
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==248:
                    self.state = 1674
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1679
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==249:
                    self.state = 1680
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1685
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1689
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==251:
                    self.state = 1686
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1691
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1694
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1695
            self.match(CnsMRParser.Loop)
            self.state = 1696
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1702
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==3 or _la==5 or _la==129:
                self.state = 1700
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [129]:
                    self.state = 1697
                    self.evaluate_statement()
                    pass
                elif token in [5]:
                    self.state = 1698
                    self.noe_assign()
                    pass
                elif token in [3]:
                    self.state = 1699
                    self.distance_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1705
            self.match(CnsMRParser.End)
            self.state = 1706
            self.match(CnsMRParser.Loop)
            self.state = 1707
            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 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 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, 152, self.RULE_dihedral_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1709
            self.match(CnsMRParser.For)
            self.state = 1710
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1711
            self.match(CnsMRParser.In_CF)
            self.state = 1712
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1731
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,192,self._ctx)
            if la_ == 1:
                self.state = 1716
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==248:
                    self.state = 1713
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1718
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1722
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==249:
                    self.state = 1719
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1724
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1728
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==251:
                    self.state = 1725
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1730
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1733
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1734
            self.match(CnsMRParser.Loop)
            self.state = 1735
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1741
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 1688849860263968) != 0) or _la==129:
                self.state = 1739
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [129]:
                    self.state = 1736
                    self.evaluate_statement()
                    pass
                elif token in [5]:
                    self.state = 1737
                    self.dihedral_assign()
                    pass
                elif token in [49, 50]:
                    self.state = 1738
                    self.dihedral_angle_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1744
            self.match(CnsMRParser.End)
            self.state = 1745
            self.match(CnsMRParser.Loop)
            self.state = 1746
            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 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 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, 154, self.RULE_sani_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1748
            self.match(CnsMRParser.For)
            self.state = 1749
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1750
            self.match(CnsMRParser.In_CF)
            self.state = 1751
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1770
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,198,self._ctx)
            if la_ == 1:
                self.state = 1755
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==248:
                    self.state = 1752
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1757
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1761
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==249:
                    self.state = 1758
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1763
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==251:
                    self.state = 1764
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1769
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1772
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1773
            self.match(CnsMRParser.Loop)
            self.state = 1774
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1780
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==5 or _la==60 or _la==129:
                self.state = 1778
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [129]:
                    self.state = 1775
                    self.evaluate_statement()
                    pass
                elif token in [5]:
                    self.state = 1776
                    self.sani_assign()
                    pass
                elif token in [60]:
                    self.state = 1777
                    self.rdc_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1783
            self.match(CnsMRParser.End)
            self.state = 1784
            self.match(CnsMRParser.Loop)
            self.state = 1785
            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 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 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, 156, self.RULE_coup_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1787
            self.match(CnsMRParser.For)
            self.state = 1788
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1789
            self.match(CnsMRParser.In_CF)
            self.state = 1790
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1809
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,204,self._ctx)
            if la_ == 1:
                self.state = 1794
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==248:
                    self.state = 1791
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1796
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1800
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==249:
                    self.state = 1797
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1802
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==251:
                    self.state = 1803
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1808
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1811
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1812
            self.match(CnsMRParser.Loop)
            self.state = 1813
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1819
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==5 or _la==63 or _la==129:
                self.state = 1817
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [129]:
                    self.state = 1814
                    self.evaluate_statement()
                    pass
                elif token in [5]:
                    self.state = 1815
                    self.coup_assign()
                    pass
                elif token in [63]:
                    self.state = 1816
                    self.coupling_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1822
            self.match(CnsMRParser.End)
            self.state = 1823
            self.match(CnsMRParser.Loop)
            self.state = 1824
            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 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 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, 158, self.RULE_carbon_shift_assign_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1826
            self.match(CnsMRParser.For)
            self.state = 1827
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1828
            self.match(CnsMRParser.In_CF)
            self.state = 1829
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1848
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
            if la_ == 1:
                self.state = 1833
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==248:
                    self.state = 1830
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1835
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1839
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==249:
                    self.state = 1836
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1841
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1845
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==251:
                    self.state = 1842
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1847
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1850
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1851
            self.match(CnsMRParser.Loop)
            self.state = 1852
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1858
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==5 or _la==64 or _la==129:
                self.state = 1856
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [129]:
                    self.state = 1853
                    self.evaluate_statement()
                    pass
                elif token in [5]:
                    self.state = 1854
                    self.carbon_shift_assign()
                    pass
                elif token in [64]:
                    self.state = 1855
                    self.carbon_shift_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1861
            self.match(CnsMRParser.End)
            self.state = 1862
            self.match(CnsMRParser.Loop)
            self.state = 1863
            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 Plane_group_loopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def For(self):
            return self.getToken(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 plane_group(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CnsMRParser.Plane_groupContext)
            else:
                return self.getTypedRuleContext(CnsMRParser.Plane_groupContext,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 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_plane_group_loop

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

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




    def plane_group_loop(self):

        localctx = CnsMRParser.Plane_group_loopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_plane_group_loop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1865
            self.match(CnsMRParser.For)
            self.state = 1866
            self.match(CnsMRParser.Symbol_name_CF)
            self.state = 1867
            self.match(CnsMRParser.In_CF)
            self.state = 1868
            self.match(CnsMRParser.L_paren_CF)
            self.state = 1887
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
            if la_ == 1:
                self.state = 1872
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==248:
                    self.state = 1869
                    self.match(CnsMRParser.Integer_CF)
                    self.state = 1874
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 1878
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==249:
                    self.state = 1875
                    self.match(CnsMRParser.Real_CF)
                    self.state = 1880
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.state = 1884
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==251:
                    self.state = 1881
                    self.match(CnsMRParser.Simple_name_CF)
                    self.state = 1886
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


            self.state = 1889
            self.match(CnsMRParser.R_paren_CF)
            self.state = 1890
            self.match(CnsMRParser.Loop)
            self.state = 1891
            self.match(CnsMRParser.Simple_name_LL)
            self.state = 1897
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 27584547717644288) != 0) or _la==129:
                self.state = 1895
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [129]:
                    self.state = 1892
                    self.evaluate_statement()
                    pass
                elif token in [54]:
                    self.state = 1893
                    self.plane_group()
                    pass
                elif token in [49, 53]:
                    self.state = 1894
                    self.plane_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 1900
            self.match(CnsMRParser.End)
            self.state = 1901
            self.match(CnsMRParser.Loop)
            self.state = 1902
            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[55] = 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)
         




