# Generated from CharmmMRParser.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,180,827,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,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,117,8,0,10,0,12,0,120,
        9,0,1,0,1,0,1,1,1,1,5,1,126,8,1,10,1,12,1,129,9,1,1,1,1,1,1,2,1,
        2,5,2,135,8,2,10,2,12,2,138,9,2,1,2,1,2,1,3,1,3,5,3,144,8,3,10,3,
        12,3,147,9,3,1,3,1,3,1,4,1,4,1,4,5,4,154,8,4,10,4,12,4,157,9,4,1,
        4,3,4,160,8,4,1,5,1,5,1,5,5,5,165,8,5,10,5,12,5,168,9,5,1,6,1,6,
        1,6,5,6,173,8,6,10,6,12,6,176,9,6,1,7,1,7,1,7,5,7,181,8,7,10,7,12,
        7,184,9,7,1,8,1,8,1,8,5,8,189,8,8,10,8,12,8,192,9,8,1,9,1,9,1,9,
        5,9,197,8,9,10,9,12,9,200,9,9,1,10,1,10,5,10,204,8,10,10,10,12,10,
        207,9,10,1,10,3,10,210,8,10,1,11,1,11,5,11,214,8,11,10,11,12,11,
        217,9,11,1,12,1,12,5,12,221,8,12,10,12,12,12,224,9,12,1,13,1,13,
        1,13,5,13,229,8,13,10,13,12,13,232,9,13,1,13,1,13,3,13,236,8,13,
        1,14,1,14,5,14,240,8,14,10,14,12,14,243,9,14,1,15,1,15,5,15,247,
        8,15,10,15,12,15,250,9,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
        1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
        1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
        1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,293,8,16,1,16,1,16,1,16,
        1,16,3,16,299,8,16,3,16,301,8,16,1,16,1,16,1,16,1,16,3,16,307,8,
        16,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
        18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
        18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
        18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,
        18,360,8,18,1,18,1,18,1,18,1,18,3,18,366,8,18,3,18,368,8,18,1,18,
        1,18,1,18,1,18,3,18,374,8,18,1,19,1,19,1,19,1,20,1,20,1,20,1,20,
        1,20,1,20,1,20,1,20,1,20,1,20,1,20,3,20,390,8,20,1,21,1,21,1,21,
        1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,
        1,21,1,21,1,21,3,21,411,8,21,1,21,1,21,1,21,3,21,416,8,21,1,21,1,
        21,1,21,3,21,421,8,21,1,21,1,21,1,21,3,21,426,8,21,1,21,1,21,3,21,
        430,8,21,1,22,3,22,433,8,22,1,22,5,22,436,8,22,10,22,12,22,439,9,
        22,1,22,5,22,442,8,22,10,22,12,22,445,9,22,1,22,1,22,5,22,449,8,
        22,10,22,12,22,452,9,22,1,22,3,22,455,8,22,1,22,1,22,3,22,459,8,
        22,1,22,5,22,462,8,22,10,22,12,22,465,9,22,1,22,3,22,468,8,22,1,
        22,1,22,3,22,472,8,22,1,22,5,22,475,8,22,10,22,12,22,478,9,22,1,
        22,1,22,5,22,482,8,22,10,22,12,22,485,9,22,1,22,1,22,1,22,3,22,490,
        8,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,500,8,23,1,24,
        1,24,1,24,1,24,3,24,506,8,24,1,25,1,25,1,26,1,26,1,27,1,27,1,27,
        1,27,3,27,516,8,27,1,27,3,27,519,8,27,1,27,1,27,1,27,1,27,1,27,1,
        27,3,27,527,8,27,1,28,1,28,1,28,1,28,1,28,3,28,534,8,28,1,29,1,29,
        3,29,538,8,29,1,29,3,29,541,8,29,1,29,3,29,544,8,29,1,29,3,29,547,
        8,29,1,29,3,29,550,8,29,1,30,1,30,1,30,3,30,555,8,30,1,30,1,30,1,
        30,1,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,3,31,571,
        8,31,1,32,1,32,3,32,575,8,32,1,32,1,32,3,32,579,8,32,1,32,1,32,3,
        32,583,8,32,1,32,1,32,3,32,587,8,32,1,32,1,32,3,32,591,8,32,1,33,
        1,33,1,33,3,33,596,8,33,1,33,3,33,599,8,33,1,34,1,34,1,34,1,34,1,
        34,1,34,1,34,1,34,1,34,1,34,3,34,611,8,34,1,35,1,35,1,35,1,35,1,
        35,1,35,1,35,1,35,1,35,1,35,3,35,623,8,35,1,36,1,36,1,36,1,36,1,
        36,1,36,1,36,1,36,3,36,633,8,36,1,37,1,37,1,38,1,38,1,38,1,38,1,
        38,1,38,1,38,3,38,644,8,38,1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,
        40,1,40,1,40,1,40,3,40,657,8,40,1,41,1,41,1,41,1,41,1,41,3,41,664,
        8,41,1,42,1,42,1,42,3,42,669,8,42,1,42,1,42,1,43,1,43,1,43,5,43,
        676,8,43,10,43,12,43,679,9,43,1,44,1,44,1,44,5,44,684,8,44,10,44,
        12,44,687,9,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,3,45,701,8,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,1,45,1,45,3,45,717,8,45,1,45,3,45,720,8,45,1,
        45,1,45,1,45,1,45,1,45,3,45,727,8,45,1,45,3,45,730,8,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,744,8,45,
        1,45,3,45,747,8,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,
        3,45,758,8,45,1,45,3,45,761,8,45,1,45,1,45,1,45,1,45,1,45,3,45,768,
        8,45,1,45,3,45,771,8,45,1,45,1,45,1,45,1,45,1,45,3,45,778,8,45,1,
        45,1,45,1,45,3,45,783,8,45,1,45,3,45,786,8,45,1,45,1,45,1,45,1,45,
        3,45,792,8,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,3,45,
        803,8,45,1,45,3,45,806,8,45,5,45,808,8,45,10,45,12,45,811,9,45,1,
        46,1,46,1,47,1,47,1,48,1,48,1,49,1,49,1,49,3,49,822,8,49,1,49,1,
        49,1,49,1,49,0,1,90,50,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,0,19,1,1,176,176,1,0,16,17,1,
        0,18,20,4,0,28,28,30,30,46,46,49,49,2,0,85,85,88,89,1,0,90,91,3,
        0,24,24,95,98,101,101,1,0,18,19,2,0,9,9,109,109,1,0,111,112,4,0,
        9,9,11,11,109,109,114,114,2,0,111,112,115,115,1,0,149,150,2,0,144,
        144,151,151,2,0,22,22,127,127,3,0,126,126,128,128,130,130,2,0,144,
        145,162,162,1,0,144,145,1,0,169,171,991,0,118,1,0,0,0,2,123,1,0,
        0,0,4,132,1,0,0,0,6,141,1,0,0,0,8,150,1,0,0,0,10,161,1,0,0,0,12,
        169,1,0,0,0,14,177,1,0,0,0,16,185,1,0,0,0,18,193,1,0,0,0,20,201,
        1,0,0,0,22,211,1,0,0,0,24,218,1,0,0,0,26,225,1,0,0,0,28,237,1,0,
        0,0,30,244,1,0,0,0,32,306,1,0,0,0,34,308,1,0,0,0,36,373,1,0,0,0,
        38,375,1,0,0,0,40,389,1,0,0,0,42,429,1,0,0,0,44,489,1,0,0,0,46,499,
        1,0,0,0,48,505,1,0,0,0,50,507,1,0,0,0,52,509,1,0,0,0,54,526,1,0,
        0,0,56,533,1,0,0,0,58,535,1,0,0,0,60,551,1,0,0,0,62,570,1,0,0,0,
        64,572,1,0,0,0,66,598,1,0,0,0,68,610,1,0,0,0,70,622,1,0,0,0,72,632,
        1,0,0,0,74,634,1,0,0,0,76,643,1,0,0,0,78,645,1,0,0,0,80,656,1,0,
        0,0,82,663,1,0,0,0,84,665,1,0,0,0,86,672,1,0,0,0,88,680,1,0,0,0,
        90,791,1,0,0,0,92,812,1,0,0,0,94,814,1,0,0,0,96,816,1,0,0,0,98,818,
        1,0,0,0,100,117,3,2,1,0,101,117,3,4,2,0,102,117,3,6,3,0,103,117,
        3,8,4,0,104,117,3,10,5,0,105,117,3,12,6,0,106,117,3,14,7,0,107,117,
        3,16,8,0,108,117,3,18,9,0,109,117,3,20,10,0,110,117,3,22,11,0,111,
        117,3,24,12,0,112,117,3,26,13,0,113,117,3,28,14,0,114,117,3,30,15,
        0,115,117,3,98,49,0,116,100,1,0,0,0,116,101,1,0,0,0,116,102,1,0,
        0,0,116,103,1,0,0,0,116,104,1,0,0,0,116,105,1,0,0,0,116,106,1,0,
        0,0,116,107,1,0,0,0,116,108,1,0,0,0,116,109,1,0,0,0,116,110,1,0,
        0,0,116,111,1,0,0,0,116,112,1,0,0,0,116,113,1,0,0,0,116,114,1,0,
        0,0,116,115,1,0,0,0,117,120,1,0,0,0,118,116,1,0,0,0,118,119,1,0,
        0,0,119,121,1,0,0,0,120,118,1,0,0,0,121,122,5,0,0,1,122,1,1,0,0,
        0,123,127,5,148,0,0,124,126,5,174,0,0,125,124,1,0,0,0,126,129,1,
        0,0,0,127,125,1,0,0,0,127,128,1,0,0,0,128,130,1,0,0,0,129,127,1,
        0,0,0,130,131,7,0,0,0,131,3,1,0,0,0,132,136,5,55,0,0,133,135,3,32,
        16,0,134,133,1,0,0,0,135,138,1,0,0,0,136,134,1,0,0,0,136,137,1,0,
        0,0,137,139,1,0,0,0,138,136,1,0,0,0,139,140,5,2,0,0,140,5,1,0,0,
        0,141,145,5,57,0,0,142,144,3,36,18,0,143,142,1,0,0,0,144,147,1,0,
        0,0,145,143,1,0,0,0,145,146,1,0,0,0,146,148,1,0,0,0,147,145,1,0,
        0,0,148,149,5,2,0,0,149,7,1,0,0,0,150,159,5,3,0,0,151,155,5,21,0,
        0,152,154,3,40,20,0,153,152,1,0,0,0,154,157,1,0,0,0,155,153,1,0,
        0,0,155,156,1,0,0,0,156,160,1,0,0,0,157,155,1,0,0,0,158,160,5,26,
        0,0,159,151,1,0,0,0,159,158,1,0,0,0,160,9,1,0,0,0,161,162,5,3,0,
        0,162,166,5,4,0,0,163,165,3,44,22,0,164,163,1,0,0,0,165,168,1,0,
        0,0,166,164,1,0,0,0,166,167,1,0,0,0,167,11,1,0,0,0,168,166,1,0,0,
        0,169,170,5,3,0,0,170,174,5,27,0,0,171,173,3,54,27,0,172,171,1,0,
        0,0,173,176,1,0,0,0,174,172,1,0,0,0,174,175,1,0,0,0,175,13,1,0,0,
        0,176,174,1,0,0,0,177,178,5,3,0,0,178,182,5,32,0,0,179,181,3,56,
        28,0,180,179,1,0,0,0,181,184,1,0,0,0,182,180,1,0,0,0,182,183,1,0,
        0,0,183,15,1,0,0,0,184,182,1,0,0,0,185,186,5,3,0,0,186,190,5,34,
        0,0,187,189,3,58,29,0,188,187,1,0,0,0,189,192,1,0,0,0,190,188,1,
        0,0,0,190,191,1,0,0,0,191,17,1,0,0,0,192,190,1,0,0,0,193,194,5,3,
        0,0,194,198,5,39,0,0,195,197,3,60,30,0,196,195,1,0,0,0,197,200,1,
        0,0,0,198,196,1,0,0,0,198,199,1,0,0,0,199,19,1,0,0,0,200,198,1,0,
        0,0,201,209,5,43,0,0,202,204,3,62,31,0,203,202,1,0,0,0,204,207,1,
        0,0,0,205,203,1,0,0,0,205,206,1,0,0,0,206,210,1,0,0,0,207,205,1,
        0,0,0,208,210,5,44,0,0,209,205,1,0,0,0,209,208,1,0,0,0,210,21,1,
        0,0,0,211,215,5,87,0,0,212,214,3,68,34,0,213,212,1,0,0,0,214,217,
        1,0,0,0,215,213,1,0,0,0,215,216,1,0,0,0,216,23,1,0,0,0,217,215,1,
        0,0,0,218,222,5,94,0,0,219,221,3,70,35,0,220,219,1,0,0,0,221,224,
        1,0,0,0,222,220,1,0,0,0,222,223,1,0,0,0,223,25,1,0,0,0,224,222,1,
        0,0,0,225,226,5,3,0,0,226,235,5,102,0,0,227,229,3,72,36,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,236,
        1,0,0,0,232,230,1,0,0,0,233,236,5,105,0,0,234,236,5,8,0,0,235,230,
        1,0,0,0,235,233,1,0,0,0,235,234,1,0,0,0,236,27,1,0,0,0,237,241,5,
        108,0,0,238,240,3,80,40,0,239,238,1,0,0,0,240,243,1,0,0,0,241,239,
        1,0,0,0,241,242,1,0,0,0,242,29,1,0,0,0,243,241,1,0,0,0,244,248,5,
        113,0,0,245,247,3,82,41,0,246,245,1,0,0,0,247,250,1,0,0,0,248,246,
        1,0,0,0,248,249,1,0,0,0,249,31,1,0,0,0,250,248,1,0,0,0,251,307,3,
        34,17,0,252,307,5,56,0,0,253,254,5,59,0,0,254,307,3,96,48,0,255,
        256,5,61,0,0,256,307,3,96,48,0,257,258,5,60,0,0,258,307,3,96,48,
        0,259,260,5,62,0,0,260,307,3,96,48,0,261,262,5,63,0,0,262,307,3,
        96,48,0,263,307,5,64,0,0,264,265,5,65,0,0,265,307,3,96,48,0,266,
        267,5,66,0,0,267,307,3,96,48,0,268,307,5,67,0,0,269,270,5,68,0,0,
        270,307,3,96,48,0,271,272,5,69,0,0,272,307,3,96,48,0,273,274,5,73,
        0,0,274,275,5,74,0,0,275,276,5,144,0,0,276,277,5,75,0,0,277,278,
        3,96,48,0,278,279,5,76,0,0,279,280,3,96,48,0,280,281,5,77,0,0,281,
        282,3,96,48,0,282,307,1,0,0,0,283,284,5,78,0,0,284,307,5,144,0,0,
        285,286,5,79,0,0,286,287,5,81,0,0,287,307,5,144,0,0,288,289,5,80,
        0,0,289,290,5,81,0,0,290,292,5,144,0,0,291,293,5,83,0,0,292,291,
        1,0,0,0,292,293,1,0,0,0,293,307,1,0,0,0,294,300,5,82,0,0,295,298,
        5,83,0,0,296,297,5,84,0,0,297,299,3,96,48,0,298,296,1,0,0,0,298,
        299,1,0,0,0,299,301,1,0,0,0,300,295,1,0,0,0,300,301,1,0,0,0,301,
        307,1,0,0,0,302,303,5,85,0,0,303,307,3,96,48,0,304,305,5,86,0,0,
        305,307,3,96,48,0,306,251,1,0,0,0,306,252,1,0,0,0,306,253,1,0,0,
        0,306,255,1,0,0,0,306,257,1,0,0,0,306,259,1,0,0,0,306,261,1,0,0,
        0,306,263,1,0,0,0,306,264,1,0,0,0,306,266,1,0,0,0,306,268,1,0,0,
        0,306,269,1,0,0,0,306,271,1,0,0,0,306,273,1,0,0,0,306,283,1,0,0,
        0,306,285,1,0,0,0,306,288,1,0,0,0,306,294,1,0,0,0,306,302,1,0,0,
        0,306,304,1,0,0,0,307,33,1,0,0,0,308,309,5,58,0,0,309,310,3,84,42,
        0,310,311,3,84,42,0,311,35,1,0,0,0,312,374,3,38,19,0,313,374,5,56,
        0,0,314,315,5,59,0,0,315,374,3,96,48,0,316,317,5,61,0,0,317,374,
        3,96,48,0,318,319,5,60,0,0,319,374,3,96,48,0,320,321,5,62,0,0,321,
        374,3,96,48,0,322,323,5,63,0,0,323,374,3,96,48,0,324,325,5,70,0,
        0,325,374,3,96,48,0,326,327,5,71,0,0,327,374,3,96,48,0,328,329,5,
        72,0,0,329,374,3,96,48,0,330,374,5,64,0,0,331,332,5,65,0,0,332,374,
        3,96,48,0,333,334,5,66,0,0,334,374,3,96,48,0,335,374,5,67,0,0,336,
        337,5,68,0,0,337,374,3,96,48,0,338,339,5,69,0,0,339,374,3,96,48,
        0,340,341,5,73,0,0,341,342,5,74,0,0,342,343,5,144,0,0,343,344,5,
        75,0,0,344,345,3,96,48,0,345,346,5,76,0,0,346,347,3,96,48,0,347,
        348,5,77,0,0,348,349,3,96,48,0,349,374,1,0,0,0,350,351,5,78,0,0,
        351,374,5,144,0,0,352,353,5,79,0,0,353,354,5,81,0,0,354,374,5,144,
        0,0,355,356,5,80,0,0,356,357,5,81,0,0,357,359,5,144,0,0,358,360,
        5,83,0,0,359,358,1,0,0,0,359,360,1,0,0,0,360,374,1,0,0,0,361,367,
        5,82,0,0,362,365,5,83,0,0,363,364,5,84,0,0,364,366,3,96,48,0,365,
        363,1,0,0,0,365,366,1,0,0,0,366,368,1,0,0,0,367,362,1,0,0,0,367,
        368,1,0,0,0,368,374,1,0,0,0,369,370,5,85,0,0,370,374,3,96,48,0,371,
        372,5,86,0,0,372,374,3,96,48,0,373,312,1,0,0,0,373,313,1,0,0,0,373,
        314,1,0,0,0,373,316,1,0,0,0,373,318,1,0,0,0,373,320,1,0,0,0,373,
        322,1,0,0,0,373,324,1,0,0,0,373,326,1,0,0,0,373,328,1,0,0,0,373,
        330,1,0,0,0,373,331,1,0,0,0,373,333,1,0,0,0,373,335,1,0,0,0,373,
        336,1,0,0,0,373,338,1,0,0,0,373,340,1,0,0,0,373,350,1,0,0,0,373,
        352,1,0,0,0,373,355,1,0,0,0,373,361,1,0,0,0,373,369,1,0,0,0,373,
        371,1,0,0,0,374,37,1,0,0,0,375,376,5,58,0,0,376,377,3,84,42,0,377,
        39,1,0,0,0,378,390,3,42,21,0,379,380,5,9,0,0,380,390,3,96,48,0,381,
        382,5,23,0,0,382,390,3,96,48,0,383,384,5,24,0,0,384,390,5,144,0,
        0,385,390,5,19,0,0,386,387,5,25,0,0,387,390,3,96,48,0,388,390,5,
        18,0,0,389,378,1,0,0,0,389,379,1,0,0,0,389,381,1,0,0,0,389,383,1,
        0,0,0,389,385,1,0,0,0,389,386,1,0,0,0,389,388,1,0,0,0,390,41,1,0,
        0,0,391,392,3,84,42,0,392,393,3,84,42,0,393,394,3,84,42,0,394,395,
        3,84,42,0,395,430,1,0,0,0,396,397,5,22,0,0,397,398,5,144,0,0,398,
        399,5,144,0,0,399,400,5,144,0,0,400,430,5,144,0,0,401,402,5,144,
        0,0,402,403,5,149,0,0,403,404,5,144,0,0,404,405,5,149,0,0,405,406,
        5,144,0,0,406,407,5,149,0,0,407,408,5,144,0,0,408,430,5,149,0,0,
        409,411,5,149,0,0,410,409,1,0,0,0,410,411,1,0,0,0,411,412,1,0,0,
        0,412,413,5,144,0,0,413,415,5,149,0,0,414,416,5,149,0,0,415,414,
        1,0,0,0,415,416,1,0,0,0,416,417,1,0,0,0,417,418,5,144,0,0,418,420,
        5,149,0,0,419,421,5,149,0,0,420,419,1,0,0,0,420,421,1,0,0,0,421,
        422,1,0,0,0,422,423,5,144,0,0,423,425,5,149,0,0,424,426,5,149,0,
        0,425,424,1,0,0,0,425,426,1,0,0,0,426,427,1,0,0,0,427,428,5,144,
        0,0,428,430,5,149,0,0,429,391,1,0,0,0,429,396,1,0,0,0,429,401,1,
        0,0,0,429,410,1,0,0,0,430,43,1,0,0,0,431,433,5,5,0,0,432,431,1,0,
        0,0,432,433,1,0,0,0,433,437,1,0,0,0,434,436,3,46,23,0,435,434,1,
        0,0,0,436,439,1,0,0,0,437,435,1,0,0,0,437,438,1,0,0,0,438,443,1,
        0,0,0,439,437,1,0,0,0,440,442,3,48,24,0,441,440,1,0,0,0,442,445,
        1,0,0,0,443,441,1,0,0,0,443,444,1,0,0,0,444,446,1,0,0,0,445,443,
        1,0,0,0,446,450,3,84,42,0,447,449,3,48,24,0,448,447,1,0,0,0,449,
        452,1,0,0,0,450,448,1,0,0,0,450,451,1,0,0,0,451,454,1,0,0,0,452,
        450,1,0,0,0,453,455,3,52,26,0,454,453,1,0,0,0,454,455,1,0,0,0,455,
        490,1,0,0,0,456,458,5,6,0,0,457,459,3,50,25,0,458,457,1,0,0,0,458,
        459,1,0,0,0,459,463,1,0,0,0,460,462,3,48,24,0,461,460,1,0,0,0,462,
        465,1,0,0,0,463,461,1,0,0,0,463,464,1,0,0,0,464,467,1,0,0,0,465,
        463,1,0,0,0,466,468,3,52,26,0,467,466,1,0,0,0,467,468,1,0,0,0,468,
        490,1,0,0,0,469,471,5,7,0,0,470,472,3,50,25,0,471,470,1,0,0,0,471,
        472,1,0,0,0,472,476,1,0,0,0,473,475,3,48,24,0,474,473,1,0,0,0,475,
        478,1,0,0,0,476,474,1,0,0,0,476,477,1,0,0,0,477,479,1,0,0,0,478,
        476,1,0,0,0,479,483,3,84,42,0,480,482,3,48,24,0,481,480,1,0,0,0,
        482,485,1,0,0,0,483,481,1,0,0,0,483,484,1,0,0,0,484,486,1,0,0,0,
        485,483,1,0,0,0,486,487,3,84,42,0,487,490,1,0,0,0,488,490,5,8,0,
        0,489,432,1,0,0,0,489,456,1,0,0,0,489,469,1,0,0,0,489,488,1,0,0,
        0,490,45,1,0,0,0,491,492,5,12,0,0,492,500,5,144,0,0,493,494,5,13,
        0,0,494,500,3,92,46,0,495,496,5,14,0,0,496,500,3,92,46,0,497,498,
        5,15,0,0,498,500,3,92,46,0,499,491,1,0,0,0,499,493,1,0,0,0,499,495,
        1,0,0,0,499,497,1,0,0,0,500,47,1,0,0,0,501,502,5,9,0,0,502,506,3,
        92,46,0,503,506,5,10,0,0,504,506,5,11,0,0,505,501,1,0,0,0,505,503,
        1,0,0,0,505,504,1,0,0,0,506,49,1,0,0,0,507,508,7,1,0,0,508,51,1,
        0,0,0,509,510,7,2,0,0,510,53,1,0,0,0,511,512,5,28,0,0,512,515,3,
        92,46,0,513,514,5,12,0,0,514,516,5,144,0,0,515,513,1,0,0,0,515,516,
        1,0,0,0,516,518,1,0,0,0,517,519,5,29,0,0,518,517,1,0,0,0,518,519,
        1,0,0,0,519,527,1,0,0,0,520,521,5,30,0,0,521,527,3,92,46,0,522,523,
        5,21,0,0,523,527,3,92,46,0,524,525,5,31,0,0,525,527,3,92,46,0,526,
        511,1,0,0,0,526,520,1,0,0,0,526,522,1,0,0,0,526,524,1,0,0,0,527,
        55,1,0,0,0,528,529,5,9,0,0,529,534,3,92,46,0,530,531,5,12,0,0,531,
        534,5,144,0,0,532,534,5,33,0,0,533,528,1,0,0,0,533,530,1,0,0,0,533,
        532,1,0,0,0,534,57,1,0,0,0,535,537,3,84,42,0,536,538,5,35,0,0,537,
        536,1,0,0,0,537,538,1,0,0,0,538,540,1,0,0,0,539,541,5,28,0,0,540,
        539,1,0,0,0,540,541,1,0,0,0,541,543,1,0,0,0,542,544,5,36,0,0,543,
        542,1,0,0,0,543,544,1,0,0,0,544,546,1,0,0,0,545,547,5,37,0,0,546,
        545,1,0,0,0,546,547,1,0,0,0,547,549,1,0,0,0,548,550,5,38,0,0,549,
        548,1,0,0,0,549,550,1,0,0,0,550,59,1,0,0,0,551,552,5,9,0,0,552,554,
        3,92,46,0,553,555,5,11,0,0,554,553,1,0,0,0,554,555,1,0,0,0,555,556,
        1,0,0,0,556,557,5,40,0,0,557,558,3,92,46,0,558,559,5,41,0,0,559,
        560,3,92,46,0,560,561,5,42,0,0,561,562,3,92,46,0,562,563,3,84,42,
        0,563,61,1,0,0,0,564,565,3,84,42,0,565,566,3,84,42,0,566,567,3,64,
        32,0,567,571,1,0,0,0,568,571,3,66,33,0,569,571,5,45,0,0,570,564,
        1,0,0,0,570,568,1,0,0,0,570,569,1,0,0,0,571,63,1,0,0,0,572,578,7,
        3,0,0,573,575,5,18,0,0,574,573,1,0,0,0,574,575,1,0,0,0,575,579,1,
        0,0,0,576,579,5,19,0,0,577,579,5,50,0,0,578,574,1,0,0,0,578,576,
        1,0,0,0,578,577,1,0,0,0,579,582,1,0,0,0,580,581,5,47,0,0,581,583,
        3,92,46,0,582,580,1,0,0,0,582,583,1,0,0,0,583,586,1,0,0,0,584,585,
        5,48,0,0,585,587,5,144,0,0,586,584,1,0,0,0,586,587,1,0,0,0,587,590,
        1,0,0,0,588,589,5,51,0,0,589,591,3,92,46,0,590,588,1,0,0,0,590,591,
        1,0,0,0,591,65,1,0,0,0,592,595,5,52,0,0,593,594,5,53,0,0,594,596,
        5,149,0,0,595,593,1,0,0,0,595,596,1,0,0,0,596,599,1,0,0,0,597,599,
        5,54,0,0,598,592,1,0,0,0,598,597,1,0,0,0,599,67,1,0,0,0,600,611,
        5,56,0,0,601,602,7,4,0,0,602,611,3,92,46,0,603,604,7,5,0,0,604,611,
        5,144,0,0,605,611,5,92,0,0,606,611,5,93,0,0,607,608,3,84,42,0,608,
        609,3,84,42,0,609,611,1,0,0,0,610,600,1,0,0,0,610,601,1,0,0,0,610,
        603,1,0,0,0,610,605,1,0,0,0,610,606,1,0,0,0,610,607,1,0,0,0,611,
        69,1,0,0,0,612,613,5,9,0,0,613,623,3,92,46,0,614,615,7,6,0,0,615,
        623,3,92,46,0,616,623,5,44,0,0,617,623,5,99,0,0,618,619,5,100,0,
        0,619,623,5,144,0,0,620,623,5,11,0,0,621,623,3,84,42,0,622,612,1,
        0,0,0,622,614,1,0,0,0,622,616,1,0,0,0,622,617,1,0,0,0,622,618,1,
        0,0,0,622,620,1,0,0,0,622,621,1,0,0,0,623,71,1,0,0,0,624,633,5,7,
        0,0,625,626,5,103,0,0,626,633,5,144,0,0,627,633,5,104,0,0,628,633,
        3,74,37,0,629,633,3,76,38,0,630,633,3,78,39,0,631,633,3,84,42,0,
        632,624,1,0,0,0,632,625,1,0,0,0,632,627,1,0,0,0,632,628,1,0,0,0,
        632,629,1,0,0,0,632,630,1,0,0,0,632,631,1,0,0,0,633,73,1,0,0,0,634,
        635,7,1,0,0,635,75,1,0,0,0,636,637,5,9,0,0,637,644,3,92,46,0,638,
        644,5,10,0,0,639,640,5,106,0,0,640,644,3,92,46,0,641,642,5,107,0,
        0,642,644,3,92,46,0,643,636,1,0,0,0,643,638,1,0,0,0,643,639,1,0,
        0,0,643,641,1,0,0,0,644,77,1,0,0,0,645,646,7,7,0,0,646,79,1,0,0,
        0,647,657,5,56,0,0,648,649,7,8,0,0,649,657,3,92,46,0,650,657,5,102,
        0,0,651,657,5,19,0,0,652,657,5,110,0,0,653,654,7,9,0,0,654,657,5,
        144,0,0,655,657,3,84,42,0,656,647,1,0,0,0,656,648,1,0,0,0,656,650,
        1,0,0,0,656,651,1,0,0,0,656,652,1,0,0,0,656,653,1,0,0,0,656,655,
        1,0,0,0,657,81,1,0,0,0,658,659,7,10,0,0,659,664,3,92,46,0,660,661,
        7,11,0,0,661,664,5,144,0,0,662,664,3,84,42,0,663,658,1,0,0,0,663,
        660,1,0,0,0,663,662,1,0,0,0,664,83,1,0,0,0,665,666,5,116,0,0,666,
        668,3,86,43,0,667,669,5,105,0,0,668,667,1,0,0,0,668,669,1,0,0,0,
        669,670,1,0,0,0,670,671,5,2,0,0,671,85,1,0,0,0,672,677,3,88,44,0,
        673,674,5,117,0,0,674,676,3,88,44,0,675,673,1,0,0,0,676,679,1,0,
        0,0,677,675,1,0,0,0,677,678,1,0,0,0,678,87,1,0,0,0,679,677,1,0,0,
        0,680,685,3,90,45,0,681,682,5,118,0,0,682,684,3,90,45,0,683,681,
        1,0,0,0,684,687,1,0,0,0,685,683,1,0,0,0,685,686,1,0,0,0,686,89,1,
        0,0,0,687,685,1,0,0,0,688,689,6,45,-1,0,689,690,5,152,0,0,690,691,
        3,86,43,0,691,692,5,153,0,0,692,792,1,0,0,0,693,792,5,142,0,0,694,
        695,5,133,0,0,695,696,7,12,0,0,696,697,7,13,0,0,697,792,7,12,0,0,
        698,700,5,134,0,0,699,701,5,177,0,0,700,699,1,0,0,0,700,701,1,0,
        0,0,701,702,1,0,0,0,702,703,5,178,0,0,703,704,5,179,0,0,704,792,
        3,94,47,0,705,706,5,122,0,0,706,792,3,90,45,18,707,708,5,124,0,0,
        708,792,3,90,45,17,709,710,5,123,0,0,710,792,3,90,45,16,711,719,
        5,131,0,0,712,720,5,150,0,0,713,716,5,149,0,0,714,715,5,154,0,0,
        715,717,5,149,0,0,716,714,1,0,0,0,716,717,1,0,0,0,717,720,1,0,0,
        0,718,720,5,162,0,0,719,712,1,0,0,0,719,713,1,0,0,0,719,718,1,0,
        0,0,720,792,1,0,0,0,721,729,5,132,0,0,722,730,5,150,0,0,723,726,
        5,149,0,0,724,725,5,154,0,0,725,727,5,149,0,0,726,724,1,0,0,0,726,
        727,1,0,0,0,727,730,1,0,0,0,728,730,5,162,0,0,729,722,1,0,0,0,729,
        723,1,0,0,0,729,728,1,0,0,0,730,792,1,0,0,0,731,792,5,136,0,0,732,
        792,5,137,0,0,733,792,5,138,0,0,734,792,5,143,0,0,735,736,5,119,
        0,0,736,792,3,90,45,9,737,738,5,135,0,0,738,739,3,94,47,0,739,740,
        3,94,47,0,740,743,3,94,47,0,741,742,5,84,0,0,742,744,3,94,47,0,743,
        741,1,0,0,0,743,744,1,0,0,0,744,746,1,0,0,0,745,747,5,24,0,0,746,
        745,1,0,0,0,746,747,1,0,0,0,747,792,1,0,0,0,748,792,5,139,0,0,749,
        792,5,140,0,0,750,751,5,141,0,0,751,792,5,144,0,0,752,760,7,14,0,
        0,753,761,5,151,0,0,754,757,5,144,0,0,755,756,5,154,0,0,756,758,
        5,144,0,0,757,755,1,0,0,0,757,758,1,0,0,0,758,761,1,0,0,0,759,761,
        5,162,0,0,760,753,1,0,0,0,760,754,1,0,0,0,760,759,1,0,0,0,761,792,
        1,0,0,0,762,770,5,129,0,0,763,771,5,150,0,0,764,767,5,149,0,0,765,
        766,5,154,0,0,766,768,5,149,0,0,767,765,1,0,0,0,767,768,1,0,0,0,
        768,771,1,0,0,0,769,771,5,162,0,0,770,763,1,0,0,0,770,764,1,0,0,
        0,770,769,1,0,0,0,771,792,1,0,0,0,772,785,5,125,0,0,773,786,5,150,
        0,0,774,777,5,149,0,0,775,776,5,154,0,0,776,778,5,149,0,0,777,775,
        1,0,0,0,777,778,1,0,0,0,778,786,1,0,0,0,779,782,5,146,0,0,780,781,
        5,154,0,0,781,783,5,146,0,0,782,780,1,0,0,0,782,783,1,0,0,0,783,
        786,1,0,0,0,784,786,5,162,0,0,785,773,1,0,0,0,785,774,1,0,0,0,785,
        779,1,0,0,0,785,784,1,0,0,0,786,792,1,0,0,0,787,788,7,15,0,0,788,
        789,5,144,0,0,789,790,5,154,0,0,790,792,5,144,0,0,791,688,1,0,0,
        0,791,693,1,0,0,0,791,694,1,0,0,0,791,698,1,0,0,0,791,705,1,0,0,
        0,791,707,1,0,0,0,791,709,1,0,0,0,791,711,1,0,0,0,791,721,1,0,0,
        0,791,731,1,0,0,0,791,732,1,0,0,0,791,733,1,0,0,0,791,734,1,0,0,
        0,791,735,1,0,0,0,791,737,1,0,0,0,791,748,1,0,0,0,791,749,1,0,0,
        0,791,750,1,0,0,0,791,752,1,0,0,0,791,762,1,0,0,0,791,772,1,0,0,
        0,791,787,1,0,0,0,792,809,1,0,0,0,793,794,10,22,0,0,794,795,5,120,
        0,0,795,808,3,94,47,0,796,797,10,21,0,0,797,805,5,121,0,0,798,806,
        5,151,0,0,799,802,5,144,0,0,800,801,5,154,0,0,801,803,5,144,0,0,
        802,800,1,0,0,0,802,803,1,0,0,0,803,806,1,0,0,0,804,806,5,162,0,
        0,805,798,1,0,0,0,805,799,1,0,0,0,805,804,1,0,0,0,806,808,1,0,0,
        0,807,793,1,0,0,0,807,796,1,0,0,0,808,811,1,0,0,0,809,807,1,0,0,
        0,809,810,1,0,0,0,810,91,1,0,0,0,811,809,1,0,0,0,812,813,7,16,0,
        0,813,93,1,0,0,0,814,815,7,17,0,0,815,95,1,0,0,0,816,817,7,16,0,
        0,817,97,1,0,0,0,818,819,5,1,0,0,819,821,5,171,0,0,820,822,5,168,
        0,0,821,820,1,0,0,0,821,822,1,0,0,0,822,823,1,0,0,0,823,824,7,18,
        0,0,824,825,5,173,0,0,825,99,1,0,0,0,95,116,118,127,136,145,155,
        159,166,174,182,190,198,205,209,215,222,230,235,241,248,292,298,
        300,306,359,365,367,373,389,410,415,420,425,429,432,437,443,450,
        454,458,463,467,471,476,483,489,499,505,515,518,526,533,537,540,
        543,546,549,554,570,574,578,582,586,590,595,598,610,622,632,643,
        656,663,668,677,685,700,716,719,726,729,743,746,757,760,767,770,
        777,782,785,791,802,805,807,809,821
    ]

class CharmmMRParser ( Parser ):

    grammarFileName = "CharmmMRParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'SET'", "'END'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'MASS'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'MAIN'", "'COMP'", "'KEEP'", "<INVALID>", "<INVALID>", 
                     "'MIN'", "<INVALID>", "<INVALID>", "'CLDH'", "'IC'", 
                     "'BOND'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'FIX'", "'PURG'", "'THET'", "'PHI'", 
                     "'IMPH'", "'HMCM'", "'REFX'", "'REFY'", "'REFZ'", "<INVALID>", 
                     "'OFF'", "<INVALID>", "'BONH'", "'TOL'", "<INVALID>", 
                     "'ANGH'", "<INVALID>", "<INVALID>", "'FAST'", "<INVALID>", 
                     "<INVALID>", "'NOE'", "<INVALID>", "'PNOE'", "<INVALID>", 
                     "'KMIN'", "'KMAX'", "'RMIN'", "'RMAX'", "'FMAX'", "'MINDIST'", 
                     "'RSWI'", "'SEXP'", "'SUMR'", "'TCON'", "'REXP'", "'CNOX'", 
                     "'CNOY'", "'CNOZ'", "<INVALID>", "'INOE'", "'TNOX'", 
                     "'TNOY'", "'TNOZ'", "<INVALID>", "'READ'", "<INVALID>", 
                     "'UNIT'", "<INVALID>", "'ANAL'", "'CUT'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'KVAL'", "'RVAL'", "'EVAL'", 
                     "'IVAL'", "<INVALID>", "<INVALID>", "'PULL'", "'XDIR'", 
                     "'YDIR'", "'ZDIR'", "<INVALID>", "'LIST'", "<INVALID>", 
                     "<INVALID>", "'RMSD'", "'MAXN'", "'NPRT'", "'SHOW'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'.OR.'", "'.AND.'", 
                     "'.NOT.'", "'.AROUND.'", "'.SUBSET.'", "'.BONDED.'", 
                     "'.BYRES.'", "'.BYGROUP.'", "<INVALID>", "'ISEG'", 
                     "<INVALID>", "'IRES'", "<INVALID>", "<INVALID>", "'TYPE'", 
                     "<INVALID>", "'ATOM'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'LONE'", "<INVALID>", "'USER'", "<INVALID>", "<INVALID>", 
                     "'ALL'", "'NONE'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'('", "')'", "':'", "'.EQ.'", "'.LT.'", 
                     "'.GT.'", "'.LE.'", "'.GE.'", "'.NE.'", "'.AE.'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'='", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'ABS'" ]

    symbolicNames = [ "<INVALID>", "Set", "End", "Cons", "Harmonic", "Absolute", 
                      "Bestfit", "Relative", "Clear", "Force", "Mass", "Weight", 
                      "Exponent", "XScale", "YScale", "ZScale", "NoRotation", 
                      "NoTranslation", "Main", "Comp", "Keep", "Dihedral", 
                      "ByNumber", "Min", "Period", "Width", "ClDh", "IC", 
                      "Bond", "Upper", "Angle", "Improper", "Droplet", "NoMass", 
                      "Fix", "Purg", "Thet", "Phi", "Imph", "Hmcm", "RefX", 
                      "RefY", "RefZ", "Shake", "Off", "NoReset", "BonH", 
                      "Tol", "MxIter", "AngH", "Parameters", "ShkScale", 
                      "Fast", "Water", "NoFast", "Noe", "Reset", "PNoe", 
                      "Assign", "KMin", "KMax", "RMin", "RMax", "FMax", 
                      "MinDist", "RSwi", "SExp", "SumR", "TCon", "RExp", 
                      "CnoX", "CnoY", "CnoZ", "MPNoe", "INoe", "TnoX", "TnoY", 
                      "TnoZ", "NMPNoe", "Read", "Write", "Unit", "Print", 
                      "Anal", "Cut", "Scale", "Temperature", "ResDistance", 
                      "KVal", "RVal", "EVal", "IVal", "Positive", "Negative", 
                      "Pull", "XDir", "YDir", "ZDir", "EField", "List", 
                      "Switch", "SForce", "RMSD", "MaxN", "NPrt", "Show", 
                      "Offset", "BOffset", "RGyration", "Reference", "Orient", 
                      "Output", "NSave", "DMConstrain", "Cutoff", "NContact", 
                      "Selection", "Or_op", "And_op", "Not_op", "Around", 
                      "Subset", "Bonded", "ByRes", "ByGroup", "SegIdentifier", 
                      "ISeg", "Residue", "IRes", "Resname", "IGroup", "Type", 
                      "Chemical", "Atom", "Property", "Point", "Initial", 
                      "Lone", "Hydrogen", "User", "Previous", "Recall", 
                      "All", "NONE", "Integer", "Real", "Double_quote_string", 
                      "SMCLN_COMMENT", "COMMENT", "Simple_name", "Simple_names", 
                      "Integers", "L_paren", "R_paren", "Colon", "Equ_op", 
                      "Lt_op", "Gt_op", "Leq_op", "Geq_op", "Neq_op", "Aeq_op", 
                      "Symbol_name", "SPACE", "CONTINUE", "ENCLOSE_COMMENT", 
                      "SECTION_COMMENT", "LINE_COMMENT", "Equ_op_VE", "Integer_VE", 
                      "Real_VE", "Simple_name_VE", "SPACE_VE", "RETURN_VE", 
                      "Any_name", "SPACE_CM", "RETURN_CM", "Abs", "Attr_properties", 
                      "Comparison_ops", "SPACE_AP" ]

    RULE_charmm_mr = 0
    RULE_comment = 1
    RULE_distance_restraint = 2
    RULE_point_distance_restraint = 3
    RULE_dihedral_angle_restraint = 4
    RULE_harmonic_restraint = 5
    RULE_manipulate_internal_coordinate = 6
    RULE_droplet_potential = 7
    RULE_fix_atom_constraint = 8
    RULE_center_of_mass_constraint = 9
    RULE_fix_bond_or_angle_constraint = 10
    RULE_restrained_distance = 11
    RULE_external_force = 12
    RULE_rmsd_restraint = 13
    RULE_gyration_restraint = 14
    RULE_distance_matrix_restraint = 15
    RULE_noe_statement = 16
    RULE_noe_assign = 17
    RULE_pnoe_statement = 18
    RULE_pnoe_assign = 19
    RULE_dihedral_statement = 20
    RULE_dihedral_assign = 21
    RULE_harmonic_statement = 22
    RULE_absolute_spec = 23
    RULE_force_const_spec = 24
    RULE_bestfit_spec = 25
    RULE_coordinate_spec = 26
    RULE_ic_statement = 27
    RULE_droplet_statement = 28
    RULE_fix_atom_statement = 29
    RULE_center_of_mass_statement = 30
    RULE_fix_bond_or_angle_statement = 31
    RULE_shake_opt = 32
    RULE_fast_opt = 33
    RULE_restrained_distance_statement = 34
    RULE_external_force_statement = 35
    RULE_rmsd_statement = 36
    RULE_rmsd_orient_spec = 37
    RULE_rmsd_force_const_spec = 38
    RULE_rmsd_coordinate_spec = 39
    RULE_gyration_statement = 40
    RULE_distance_matrix_statement = 41
    RULE_selection = 42
    RULE_selection_expression = 43
    RULE_term = 44
    RULE_factor = 45
    RULE_number = 46
    RULE_number_f = 47
    RULE_number_s = 48
    RULE_set_statement = 49

    ruleNames =  [ "charmm_mr", "comment", "distance_restraint", "point_distance_restraint", 
                   "dihedral_angle_restraint", "harmonic_restraint", "manipulate_internal_coordinate", 
                   "droplet_potential", "fix_atom_constraint", "center_of_mass_constraint", 
                   "fix_bond_or_angle_constraint", "restrained_distance", 
                   "external_force", "rmsd_restraint", "gyration_restraint", 
                   "distance_matrix_restraint", "noe_statement", "noe_assign", 
                   "pnoe_statement", "pnoe_assign", "dihedral_statement", 
                   "dihedral_assign", "harmonic_statement", "absolute_spec", 
                   "force_const_spec", "bestfit_spec", "coordinate_spec", 
                   "ic_statement", "droplet_statement", "fix_atom_statement", 
                   "center_of_mass_statement", "fix_bond_or_angle_statement", 
                   "shake_opt", "fast_opt", "restrained_distance_statement", 
                   "external_force_statement", "rmsd_statement", "rmsd_orient_spec", 
                   "rmsd_force_const_spec", "rmsd_coordinate_spec", "gyration_statement", 
                   "distance_matrix_statement", "selection", "selection_expression", 
                   "term", "factor", "number", "number_f", "number_s", "set_statement" ]

    EOF = Token.EOF
    Set=1
    End=2
    Cons=3
    Harmonic=4
    Absolute=5
    Bestfit=6
    Relative=7
    Clear=8
    Force=9
    Mass=10
    Weight=11
    Exponent=12
    XScale=13
    YScale=14
    ZScale=15
    NoRotation=16
    NoTranslation=17
    Main=18
    Comp=19
    Keep=20
    Dihedral=21
    ByNumber=22
    Min=23
    Period=24
    Width=25
    ClDh=26
    IC=27
    Bond=28
    Upper=29
    Angle=30
    Improper=31
    Droplet=32
    NoMass=33
    Fix=34
    Purg=35
    Thet=36
    Phi=37
    Imph=38
    Hmcm=39
    RefX=40
    RefY=41
    RefZ=42
    Shake=43
    Off=44
    NoReset=45
    BonH=46
    Tol=47
    MxIter=48
    AngH=49
    Parameters=50
    ShkScale=51
    Fast=52
    Water=53
    NoFast=54
    Noe=55
    Reset=56
    PNoe=57
    Assign=58
    KMin=59
    KMax=60
    RMin=61
    RMax=62
    FMax=63
    MinDist=64
    RSwi=65
    SExp=66
    SumR=67
    TCon=68
    RExp=69
    CnoX=70
    CnoY=71
    CnoZ=72
    MPNoe=73
    INoe=74
    TnoX=75
    TnoY=76
    TnoZ=77
    NMPNoe=78
    Read=79
    Write=80
    Unit=81
    Print=82
    Anal=83
    Cut=84
    Scale=85
    Temperature=86
    ResDistance=87
    KVal=88
    RVal=89
    EVal=90
    IVal=91
    Positive=92
    Negative=93
    Pull=94
    XDir=95
    YDir=96
    ZDir=97
    EField=98
    List=99
    Switch=100
    SForce=101
    RMSD=102
    MaxN=103
    NPrt=104
    Show=105
    Offset=106
    BOffset=107
    RGyration=108
    Reference=109
    Orient=110
    Output=111
    NSave=112
    DMConstrain=113
    Cutoff=114
    NContact=115
    Selection=116
    Or_op=117
    And_op=118
    Not_op=119
    Around=120
    Subset=121
    Bonded=122
    ByRes=123
    ByGroup=124
    SegIdentifier=125
    ISeg=126
    Residue=127
    IRes=128
    Resname=129
    IGroup=130
    Type=131
    Chemical=132
    Atom=133
    Property=134
    Point=135
    Initial=136
    Lone=137
    Hydrogen=138
    User=139
    Previous=140
    Recall=141
    All=142
    NONE=143
    Integer=144
    Real=145
    Double_quote_string=146
    SMCLN_COMMENT=147
    COMMENT=148
    Simple_name=149
    Simple_names=150
    Integers=151
    L_paren=152
    R_paren=153
    Colon=154
    Equ_op=155
    Lt_op=156
    Gt_op=157
    Leq_op=158
    Geq_op=159
    Neq_op=160
    Aeq_op=161
    Symbol_name=162
    SPACE=163
    CONTINUE=164
    ENCLOSE_COMMENT=165
    SECTION_COMMENT=166
    LINE_COMMENT=167
    Equ_op_VE=168
    Integer_VE=169
    Real_VE=170
    Simple_name_VE=171
    SPACE_VE=172
    RETURN_VE=173
    Any_name=174
    SPACE_CM=175
    RETURN_CM=176
    Abs=177
    Attr_properties=178
    Comparison_ops=179
    SPACE_AP=180

    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 Charmm_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(CharmmMRParser.EOF, 0)

        def comment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.CommentContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.CommentContext,i)


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


        def point_distance_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Point_distance_restraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Point_distance_restraintContext,i)


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


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


        def manipulate_internal_coordinate(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Manipulate_internal_coordinateContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Manipulate_internal_coordinateContext,i)


        def droplet_potential(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Droplet_potentialContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Droplet_potentialContext,i)


        def fix_atom_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Fix_atom_constraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Fix_atom_constraintContext,i)


        def center_of_mass_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Center_of_mass_constraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Center_of_mass_constraintContext,i)


        def fix_bond_or_angle_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Fix_bond_or_angle_constraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Fix_bond_or_angle_constraintContext,i)


        def restrained_distance(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Restrained_distanceContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Restrained_distanceContext,i)


        def external_force(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.External_forceContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.External_forceContext,i)


        def rmsd_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Rmsd_restraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Rmsd_restraintContext,i)


        def gyration_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Gyration_restraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Gyration_restraintContext,i)


        def distance_matrix_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Distance_matrix_restraintContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Distance_matrix_restraintContext,i)


        def set_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Set_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Set_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_charmm_mr

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

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




    def charmm_mr(self):

        localctx = CharmmMRParser.Charmm_mrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_charmm_mr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 118
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 180152781187842058) != 0) or ((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & 2305843009282900097) != 0):
                self.state = 116
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 100
                    self.comment()
                    pass

                elif la_ == 2:
                    self.state = 101
                    self.distance_restraint()
                    pass

                elif la_ == 3:
                    self.state = 102
                    self.point_distance_restraint()
                    pass

                elif la_ == 4:
                    self.state = 103
                    self.dihedral_angle_restraint()
                    pass

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

                elif la_ == 6:
                    self.state = 105
                    self.manipulate_internal_coordinate()
                    pass

                elif la_ == 7:
                    self.state = 106
                    self.droplet_potential()
                    pass

                elif la_ == 8:
                    self.state = 107
                    self.fix_atom_constraint()
                    pass

                elif la_ == 9:
                    self.state = 108
                    self.center_of_mass_constraint()
                    pass

                elif la_ == 10:
                    self.state = 109
                    self.fix_bond_or_angle_constraint()
                    pass

                elif la_ == 11:
                    self.state = 110
                    self.restrained_distance()
                    pass

                elif la_ == 12:
                    self.state = 111
                    self.external_force()
                    pass

                elif la_ == 13:
                    self.state = 112
                    self.rmsd_restraint()
                    pass

                elif la_ == 14:
                    self.state = 113
                    self.gyration_restraint()
                    pass

                elif la_ == 15:
                    self.state = 114
                    self.distance_matrix_restraint()
                    pass

                elif la_ == 16:
                    self.state = 115
                    self.set_statement()
                    pass


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

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


    class CommentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def COMMENT(self):
            return self.getToken(CharmmMRParser.COMMENT, 0)

        def RETURN_CM(self):
            return self.getToken(CharmmMRParser.RETURN_CM, 0)

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

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

        def getRuleIndex(self):
            return CharmmMRParser.RULE_comment

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

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




    def comment(self):

        localctx = CharmmMRParser.CommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_comment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 123
            self.match(CharmmMRParser.COMMENT)
            self.state = 127
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==174:
                self.state = 124
                self.match(CharmmMRParser.Any_name)
                self.state = 129
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 130
            _la = self._input.LA(1)
            if not(_la==-1 or _la==176):
                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 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(CharmmMRParser.Noe, 0)

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

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


        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Distance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_distance_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 132
            self.match(CharmmMRParser.Noe)
            self.state = 136
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & 1707229181) != 0):
                self.state = 133
                self.noe_statement()
                self.state = 138
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Point_distance_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PNoe(self):
            return self.getToken(CharmmMRParser.PNoe, 0)

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

        def pnoe_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Pnoe_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Pnoe_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_point_distance_restraint

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

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




    def point_distance_restraint(self):

        localctx = CharmmMRParser.Point_distance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_point_distance_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 141
            self.match(CharmmMRParser.PNoe)
            self.state = 145
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & 1707343869) != 0):
                self.state = 142
                self.pnoe_statement()
                self.state = 147
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 148
            self.match(CharmmMRParser.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 Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

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

        def ClDh(self):
            return self.getToken(CharmmMRParser.ClDh, 0)

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


        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Dihedral_angle_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_dihedral_angle_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 150
            self.match(CharmmMRParser.Cons)
            self.state = 159
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [21]:
                self.state = 151
                self.match(CharmmMRParser.Dihedral)
                self.state = 155
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 63701504) != 0) or ((((_la - 116)) & ~0x3f) == 0 and ((1 << (_la - 116)) & 8858370049) != 0):
                    self.state = 152
                    self.dihedral_statement()
                    self.state = 157
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [26]:
                self.state = 158
                self.match(CharmmMRParser.ClDh)
                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_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

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

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


        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Harmonic_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_harmonic_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 161
            self.match(CharmmMRParser.Cons)
            self.state = 162
            self.match(CharmmMRParser.Harmonic)
            self.state = 166
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 65504) != 0) or _la==116:
                self.state = 163
                self.harmonic_statement()
                self.state = 168
                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 Manipulate_internal_coordinateContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

        def IC(self):
            return self.getToken(CharmmMRParser.IC, 0)

        def ic_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Ic_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Ic_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_manipulate_internal_coordinate

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

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




    def manipulate_internal_coordinate(self):

        localctx = CharmmMRParser.Manipulate_internal_coordinateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_manipulate_internal_coordinate)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 169
            self.match(CharmmMRParser.Cons)
            self.state = 170
            self.match(CharmmMRParser.IC)
            self.state = 174
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3491758080) != 0):
                self.state = 171
                self.ic_statement()
                self.state = 176
                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 Droplet_potentialContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

        def Droplet(self):
            return self.getToken(CharmmMRParser.Droplet, 0)

        def droplet_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Droplet_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Droplet_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_droplet_potential

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

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




    def droplet_potential(self):

        localctx = CharmmMRParser.Droplet_potentialContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_droplet_potential)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self.match(CharmmMRParser.Cons)
            self.state = 178
            self.match(CharmmMRParser.Droplet)
            self.state = 182
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8589939200) != 0):
                self.state = 179
                self.droplet_statement()
                self.state = 184
                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 Fix_atom_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

        def Fix(self):
            return self.getToken(CharmmMRParser.Fix, 0)

        def fix_atom_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Fix_atom_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Fix_atom_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_fix_atom_constraint

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

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




    def fix_atom_constraint(self):

        localctx = CharmmMRParser.Fix_atom_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_fix_atom_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 185
            self.match(CharmmMRParser.Cons)
            self.state = 186
            self.match(CharmmMRParser.Fix)
            self.state = 190
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==116:
                self.state = 187
                self.fix_atom_statement()
                self.state = 192
                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 Center_of_mass_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

        def Hmcm(self):
            return self.getToken(CharmmMRParser.Hmcm, 0)

        def center_of_mass_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Center_of_mass_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Center_of_mass_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_center_of_mass_constraint

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

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




    def center_of_mass_constraint(self):

        localctx = CharmmMRParser.Center_of_mass_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_center_of_mass_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 193
            self.match(CharmmMRParser.Cons)
            self.state = 194
            self.match(CharmmMRParser.Hmcm)
            self.state = 198
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==9:
                self.state = 195
                self.center_of_mass_statement()
                self.state = 200
                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 Fix_bond_or_angle_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Shake(self):
            return self.getToken(CharmmMRParser.Shake, 0)

        def Off(self):
            return self.getToken(CharmmMRParser.Off, 0)

        def fix_bond_or_angle_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Fix_bond_or_angle_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Fix_bond_or_angle_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_fix_bond_or_angle_constraint

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

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




    def fix_bond_or_angle_constraint(self):

        localctx = CharmmMRParser.Fix_bond_or_angle_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_fix_bond_or_angle_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 201
            self.match(CharmmMRParser.Shake)
            self.state = 209
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [-1, 1, 3, 43, 45, 52, 54, 55, 57, 87, 94, 108, 113, 116, 148]:
                self.state = 205
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 22553182508941312) != 0) or _la==116:
                    self.state = 202
                    self.fix_bond_or_angle_statement()
                    self.state = 207
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [44]:
                self.state = 208
                self.match(CharmmMRParser.Off)
                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 Restrained_distanceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ResDistance(self):
            return self.getToken(CharmmMRParser.ResDistance, 0)

        def restrained_distance_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Restrained_distance_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Restrained_distance_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_restrained_distance

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

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




    def restrained_distance(self):

        localctx = CharmmMRParser.Restrained_distanceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_restrained_distance)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self.match(CharmmMRParser.ResDistance)
            self.state = 215
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & 1152921775726657537) != 0):
                self.state = 212
                self.restrained_distance_statement()
                self.state = 217
                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 External_forceContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Pull(self):
            return self.getToken(CharmmMRParser.Pull, 0)

        def external_force_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.External_force_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.External_force_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_external_force

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

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




    def external_force(self):

        localctx = CharmmMRParser.External_forceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_external_force)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 218
            self.match(CharmmMRParser.Pull)
            self.state = 222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 17592202824192) != 0) or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 2097279) != 0):
                self.state = 219
                self.external_force_statement()
                self.state = 224
                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 Rmsd_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Cons(self):
            return self.getToken(CharmmMRParser.Cons, 0)

        def RMSD(self):
            return self.getToken(CharmmMRParser.RMSD, 0)

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

        def Clear(self):
            return self.getToken(CharmmMRParser.Clear, 0)

        def rmsd_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Rmsd_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Rmsd_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_rmsd_restraint

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

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




    def rmsd_restraint(self):

        localctx = CharmmMRParser.Rmsd_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_rmsd_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self.match(CharmmMRParser.Cons)
            self.state = 226
            self.match(CharmmMRParser.RMSD)
            self.state = 235
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [-1, 1, 3, 7, 9, 10, 16, 17, 18, 19, 43, 55, 57, 87, 94, 103, 104, 106, 107, 108, 113, 116, 148]:
                self.state = 230
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 984704) != 0) or ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & 8219) != 0):
                    self.state = 227
                    self.rmsd_statement()
                    self.state = 232
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [105]:
                self.state = 233
                self.match(CharmmMRParser.Show)
                pass
            elif token in [8]:
                self.state = 234
                self.match(CharmmMRParser.Clear)
                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 Gyration_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RGyration(self):
            return self.getToken(CharmmMRParser.RGyration, 0)

        def gyration_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Gyration_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Gyration_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_gyration_restraint

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

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




    def gyration_restraint(self):

        localctx = CharmmMRParser.Gyration_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_gyration_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 237
            self.match(CharmmMRParser.RGyration)
            self.state = 241
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 72057594038452736) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & 18305) != 0):
                self.state = 238
                self.gyration_statement()
                self.state = 243
                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 Distance_matrix_restraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DMConstrain(self):
            return self.getToken(CharmmMRParser.DMConstrain, 0)

        def distance_matrix_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Distance_matrix_statementContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Distance_matrix_statementContext,i)


        def getRuleIndex(self):
            return CharmmMRParser.RULE_distance_matrix_restraint

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

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




    def distance_matrix_restraint(self):

        localctx = CharmmMRParser.Distance_matrix_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_distance_matrix_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 244
            self.match(CharmmMRParser.DMConstrain)
            self.state = 248
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==9 or _la==11 or ((((_la - 109)) & ~0x3f) == 0 and ((1 << (_la - 109)) & 237) != 0):
                self.state = 245
                self.distance_matrix_statement()
                self.state = 250
                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 Noe_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def KMin(self):
            return self.getToken(CharmmMRParser.KMin, 0)

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


        def RMin(self):
            return self.getToken(CharmmMRParser.RMin, 0)

        def KMax(self):
            return self.getToken(CharmmMRParser.KMax, 0)

        def RMax(self):
            return self.getToken(CharmmMRParser.RMax, 0)

        def FMax(self):
            return self.getToken(CharmmMRParser.FMax, 0)

        def MinDist(self):
            return self.getToken(CharmmMRParser.MinDist, 0)

        def RSwi(self):
            return self.getToken(CharmmMRParser.RSwi, 0)

        def SExp(self):
            return self.getToken(CharmmMRParser.SExp, 0)

        def SumR(self):
            return self.getToken(CharmmMRParser.SumR, 0)

        def TCon(self):
            return self.getToken(CharmmMRParser.TCon, 0)

        def RExp(self):
            return self.getToken(CharmmMRParser.RExp, 0)

        def MPNoe(self):
            return self.getToken(CharmmMRParser.MPNoe, 0)

        def INoe(self):
            return self.getToken(CharmmMRParser.INoe, 0)

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

        def TnoX(self):
            return self.getToken(CharmmMRParser.TnoX, 0)

        def TnoY(self):
            return self.getToken(CharmmMRParser.TnoY, 0)

        def TnoZ(self):
            return self.getToken(CharmmMRParser.TnoZ, 0)

        def NMPNoe(self):
            return self.getToken(CharmmMRParser.NMPNoe, 0)

        def Read(self):
            return self.getToken(CharmmMRParser.Read, 0)

        def Unit(self):
            return self.getToken(CharmmMRParser.Unit, 0)

        def Write(self):
            return self.getToken(CharmmMRParser.Write, 0)

        def Anal(self):
            return self.getToken(CharmmMRParser.Anal, 0)

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

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

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

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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Noe_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_noe_statement)
        self._la = 0 # Token type
        try:
            self.state = 306
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58]:
                self.enterOuterAlt(localctx, 1)
                self.state = 251
                self.noe_assign()
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 2)
                self.state = 252
                self.match(CharmmMRParser.Reset)
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 3)
                self.state = 253
                self.match(CharmmMRParser.KMin)
                self.state = 254
                self.number_s()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 4)
                self.state = 255
                self.match(CharmmMRParser.RMin)
                self.state = 256
                self.number_s()
                pass
            elif token in [60]:
                self.enterOuterAlt(localctx, 5)
                self.state = 257
                self.match(CharmmMRParser.KMax)
                self.state = 258
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 6)
                self.state = 259
                self.match(CharmmMRParser.RMax)
                self.state = 260
                self.number_s()
                pass
            elif token in [63]:
                self.enterOuterAlt(localctx, 7)
                self.state = 261
                self.match(CharmmMRParser.FMax)
                self.state = 262
                self.number_s()
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 8)
                self.state = 263
                self.match(CharmmMRParser.MinDist)
                pass
            elif token in [65]:
                self.enterOuterAlt(localctx, 9)
                self.state = 264
                self.match(CharmmMRParser.RSwi)
                self.state = 265
                self.number_s()
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 10)
                self.state = 266
                self.match(CharmmMRParser.SExp)
                self.state = 267
                self.number_s()
                pass
            elif token in [67]:
                self.enterOuterAlt(localctx, 11)
                self.state = 268
                self.match(CharmmMRParser.SumR)
                pass
            elif token in [68]:
                self.enterOuterAlt(localctx, 12)
                self.state = 269
                self.match(CharmmMRParser.TCon)
                self.state = 270
                self.number_s()
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 13)
                self.state = 271
                self.match(CharmmMRParser.RExp)
                self.state = 272
                self.number_s()
                pass
            elif token in [73]:
                self.enterOuterAlt(localctx, 14)
                self.state = 273
                self.match(CharmmMRParser.MPNoe)
                self.state = 274
                self.match(CharmmMRParser.INoe)
                self.state = 275
                self.match(CharmmMRParser.Integer)
                self.state = 276
                self.match(CharmmMRParser.TnoX)
                self.state = 277
                self.number_s()
                self.state = 278
                self.match(CharmmMRParser.TnoY)
                self.state = 279
                self.number_s()
                self.state = 280
                self.match(CharmmMRParser.TnoZ)
                self.state = 281
                self.number_s()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 15)
                self.state = 283
                self.match(CharmmMRParser.NMPNoe)
                self.state = 284
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [79]:
                self.enterOuterAlt(localctx, 16)
                self.state = 285
                self.match(CharmmMRParser.Read)
                self.state = 286
                self.match(CharmmMRParser.Unit)
                self.state = 287
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [80]:
                self.enterOuterAlt(localctx, 17)
                self.state = 288
                self.match(CharmmMRParser.Write)
                self.state = 289
                self.match(CharmmMRParser.Unit)
                self.state = 290
                self.match(CharmmMRParser.Integer)
                self.state = 292
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==83:
                    self.state = 291
                    self.match(CharmmMRParser.Anal)


                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 18)
                self.state = 294
                self.match(CharmmMRParser.Print)
                self.state = 300
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==83:
                    self.state = 295
                    self.match(CharmmMRParser.Anal)
                    self.state = 298
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==84:
                        self.state = 296
                        self.match(CharmmMRParser.Cut)
                        self.state = 297
                        self.number_s()




                pass
            elif token in [85]:
                self.enterOuterAlt(localctx, 19)
                self.state = 302
                self.match(CharmmMRParser.Scale)
                self.state = 303
                self.number_s()
                pass
            elif token in [86]:
                self.enterOuterAlt(localctx, 20)
                self.state = 304
                self.match(CharmmMRParser.Temperature)
                self.state = 305
                self.number_s()
                pass
            else:
                raise NoViableAltException(self)

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


    class Noe_assignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Noe_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_noe_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.match(CharmmMRParser.Assign)
            self.state = 309
            self.selection()
            self.state = 310
            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 Pnoe_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pnoe_assign(self):
            return self.getTypedRuleContext(CharmmMRParser.Pnoe_assignContext,0)


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

        def KMin(self):
            return self.getToken(CharmmMRParser.KMin, 0)

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


        def RMin(self):
            return self.getToken(CharmmMRParser.RMin, 0)

        def KMax(self):
            return self.getToken(CharmmMRParser.KMax, 0)

        def RMax(self):
            return self.getToken(CharmmMRParser.RMax, 0)

        def FMax(self):
            return self.getToken(CharmmMRParser.FMax, 0)

        def CnoX(self):
            return self.getToken(CharmmMRParser.CnoX, 0)

        def CnoY(self):
            return self.getToken(CharmmMRParser.CnoY, 0)

        def CnoZ(self):
            return self.getToken(CharmmMRParser.CnoZ, 0)

        def MinDist(self):
            return self.getToken(CharmmMRParser.MinDist, 0)

        def RSwi(self):
            return self.getToken(CharmmMRParser.RSwi, 0)

        def SExp(self):
            return self.getToken(CharmmMRParser.SExp, 0)

        def SumR(self):
            return self.getToken(CharmmMRParser.SumR, 0)

        def TCon(self):
            return self.getToken(CharmmMRParser.TCon, 0)

        def RExp(self):
            return self.getToken(CharmmMRParser.RExp, 0)

        def MPNoe(self):
            return self.getToken(CharmmMRParser.MPNoe, 0)

        def INoe(self):
            return self.getToken(CharmmMRParser.INoe, 0)

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

        def TnoX(self):
            return self.getToken(CharmmMRParser.TnoX, 0)

        def TnoY(self):
            return self.getToken(CharmmMRParser.TnoY, 0)

        def TnoZ(self):
            return self.getToken(CharmmMRParser.TnoZ, 0)

        def NMPNoe(self):
            return self.getToken(CharmmMRParser.NMPNoe, 0)

        def Read(self):
            return self.getToken(CharmmMRParser.Read, 0)

        def Unit(self):
            return self.getToken(CharmmMRParser.Unit, 0)

        def Write(self):
            return self.getToken(CharmmMRParser.Write, 0)

        def Anal(self):
            return self.getToken(CharmmMRParser.Anal, 0)

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

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

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

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

        def getRuleIndex(self):
            return CharmmMRParser.RULE_pnoe_statement

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

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




    def pnoe_statement(self):

        localctx = CharmmMRParser.Pnoe_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_pnoe_statement)
        self._la = 0 # Token type
        try:
            self.state = 373
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [58]:
                self.enterOuterAlt(localctx, 1)
                self.state = 312
                self.pnoe_assign()
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 2)
                self.state = 313
                self.match(CharmmMRParser.Reset)
                pass
            elif token in [59]:
                self.enterOuterAlt(localctx, 3)
                self.state = 314
                self.match(CharmmMRParser.KMin)
                self.state = 315
                self.number_s()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 4)
                self.state = 316
                self.match(CharmmMRParser.RMin)
                self.state = 317
                self.number_s()
                pass
            elif token in [60]:
                self.enterOuterAlt(localctx, 5)
                self.state = 318
                self.match(CharmmMRParser.KMax)
                self.state = 319
                self.number_s()
                pass
            elif token in [62]:
                self.enterOuterAlt(localctx, 6)
                self.state = 320
                self.match(CharmmMRParser.RMax)
                self.state = 321
                self.number_s()
                pass
            elif token in [63]:
                self.enterOuterAlt(localctx, 7)
                self.state = 322
                self.match(CharmmMRParser.FMax)
                self.state = 323
                self.number_s()
                pass
            elif token in [70]:
                self.enterOuterAlt(localctx, 8)
                self.state = 324
                self.match(CharmmMRParser.CnoX)
                self.state = 325
                self.number_s()
                pass
            elif token in [71]:
                self.enterOuterAlt(localctx, 9)
                self.state = 326
                self.match(CharmmMRParser.CnoY)
                self.state = 327
                self.number_s()
                pass
            elif token in [72]:
                self.enterOuterAlt(localctx, 10)
                self.state = 328
                self.match(CharmmMRParser.CnoZ)
                self.state = 329
                self.number_s()
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 11)
                self.state = 330
                self.match(CharmmMRParser.MinDist)
                pass
            elif token in [65]:
                self.enterOuterAlt(localctx, 12)
                self.state = 331
                self.match(CharmmMRParser.RSwi)
                self.state = 332
                self.number_s()
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 13)
                self.state = 333
                self.match(CharmmMRParser.SExp)
                self.state = 334
                self.number_s()
                pass
            elif token in [67]:
                self.enterOuterAlt(localctx, 14)
                self.state = 335
                self.match(CharmmMRParser.SumR)
                pass
            elif token in [68]:
                self.enterOuterAlt(localctx, 15)
                self.state = 336
                self.match(CharmmMRParser.TCon)
                self.state = 337
                self.number_s()
                pass
            elif token in [69]:
                self.enterOuterAlt(localctx, 16)
                self.state = 338
                self.match(CharmmMRParser.RExp)
                self.state = 339
                self.number_s()
                pass
            elif token in [73]:
                self.enterOuterAlt(localctx, 17)
                self.state = 340
                self.match(CharmmMRParser.MPNoe)
                self.state = 341
                self.match(CharmmMRParser.INoe)
                self.state = 342
                self.match(CharmmMRParser.Integer)
                self.state = 343
                self.match(CharmmMRParser.TnoX)
                self.state = 344
                self.number_s()
                self.state = 345
                self.match(CharmmMRParser.TnoY)
                self.state = 346
                self.number_s()
                self.state = 347
                self.match(CharmmMRParser.TnoZ)
                self.state = 348
                self.number_s()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 18)
                self.state = 350
                self.match(CharmmMRParser.NMPNoe)
                self.state = 351
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [79]:
                self.enterOuterAlt(localctx, 19)
                self.state = 352
                self.match(CharmmMRParser.Read)
                self.state = 353
                self.match(CharmmMRParser.Unit)
                self.state = 354
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [80]:
                self.enterOuterAlt(localctx, 20)
                self.state = 355
                self.match(CharmmMRParser.Write)
                self.state = 356
                self.match(CharmmMRParser.Unit)
                self.state = 357
                self.match(CharmmMRParser.Integer)
                self.state = 359
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==83:
                    self.state = 358
                    self.match(CharmmMRParser.Anal)


                pass
            elif token in [82]:
                self.enterOuterAlt(localctx, 21)
                self.state = 361
                self.match(CharmmMRParser.Print)
                self.state = 367
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==83:
                    self.state = 362
                    self.match(CharmmMRParser.Anal)
                    self.state = 365
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==84:
                        self.state = 363
                        self.match(CharmmMRParser.Cut)
                        self.state = 364
                        self.number_s()




                pass
            elif token in [85]:
                self.enterOuterAlt(localctx, 22)
                self.state = 369
                self.match(CharmmMRParser.Scale)
                self.state = 370
                self.number_s()
                pass
            elif token in [86]:
                self.enterOuterAlt(localctx, 23)
                self.state = 371
                self.match(CharmmMRParser.Temperature)
                self.state = 372
                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 Pnoe_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(CharmmMRParser.Assign, 0)

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


        def getRuleIndex(self):
            return CharmmMRParser.RULE_pnoe_assign

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

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




    def pnoe_assign(self):

        localctx = CharmmMRParser.Pnoe_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_pnoe_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 375
            self.match(CharmmMRParser.Assign)
            self.state = 376
            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 Dihedral_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

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


        def Min(self):
            return self.getToken(CharmmMRParser.Min, 0)

        def Period(self):
            return self.getToken(CharmmMRParser.Period, 0)

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

        def Comp(self):
            return self.getToken(CharmmMRParser.Comp, 0)

        def Width(self):
            return self.getToken(CharmmMRParser.Width, 0)

        def Main(self):
            return self.getToken(CharmmMRParser.Main, 0)

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Dihedral_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_dihedral_statement)
        try:
            self.state = 389
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [22, 116, 144, 149]:
                self.enterOuterAlt(localctx, 1)
                self.state = 378
                self.dihedral_assign()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 2)
                self.state = 379
                self.match(CharmmMRParser.Force)
                self.state = 380
                self.number_s()
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 3)
                self.state = 381
                self.match(CharmmMRParser.Min)
                self.state = 382
                self.number_s()
                pass
            elif token in [24]:
                self.enterOuterAlt(localctx, 4)
                self.state = 383
                self.match(CharmmMRParser.Period)
                self.state = 384
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 5)
                self.state = 385
                self.match(CharmmMRParser.Comp)
                pass
            elif token in [25]:
                self.enterOuterAlt(localctx, 6)
                self.state = 386
                self.match(CharmmMRParser.Width)
                self.state = 387
                self.number_s()
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 7)
                self.state = 388
                self.match(CharmmMRParser.Main)
                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 selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.SelectionContext,i)


        def ByNumber(self):
            return self.getToken(CharmmMRParser.ByNumber, 0)

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

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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Dihedral_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_dihedral_assign)
        self._la = 0 # Token type
        try:
            self.state = 429
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 391
                self.selection()
                self.state = 392
                self.selection()
                self.state = 393
                self.selection()
                self.state = 394
                self.selection()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 396
                self.match(CharmmMRParser.ByNumber)
                self.state = 397
                self.match(CharmmMRParser.Integer)
                self.state = 398
                self.match(CharmmMRParser.Integer)
                self.state = 399
                self.match(CharmmMRParser.Integer)
                self.state = 400
                self.match(CharmmMRParser.Integer)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 401
                self.match(CharmmMRParser.Integer)
                self.state = 402
                self.match(CharmmMRParser.Simple_name)
                self.state = 403
                self.match(CharmmMRParser.Integer)
                self.state = 404
                self.match(CharmmMRParser.Simple_name)
                self.state = 405
                self.match(CharmmMRParser.Integer)
                self.state = 406
                self.match(CharmmMRParser.Simple_name)
                self.state = 407
                self.match(CharmmMRParser.Integer)
                self.state = 408
                self.match(CharmmMRParser.Simple_name)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 410
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 409
                    self.match(CharmmMRParser.Simple_name)


                self.state = 412
                self.match(CharmmMRParser.Integer)
                self.state = 413
                self.match(CharmmMRParser.Simple_name)
                self.state = 415
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 414
                    self.match(CharmmMRParser.Simple_name)


                self.state = 417
                self.match(CharmmMRParser.Integer)
                self.state = 418
                self.match(CharmmMRParser.Simple_name)
                self.state = 420
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 419
                    self.match(CharmmMRParser.Simple_name)


                self.state = 422
                self.match(CharmmMRParser.Integer)
                self.state = 423
                self.match(CharmmMRParser.Simple_name)
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==149:
                    self.state = 424
                    self.match(CharmmMRParser.Simple_name)


                self.state = 427
                self.match(CharmmMRParser.Integer)
                self.state = 428
                self.match(CharmmMRParser.Simple_name)
                pass


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


        def Absolute(self):
            return self.getToken(CharmmMRParser.Absolute, 0)

        def absolute_spec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Absolute_specContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Absolute_specContext,i)


        def force_const_spec(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CharmmMRParser.Force_const_specContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.Force_const_specContext,i)


        def coordinate_spec(self):
            return self.getTypedRuleContext(CharmmMRParser.Coordinate_specContext,0)


        def Bestfit(self):
            return self.getToken(CharmmMRParser.Bestfit, 0)

        def bestfit_spec(self):
            return self.getTypedRuleContext(CharmmMRParser.Bestfit_specContext,0)


        def Relative(self):
            return self.getToken(CharmmMRParser.Relative, 0)

        def Clear(self):
            return self.getToken(CharmmMRParser.Clear, 0)

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Harmonic_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_harmonic_statement)
        self._la = 0 # Token type
        try:
            self.state = 489
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 9, 10, 11, 12, 13, 14, 15, 116]:
                self.enterOuterAlt(localctx, 1)
                self.state = 432
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==5:
                    self.state = 431
                    self.match(CharmmMRParser.Absolute)


                self.state = 437
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 61440) != 0):
                    self.state = 434
                    self.absolute_spec()
                    self.state = 439
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 443
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3584) != 0):
                    self.state = 440
                    self.force_const_spec()
                    self.state = 445
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 446
                self.selection()
                self.state = 450
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,37,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 447
                        self.force_const_spec() 
                    self.state = 452
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,37,self._ctx)

                self.state = 454
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1835008) != 0):
                    self.state = 453
                    self.coordinate_spec()


                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 2)
                self.state = 456
                self.match(CharmmMRParser.Bestfit)
                self.state = 458
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16 or _la==17:
                    self.state = 457
                    self.bestfit_spec()


                self.state = 463
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 460
                        self.force_const_spec() 
                    self.state = 465
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,40,self._ctx)

                self.state = 467
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 1835008) != 0):
                    self.state = 466
                    self.coordinate_spec()


                pass
            elif token in [7]:
                self.enterOuterAlt(localctx, 3)
                self.state = 469
                self.match(CharmmMRParser.Relative)
                self.state = 471
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16 or _la==17:
                    self.state = 470
                    self.bestfit_spec()


                self.state = 476
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3584) != 0):
                    self.state = 473
                    self.force_const_spec()
                    self.state = 478
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 479
                self.selection()
                self.state = 483
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3584) != 0):
                    self.state = 480
                    self.force_const_spec()
                    self.state = 485
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 486
                self.selection()
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 4)
                self.state = 488
                self.match(CharmmMRParser.Clear)
                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 Absolute_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def XScale(self):
            return self.getToken(CharmmMRParser.XScale, 0)

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


        def YScale(self):
            return self.getToken(CharmmMRParser.YScale, 0)

        def ZScale(self):
            return self.getToken(CharmmMRParser.ZScale, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_absolute_spec

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

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




    def absolute_spec(self):

        localctx = CharmmMRParser.Absolute_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_absolute_spec)
        try:
            self.state = 499
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [12]:
                self.enterOuterAlt(localctx, 1)
                self.state = 491
                self.match(CharmmMRParser.Exponent)
                self.state = 492
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [13]:
                self.enterOuterAlt(localctx, 2)
                self.state = 493
                self.match(CharmmMRParser.XScale)
                self.state = 494
                self.number()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 3)
                self.state = 495
                self.match(CharmmMRParser.YScale)
                self.state = 496
                self.number()
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 4)
                self.state = 497
                self.match(CharmmMRParser.ZScale)
                self.state = 498
                self.number()
                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 Force_const_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

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


        def Mass(self):
            return self.getToken(CharmmMRParser.Mass, 0)

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

        def getRuleIndex(self):
            return CharmmMRParser.RULE_force_const_spec

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

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




    def force_const_spec(self):

        localctx = CharmmMRParser.Force_const_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_force_const_spec)
        try:
            self.state = 505
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 501
                self.match(CharmmMRParser.Force)
                self.state = 502
                self.number()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 503
                self.match(CharmmMRParser.Mass)
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 3)
                self.state = 504
                self.match(CharmmMRParser.Weight)
                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 Bestfit_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NoRotation(self):
            return self.getToken(CharmmMRParser.NoRotation, 0)

        def NoTranslation(self):
            return self.getToken(CharmmMRParser.NoTranslation, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_bestfit_spec

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

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




    def bestfit_spec(self):

        localctx = CharmmMRParser.Bestfit_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_bestfit_spec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 507
            _la = self._input.LA(1)
            if not(_la==16 or _la==17):
                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 Coordinate_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Main(self):
            return self.getToken(CharmmMRParser.Main, 0)

        def Comp(self):
            return self.getToken(CharmmMRParser.Comp, 0)

        def Keep(self):
            return self.getToken(CharmmMRParser.Keep, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_coordinate_spec

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

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




    def coordinate_spec(self):

        localctx = CharmmMRParser.Coordinate_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_coordinate_spec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 509
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1835008) != 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 Ic_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Bond(self):
            return self.getToken(CharmmMRParser.Bond, 0)

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


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

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

        def Upper(self):
            return self.getToken(CharmmMRParser.Upper, 0)

        def Angle(self):
            return self.getToken(CharmmMRParser.Angle, 0)

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

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

        def getRuleIndex(self):
            return CharmmMRParser.RULE_ic_statement

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

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




    def ic_statement(self):

        localctx = CharmmMRParser.Ic_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_ic_statement)
        self._la = 0 # Token type
        try:
            self.state = 526
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [28]:
                self.enterOuterAlt(localctx, 1)
                self.state = 511
                self.match(CharmmMRParser.Bond)
                self.state = 512
                self.number()
                self.state = 515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==12:
                    self.state = 513
                    self.match(CharmmMRParser.Exponent)
                    self.state = 514
                    self.match(CharmmMRParser.Integer)


                self.state = 518
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==29:
                    self.state = 517
                    self.match(CharmmMRParser.Upper)


                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 2)
                self.state = 520
                self.match(CharmmMRParser.Angle)
                self.state = 521
                self.number()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 3)
                self.state = 522
                self.match(CharmmMRParser.Dihedral)
                self.state = 523
                self.number()
                pass
            elif token in [31]:
                self.enterOuterAlt(localctx, 4)
                self.state = 524
                self.match(CharmmMRParser.Improper)
                self.state = 525
                self.number()
                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 Droplet_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

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


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

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

        def NoMass(self):
            return self.getToken(CharmmMRParser.NoMass, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_droplet_statement

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

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




    def droplet_statement(self):

        localctx = CharmmMRParser.Droplet_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_droplet_statement)
        try:
            self.state = 533
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 528
                self.match(CharmmMRParser.Force)
                self.state = 529
                self.number()
                pass
            elif token in [12]:
                self.enterOuterAlt(localctx, 2)
                self.state = 530
                self.match(CharmmMRParser.Exponent)
                self.state = 531
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [33]:
                self.enterOuterAlt(localctx, 3)
                self.state = 532
                self.match(CharmmMRParser.NoMass)
                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 Fix_atom_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.getTypedRuleContext(CharmmMRParser.SelectionContext,0)


        def Purg(self):
            return self.getToken(CharmmMRParser.Purg, 0)

        def Bond(self):
            return self.getToken(CharmmMRParser.Bond, 0)

        def Thet(self):
            return self.getToken(CharmmMRParser.Thet, 0)

        def Phi(self):
            return self.getToken(CharmmMRParser.Phi, 0)

        def Imph(self):
            return self.getToken(CharmmMRParser.Imph, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_fix_atom_statement

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

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




    def fix_atom_statement(self):

        localctx = CharmmMRParser.Fix_atom_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_fix_atom_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 535
            self.selection()
            self.state = 537
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==35:
                self.state = 536
                self.match(CharmmMRParser.Purg)


            self.state = 540
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==28:
                self.state = 539
                self.match(CharmmMRParser.Bond)


            self.state = 543
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==36:
                self.state = 542
                self.match(CharmmMRParser.Thet)


            self.state = 546
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==37:
                self.state = 545
                self.match(CharmmMRParser.Phi)


            self.state = 549
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==38:
                self.state = 548
                self.match(CharmmMRParser.Imph)


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


    class Center_of_mass_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

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


        def RefX(self):
            return self.getToken(CharmmMRParser.RefX, 0)

        def RefY(self):
            return self.getToken(CharmmMRParser.RefY, 0)

        def RefZ(self):
            return self.getToken(CharmmMRParser.RefZ, 0)

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


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

        def getRuleIndex(self):
            return CharmmMRParser.RULE_center_of_mass_statement

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

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




    def center_of_mass_statement(self):

        localctx = CharmmMRParser.Center_of_mass_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_center_of_mass_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.match(CharmmMRParser.Force)
            self.state = 552
            self.number()
            self.state = 554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==11:
                self.state = 553
                self.match(CharmmMRParser.Weight)


            self.state = 556
            self.match(CharmmMRParser.RefX)
            self.state = 557
            self.number()
            self.state = 558
            self.match(CharmmMRParser.RefY)
            self.state = 559
            self.number()
            self.state = 560
            self.match(CharmmMRParser.RefZ)
            self.state = 561
            self.number()
            self.state = 562
            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 Fix_bond_or_angle_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def shake_opt(self):
            return self.getTypedRuleContext(CharmmMRParser.Shake_optContext,0)


        def fast_opt(self):
            return self.getTypedRuleContext(CharmmMRParser.Fast_optContext,0)


        def NoReset(self):
            return self.getToken(CharmmMRParser.NoReset, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_fix_bond_or_angle_statement

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

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




    def fix_bond_or_angle_statement(self):

        localctx = CharmmMRParser.Fix_bond_or_angle_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_fix_bond_or_angle_statement)
        try:
            self.state = 570
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [116]:
                self.enterOuterAlt(localctx, 1)
                self.state = 564
                self.selection()
                self.state = 565
                self.selection()
                self.state = 566
                self.shake_opt()
                pass
            elif token in [52, 54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 568
                self.fast_opt()
                pass
            elif token in [45]:
                self.enterOuterAlt(localctx, 3)
                self.state = 569
                self.match(CharmmMRParser.NoReset)
                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 Shake_optContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BonH(self):
            return self.getToken(CharmmMRParser.BonH, 0)

        def Bond(self):
            return self.getToken(CharmmMRParser.Bond, 0)

        def AngH(self):
            return self.getToken(CharmmMRParser.AngH, 0)

        def Angle(self):
            return self.getToken(CharmmMRParser.Angle, 0)

        def Comp(self):
            return self.getToken(CharmmMRParser.Comp, 0)

        def Parameters(self):
            return self.getToken(CharmmMRParser.Parameters, 0)

        def Tol(self):
            return self.getToken(CharmmMRParser.Tol, 0)

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


        def MxIter(self):
            return self.getToken(CharmmMRParser.MxIter, 0)

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

        def ShkScale(self):
            return self.getToken(CharmmMRParser.ShkScale, 0)

        def Main(self):
            return self.getToken(CharmmMRParser.Main, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_shake_opt

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

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




    def shake_opt(self):

        localctx = CharmmMRParser.Shake_optContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_shake_opt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 572
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 633320039776256) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 578
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [-1, 1, 3, 18, 43, 45, 47, 48, 51, 52, 54, 55, 57, 87, 94, 108, 113, 116, 148]:
                self.state = 574
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==18:
                    self.state = 573
                    self.match(CharmmMRParser.Main)


                pass
            elif token in [19]:
                self.state = 576
                self.match(CharmmMRParser.Comp)
                pass
            elif token in [50]:
                self.state = 577
                self.match(CharmmMRParser.Parameters)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 582
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==47:
                self.state = 580
                self.match(CharmmMRParser.Tol)
                self.state = 581
                self.number()


            self.state = 586
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==48:
                self.state = 584
                self.match(CharmmMRParser.MxIter)
                self.state = 585
                self.match(CharmmMRParser.Integer)


            self.state = 590
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==51:
                self.state = 588
                self.match(CharmmMRParser.ShkScale)
                self.state = 589
                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 Fast_optContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Fast(self):
            return self.getToken(CharmmMRParser.Fast, 0)

        def Water(self):
            return self.getToken(CharmmMRParser.Water, 0)

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

        def NoFast(self):
            return self.getToken(CharmmMRParser.NoFast, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_fast_opt

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

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




    def fast_opt(self):

        localctx = CharmmMRParser.Fast_optContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_fast_opt)
        self._la = 0 # Token type
        try:
            self.state = 598
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [52]:
                self.enterOuterAlt(localctx, 1)
                self.state = 592
                self.match(CharmmMRParser.Fast)
                self.state = 595
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==53:
                    self.state = 593
                    self.match(CharmmMRParser.Water)
                    self.state = 594
                    self.match(CharmmMRParser.Simple_name)


                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 597
                self.match(CharmmMRParser.NoFast)
                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 Restrained_distance_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def KVal(self):
            return self.getToken(CharmmMRParser.KVal, 0)

        def RVal(self):
            return self.getToken(CharmmMRParser.RVal, 0)

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

        def EVal(self):
            return self.getToken(CharmmMRParser.EVal, 0)

        def IVal(self):
            return self.getToken(CharmmMRParser.IVal, 0)

        def Positive(self):
            return self.getToken(CharmmMRParser.Positive, 0)

        def Negative(self):
            return self.getToken(CharmmMRParser.Negative, 0)

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


        def getRuleIndex(self):
            return CharmmMRParser.RULE_restrained_distance_statement

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

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




    def restrained_distance_statement(self):

        localctx = CharmmMRParser.Restrained_distance_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_restrained_distance_statement)
        self._la = 0 # Token type
        try:
            self.state = 610
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 600
                self.match(CharmmMRParser.Reset)
                pass
            elif token in [85, 88, 89]:
                self.enterOuterAlt(localctx, 2)
                self.state = 601
                _la = self._input.LA(1)
                if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & 25) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 602
                self.number()
                pass
            elif token in [90, 91]:
                self.enterOuterAlt(localctx, 3)
                self.state = 603
                _la = self._input.LA(1)
                if not(_la==90 or _la==91):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 604
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [92]:
                self.enterOuterAlt(localctx, 4)
                self.state = 605
                self.match(CharmmMRParser.Positive)
                pass
            elif token in [93]:
                self.enterOuterAlt(localctx, 5)
                self.state = 606
                self.match(CharmmMRParser.Negative)
                pass
            elif token in [116]:
                self.enterOuterAlt(localctx, 6)
                self.state = 607
                self.selection()
                self.state = 608
                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 External_force_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

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


        def XDir(self):
            return self.getToken(CharmmMRParser.XDir, 0)

        def YDir(self):
            return self.getToken(CharmmMRParser.YDir, 0)

        def ZDir(self):
            return self.getToken(CharmmMRParser.ZDir, 0)

        def Period(self):
            return self.getToken(CharmmMRParser.Period, 0)

        def EField(self):
            return self.getToken(CharmmMRParser.EField, 0)

        def SForce(self):
            return self.getToken(CharmmMRParser.SForce, 0)

        def Off(self):
            return self.getToken(CharmmMRParser.Off, 0)

        def List(self):
            return self.getToken(CharmmMRParser.List, 0)

        def Switch(self):
            return self.getToken(CharmmMRParser.Switch, 0)

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

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

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


        def getRuleIndex(self):
            return CharmmMRParser.RULE_external_force_statement

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

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




    def external_force_statement(self):

        localctx = CharmmMRParser.External_force_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_external_force_statement)
        self._la = 0 # Token type
        try:
            self.state = 622
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 612
                self.match(CharmmMRParser.Force)
                self.state = 613
                self.number()
                pass
            elif token in [24, 95, 96, 97, 98, 101]:
                self.enterOuterAlt(localctx, 2)
                self.state = 614
                _la = self._input.LA(1)
                if not(_la==24 or ((((_la - 95)) & ~0x3f) == 0 and ((1 << (_la - 95)) & 79) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 615
                self.number()
                pass
            elif token in [44]:
                self.enterOuterAlt(localctx, 3)
                self.state = 616
                self.match(CharmmMRParser.Off)
                pass
            elif token in [99]:
                self.enterOuterAlt(localctx, 4)
                self.state = 617
                self.match(CharmmMRParser.List)
                pass
            elif token in [100]:
                self.enterOuterAlt(localctx, 5)
                self.state = 618
                self.match(CharmmMRParser.Switch)
                self.state = 619
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [11]:
                self.enterOuterAlt(localctx, 6)
                self.state = 620
                self.match(CharmmMRParser.Weight)
                pass
            elif token in [116]:
                self.enterOuterAlt(localctx, 7)
                self.state = 621
                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 Rmsd_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Relative(self):
            return self.getToken(CharmmMRParser.Relative, 0)

        def MaxN(self):
            return self.getToken(CharmmMRParser.MaxN, 0)

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

        def NPrt(self):
            return self.getToken(CharmmMRParser.NPrt, 0)

        def rmsd_orient_spec(self):
            return self.getTypedRuleContext(CharmmMRParser.Rmsd_orient_specContext,0)


        def rmsd_force_const_spec(self):
            return self.getTypedRuleContext(CharmmMRParser.Rmsd_force_const_specContext,0)


        def rmsd_coordinate_spec(self):
            return self.getTypedRuleContext(CharmmMRParser.Rmsd_coordinate_specContext,0)


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


        def getRuleIndex(self):
            return CharmmMRParser.RULE_rmsd_statement

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

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




    def rmsd_statement(self):

        localctx = CharmmMRParser.Rmsd_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_rmsd_statement)
        try:
            self.state = 632
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [7]:
                self.enterOuterAlt(localctx, 1)
                self.state = 624
                self.match(CharmmMRParser.Relative)
                pass
            elif token in [103]:
                self.enterOuterAlt(localctx, 2)
                self.state = 625
                self.match(CharmmMRParser.MaxN)
                self.state = 626
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 3)
                self.state = 627
                self.match(CharmmMRParser.NPrt)
                pass
            elif token in [16, 17]:
                self.enterOuterAlt(localctx, 4)
                self.state = 628
                self.rmsd_orient_spec()
                pass
            elif token in [9, 10, 106, 107]:
                self.enterOuterAlt(localctx, 5)
                self.state = 629
                self.rmsd_force_const_spec()
                pass
            elif token in [18, 19]:
                self.enterOuterAlt(localctx, 6)
                self.state = 630
                self.rmsd_coordinate_spec()
                pass
            elif token in [116]:
                self.enterOuterAlt(localctx, 7)
                self.state = 631
                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 Rmsd_orient_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NoRotation(self):
            return self.getToken(CharmmMRParser.NoRotation, 0)

        def NoTranslation(self):
            return self.getToken(CharmmMRParser.NoTranslation, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_rmsd_orient_spec

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

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




    def rmsd_orient_spec(self):

        localctx = CharmmMRParser.Rmsd_orient_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_rmsd_orient_spec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 634
            _la = self._input.LA(1)
            if not(_la==16 or _la==17):
                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 Rmsd_force_const_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

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


        def Mass(self):
            return self.getToken(CharmmMRParser.Mass, 0)

        def Offset(self):
            return self.getToken(CharmmMRParser.Offset, 0)

        def BOffset(self):
            return self.getToken(CharmmMRParser.BOffset, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_rmsd_force_const_spec

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

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




    def rmsd_force_const_spec(self):

        localctx = CharmmMRParser.Rmsd_force_const_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_rmsd_force_const_spec)
        try:
            self.state = 643
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 636
                self.match(CharmmMRParser.Force)
                self.state = 637
                self.number()
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 638
                self.match(CharmmMRParser.Mass)
                pass
            elif token in [106]:
                self.enterOuterAlt(localctx, 3)
                self.state = 639
                self.match(CharmmMRParser.Offset)
                self.state = 640
                self.number()
                pass
            elif token in [107]:
                self.enterOuterAlt(localctx, 4)
                self.state = 641
                self.match(CharmmMRParser.BOffset)
                self.state = 642
                self.number()
                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 Rmsd_coordinate_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Main(self):
            return self.getToken(CharmmMRParser.Main, 0)

        def Comp(self):
            return self.getToken(CharmmMRParser.Comp, 0)

        def getRuleIndex(self):
            return CharmmMRParser.RULE_rmsd_coordinate_spec

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

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




    def rmsd_coordinate_spec(self):

        localctx = CharmmMRParser.Rmsd_coordinate_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_rmsd_coordinate_spec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 645
            _la = self._input.LA(1)
            if not(_la==18 or _la==19):
                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 Gyration_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

        def Reference(self):
            return self.getToken(CharmmMRParser.Reference, 0)

        def RMSD(self):
            return self.getToken(CharmmMRParser.RMSD, 0)

        def Comp(self):
            return self.getToken(CharmmMRParser.Comp, 0)

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

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

        def Output(self):
            return self.getToken(CharmmMRParser.Output, 0)

        def NSave(self):
            return self.getToken(CharmmMRParser.NSave, 0)

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


        def getRuleIndex(self):
            return CharmmMRParser.RULE_gyration_statement

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

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




    def gyration_statement(self):

        localctx = CharmmMRParser.Gyration_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_gyration_statement)
        self._la = 0 # Token type
        try:
            self.state = 656
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 647
                self.match(CharmmMRParser.Reset)
                pass
            elif token in [9, 109]:
                self.enterOuterAlt(localctx, 2)
                self.state = 648
                _la = self._input.LA(1)
                if not(_la==9 or _la==109):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 649
                self.number()
                pass
            elif token in [102]:
                self.enterOuterAlt(localctx, 3)
                self.state = 650
                self.match(CharmmMRParser.RMSD)
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 4)
                self.state = 651
                self.match(CharmmMRParser.Comp)
                pass
            elif token in [110]:
                self.enterOuterAlt(localctx, 5)
                self.state = 652
                self.match(CharmmMRParser.Orient)
                pass
            elif token in [111, 112]:
                self.enterOuterAlt(localctx, 6)
                self.state = 653
                _la = self._input.LA(1)
                if not(_la==111 or _la==112):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 654
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [116]:
                self.enterOuterAlt(localctx, 7)
                self.state = 655
                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 Distance_matrix_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def Force(self):
            return self.getToken(CharmmMRParser.Force, 0)

        def Reference(self):
            return self.getToken(CharmmMRParser.Reference, 0)

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

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

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

        def Output(self):
            return self.getToken(CharmmMRParser.Output, 0)

        def NSave(self):
            return self.getToken(CharmmMRParser.NSave, 0)

        def NContact(self):
            return self.getToken(CharmmMRParser.NContact, 0)

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


        def getRuleIndex(self):
            return CharmmMRParser.RULE_distance_matrix_statement

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

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




    def distance_matrix_statement(self):

        localctx = CharmmMRParser.Distance_matrix_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_distance_matrix_statement)
        self._la = 0 # Token type
        try:
            self.state = 663
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9, 11, 109, 114]:
                self.enterOuterAlt(localctx, 1)
                self.state = 658
                _la = self._input.LA(1)
                if not(_la==9 or _la==11 or _la==109 or _la==114):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 659
                self.number()
                pass
            elif token in [111, 112, 115]:
                self.enterOuterAlt(localctx, 2)
                self.state = 660
                _la = self._input.LA(1)
                if not(((((_la - 111)) & ~0x3f) == 0 and ((1 << (_la - 111)) & 19) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 661
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [116]:
                self.enterOuterAlt(localctx, 3)
                self.state = 662
                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 SelectionContext(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(CharmmMRParser.Selection, 0)

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


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

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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_selection)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.match(CharmmMRParser.Selection)
            self.state = 666
            self.selection_expression()
            self.state = 668
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==105:
                self.state = 667
                self.match(CharmmMRParser.Show)


            self.state = 670
            self.match(CharmmMRParser.End)
        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(CharmmMRParser.TermContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.TermContext,i)


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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Selection_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_selection_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 672
            self.term()
            self.state = 677
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==117:
                self.state = 673
                self.match(CharmmMRParser.Or_op)
                self.state = 674
                self.term()
                self.state = 679
                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(CharmmMRParser.FactorContext)
            else:
                return self.getTypedRuleContext(CharmmMRParser.FactorContext,i)


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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.TermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 680
            self.factor(0)
            self.state = 685
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==118:
                self.state = 681
                self.match(CharmmMRParser.And_op)
                self.state = 682
                self.factor(0)
                self.state = 687
                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(CharmmMRParser.L_paren, 0)

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


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

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

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

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

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

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

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

        def Property(self):
            return self.getToken(CharmmMRParser.Property, 0)

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

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

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


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

        def Bonded(self):
            return self.getToken(CharmmMRParser.Bonded, 0)

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


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

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

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

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

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

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

        def Initial(self):
            return self.getToken(CharmmMRParser.Initial, 0)

        def Lone(self):
            return self.getToken(CharmmMRParser.Lone, 0)

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

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

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

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

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

        def Period(self):
            return self.getToken(CharmmMRParser.Period, 0)

        def User(self):
            return self.getToken(CharmmMRParser.User, 0)

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

        def Recall(self):
            return self.getToken(CharmmMRParser.Recall, 0)

        def ByNumber(self):
            return self.getToken(CharmmMRParser.ByNumber, 0)

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

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

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

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

        def ISeg(self):
            return self.getToken(CharmmMRParser.ISeg, 0)

        def IRes(self):
            return self.getToken(CharmmMRParser.IRes, 0)

        def IGroup(self):
            return self.getToken(CharmmMRParser.IGroup, 0)

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

        def Subset(self):
            return self.getToken(CharmmMRParser.Subset, 0)

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.FactorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 90
        self.enterRecursionRule(localctx, 90, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 791
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [152]:
                self.state = 689
                self.match(CharmmMRParser.L_paren)
                self.state = 690
                self.selection_expression()
                self.state = 691
                self.match(CharmmMRParser.R_paren)
                pass
            elif token in [142]:
                self.state = 693
                self.match(CharmmMRParser.All)
                pass
            elif token in [133]:
                self.state = 694
                self.match(CharmmMRParser.Atom)
                self.state = 695
                _la = self._input.LA(1)
                if not(_la==149 or _la==150):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 696
                _la = self._input.LA(1)
                if not(_la==144 or _la==151):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 697
                _la = self._input.LA(1)
                if not(_la==149 or _la==150):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [134]:
                self.state = 698
                self.match(CharmmMRParser.Property)
                self.state = 700
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==177:
                    self.state = 699
                    self.match(CharmmMRParser.Abs)


                self.state = 702
                self.match(CharmmMRParser.Attr_properties)
                self.state = 703
                self.match(CharmmMRParser.Comparison_ops)
                self.state = 704
                self.number_f()
                pass
            elif token in [122]:
                self.state = 705
                self.match(CharmmMRParser.Bonded)
                self.state = 706
                self.factor(18)
                pass
            elif token in [124]:
                self.state = 707
                self.match(CharmmMRParser.ByGroup)
                self.state = 708
                self.factor(17)
                pass
            elif token in [123]:
                self.state = 709
                self.match(CharmmMRParser.ByRes)
                self.state = 710
                self.factor(16)
                pass
            elif token in [131]:
                self.state = 711
                self.match(CharmmMRParser.Type)
                self.state = 719
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [150]:
                    self.state = 712
                    self.match(CharmmMRParser.Simple_names)
                    pass
                elif token in [149]:
                    self.state = 713
                    self.match(CharmmMRParser.Simple_name)
                    self.state = 716
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
                    if la_ == 1:
                        self.state = 714
                        self.match(CharmmMRParser.Colon)
                        self.state = 715
                        self.match(CharmmMRParser.Simple_name)


                    pass
                elif token in [162]:
                    self.state = 718
                    self.match(CharmmMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [132]:
                self.state = 721
                self.match(CharmmMRParser.Chemical)
                self.state = 729
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [150]:
                    self.state = 722
                    self.match(CharmmMRParser.Simple_names)
                    pass
                elif token in [149]:
                    self.state = 723
                    self.match(CharmmMRParser.Simple_name)
                    self.state = 726
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                    if la_ == 1:
                        self.state = 724
                        self.match(CharmmMRParser.Colon)
                        self.state = 725
                        self.match(CharmmMRParser.Simple_name)


                    pass
                elif token in [162]:
                    self.state = 728
                    self.match(CharmmMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [136]:
                self.state = 731
                self.match(CharmmMRParser.Initial)
                pass
            elif token in [137]:
                self.state = 732
                self.match(CharmmMRParser.Lone)
                pass
            elif token in [138]:
                self.state = 733
                self.match(CharmmMRParser.Hydrogen)
                pass
            elif token in [143]:
                self.state = 734
                self.match(CharmmMRParser.NONE)
                pass
            elif token in [119]:
                self.state = 735
                self.match(CharmmMRParser.Not_op)
                self.state = 736
                self.factor(9)
                pass
            elif token in [135]:
                self.state = 737
                self.match(CharmmMRParser.Point)
                self.state = 738
                self.number_f()
                self.state = 739
                self.number_f()
                self.state = 740
                self.number_f()
                self.state = 743
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
                if la_ == 1:
                    self.state = 741
                    self.match(CharmmMRParser.Cut)
                    self.state = 742
                    self.number_f()


                self.state = 746
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
                if la_ == 1:
                    self.state = 745
                    self.match(CharmmMRParser.Period)


                pass
            elif token in [139]:
                self.state = 748
                self.match(CharmmMRParser.User)
                pass
            elif token in [140]:
                self.state = 749
                self.match(CharmmMRParser.Previous)
                pass
            elif token in [141]:
                self.state = 750
                self.match(CharmmMRParser.Recall)
                self.state = 751
                self.match(CharmmMRParser.Integer)
                pass
            elif token in [22, 127]:
                self.state = 752
                _la = self._input.LA(1)
                if not(_la==22 or _la==127):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 760
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [151]:
                    self.state = 753
                    self.match(CharmmMRParser.Integers)
                    pass
                elif token in [144]:
                    self.state = 754
                    self.match(CharmmMRParser.Integer)
                    self.state = 757
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
                    if la_ == 1:
                        self.state = 755
                        self.match(CharmmMRParser.Colon)
                        self.state = 756
                        self.match(CharmmMRParser.Integer)


                    pass
                elif token in [162]:
                    self.state = 759
                    self.match(CharmmMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [129]:
                self.state = 762
                self.match(CharmmMRParser.Resname)
                self.state = 770
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [150]:
                    self.state = 763
                    self.match(CharmmMRParser.Simple_names)
                    pass
                elif token in [149]:
                    self.state = 764
                    self.match(CharmmMRParser.Simple_name)
                    self.state = 767
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
                    if la_ == 1:
                        self.state = 765
                        self.match(CharmmMRParser.Colon)
                        self.state = 766
                        self.match(CharmmMRParser.Simple_name)


                    pass
                elif token in [162]:
                    self.state = 769
                    self.match(CharmmMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [125]:
                self.state = 772
                self.match(CharmmMRParser.SegIdentifier)
                self.state = 785
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [150]:
                    self.state = 773
                    self.match(CharmmMRParser.Simple_names)
                    pass
                elif token in [149]:
                    self.state = 774
                    self.match(CharmmMRParser.Simple_name)
                    self.state = 777
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                    if la_ == 1:
                        self.state = 775
                        self.match(CharmmMRParser.Colon)
                        self.state = 776
                        self.match(CharmmMRParser.Simple_name)


                    pass
                elif token in [146]:
                    self.state = 779
                    self.match(CharmmMRParser.Double_quote_string)
                    self.state = 782
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
                    if la_ == 1:
                        self.state = 780
                        self.match(CharmmMRParser.Colon)
                        self.state = 781
                        self.match(CharmmMRParser.Double_quote_string)


                    pass
                elif token in [162]:
                    self.state = 784
                    self.match(CharmmMRParser.Symbol_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [126, 128, 130]:
                self.state = 787
                _la = self._input.LA(1)
                if not(((((_la - 126)) & ~0x3f) == 0 and ((1 << (_la - 126)) & 21) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 788
                self.match(CharmmMRParser.Integer)
                self.state = 789
                self.match(CharmmMRParser.Colon)
                self.state = 790
                self.match(CharmmMRParser.Integer)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 809
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,93,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 = 807
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                    if la_ == 1:
                        localctx = CharmmMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 793
                        if not self.precpred(self._ctx, 22):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 22)")
                        self.state = 794
                        self.match(CharmmMRParser.Around)
                        self.state = 795
                        self.number_f()
                        pass

                    elif la_ == 2:
                        localctx = CharmmMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 796
                        if not self.precpred(self._ctx, 21):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                        self.state = 797
                        self.match(CharmmMRParser.Subset)
                        self.state = 805
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [151]:
                            self.state = 798
                            self.match(CharmmMRParser.Integers)
                            pass
                        elif token in [144]:
                            self.state = 799
                            self.match(CharmmMRParser.Integer)
                            self.state = 802
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
                            if la_ == 1:
                                self.state = 800
                                self.match(CharmmMRParser.Colon)
                                self.state = 801
                                self.match(CharmmMRParser.Integer)


                            pass
                        elif token in [162]:
                            self.state = 804
                            self.match(CharmmMRParser.Symbol_name)
                            pass
                        else:
                            raise NoViableAltException(self)

                        pass

             
                self.state = 811
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,93,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(CharmmMRParser.Real, 0)

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

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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 812
            _la = self._input.LA(1)
            if not(((((_la - 144)) & ~0x3f) == 0 and ((1 << (_la - 144)) & 262147) != 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(CharmmMRParser.Real, 0)

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

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

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

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

        def getRuleIndex(self):
            return CharmmMRParser.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 = CharmmMRParser.Number_sContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_number_s)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 816
            _la = self._input.LA(1)
            if not(((((_la - 144)) & ~0x3f) == 0 and ((1 << (_la - 144)) & 262147) != 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 Set_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Set(self):
            return self.getToken(CharmmMRParser.Set, 0)

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

        def RETURN_VE(self):
            return self.getToken(CharmmMRParser.RETURN_VE, 0)

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

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

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

        def getRuleIndex(self):
            return CharmmMRParser.RULE_set_statement

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

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




    def set_statement(self):

        localctx = CharmmMRParser.Set_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_set_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 818
            self.match(CharmmMRParser.Set)
            self.state = 819
            self.match(CharmmMRParser.Simple_name_VE)
            self.state = 821
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==168:
                self.state = 820
                self.match(CharmmMRParser.Equ_op_VE)


            self.state = 823
            _la = self._input.LA(1)
            if not(((((_la - 169)) & ~0x3f) == 0 and ((1 << (_la - 169)) & 7) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 824
            self.match(CharmmMRParser.RETURN_VE)
        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[45] = 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, 22)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 21)
         




