# Generated from XplorMRParser.g4 by ANTLR 4.9
# 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():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00fa")
        buf.write("\u07d7\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\3\2\3\2")
        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3")
        buf.write("\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2")
        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\7\2\u00f0\n\2\f\2\16\2\u00f3")
        buf.write("\13\2\3\2\3\2\3\3\3\3\7\3\u00f9\n\3\f\3\16\3\u00fc\13")
        buf.write("\3\3\3\3\3\3\4\5\4\u0101\n\4\3\4\3\4\7\4\u0105\n\4\f\4")
        buf.write("\16\4\u0108\13\4\3\4\3\4\3\5\3\5\7\5\u010e\n\5\f\5\16")
        buf.write("\5\u0111\13\5\3\5\3\5\3\5\7\5\u0116\n\5\f\5\16\5\u0119")
        buf.write("\13\5\3\5\3\5\3\5\7\5\u011e\n\5\f\5\16\5\u0121\13\5\3")
        buf.write("\5\3\5\3\5\7\5\u0126\n\5\f\5\16\5\u0129\13\5\3\5\3\5\3")
        buf.write("\5\7\5\u012e\n\5\f\5\16\5\u0131\13\5\3\5\5\5\u0134\n\5")
        buf.write("\3\6\5\6\u0137\n\6\3\6\3\6\7\6\u013b\n\6\f\6\16\6\u013e")
        buf.write("\13\6\3\6\3\6\3\7\3\7\7\7\u0144\n\7\f\7\16\7\u0147\13")
        buf.write("\7\3\7\3\7\3\b\3\b\7\b\u014d\n\b\f\b\16\b\u0150\13\b\3")
        buf.write("\b\3\b\3\t\3\t\7\t\u0156\n\t\f\t\16\t\u0159\13\t\3\t\3")
        buf.write("\t\3\n\3\n\7\n\u015f\n\n\f\n\16\n\u0162\13\n\3\n\3\n\3")
        buf.write("\13\3\13\7\13\u0168\n\13\f\13\16\13\u016b\13\13\3\13\3")
        buf.write("\13\3\f\3\f\7\f\u0171\n\f\f\f\16\f\u0174\13\f\3\f\3\f")
        buf.write("\3\r\3\r\7\r\u017a\n\r\f\r\16\r\u017d\13\r\3\r\3\r\3\16")
        buf.write("\3\16\7\16\u0183\n\16\f\16\16\16\u0186\13\16\3\16\3\16")
        buf.write("\3\17\3\17\7\17\u018c\n\17\f\17\16\17\u018f\13\17\3\17")
        buf.write("\3\17\3\20\3\20\7\20\u0195\n\20\f\20\16\20\u0198\13\20")
        buf.write("\3\20\3\20\3\21\3\21\7\21\u019e\n\21\f\21\16\21\u01a1")
        buf.write("\13\21\3\21\3\21\3\22\3\22\7\22\u01a7\n\22\f\22\16\22")
        buf.write("\u01aa\13\22\3\22\3\22\3\23\3\23\7\23\u01b0\n\23\f\23")
        buf.write("\16\23\u01b3\13\23\3\23\3\23\3\24\3\24\7\24\u01b9\n\24")
        buf.write("\f\24\16\24\u01bc\13\24\3\24\3\24\3\25\3\25\7\25\u01c2")
        buf.write("\n\25\f\25\16\25\u01c5\13\25\3\25\3\25\3\26\3\26\7\26")
        buf.write("\u01cb\n\26\f\26\16\26\u01ce\13\26\3\26\3\26\3\27\3\27")
        buf.write("\7\27\u01d4\n\27\f\27\16\27\u01d7\13\27\3\27\3\27\3\30")
        buf.write("\3\30\7\30\u01dd\n\30\f\30\16\30\u01e0\13\30\3\30\3\30")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\5\31\u01f0\n\31\3\31\3\31\3\31\3\31\3\31\3\31\3")
        buf.write("\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\5\31\u0203\n\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3")
        buf.write("\31\3\31\3\31\3\31\5\31\u0210\n\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0228\n\31\3")
        buf.write("\31\5\31\u022b\n\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
        buf.write("\7\32\u0234\n\32\f\32\16\32\u0237\13\32\3\32\3\32\3\32")
        buf.write("\3\32\7\32\u023d\n\32\f\32\16\32\u0240\13\32\3\33\3\33")
        buf.write("\5\33\u0244\n\33\3\33\3\33\3\33\5\33\u0249\n\33\3\33\3")
        buf.write("\33\3\33\3\33\3\33\5\33\u0250\n\33\3\34\3\34\5\34\u0254")
        buf.write("\n\34\3\34\3\34\3\34\5\34\u0259\n\34\3\34\3\34\3\34\5")
        buf.write("\34\u025e\n\34\3\34\3\34\3\34\5\34\u0263\n\34\3\34\3\34")
        buf.write("\3\34\5\34\u0268\n\34\3\34\3\34\3\34\5\34\u026d\n\34\3")
        buf.write("\34\3\34\3\34\5\34\u0272\n\34\3\34\5\34\u0275\n\34\3\35")
        buf.write("\3\35\3\35\5\35\u027a\n\35\3\35\3\35\3\35\3\35\5\35\u0280")
        buf.write("\n\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36")
        buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37")
        buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u029e\n\37\3")
        buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u02aa\n \3!\3!\3!\3!\3")
        buf.write("!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3")
        buf.write("!\3!\3!\3!\5!\u02c6\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"")
        buf.write("\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u02d7\n\"\3#\3#\3#\5")
        buf.write("#\u02dc\n#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u02e9\n")
        buf.write("#\3#\3#\3#\3#\3#\5#\u02f0\n#\3$\3$\3$\3$\3$\3$\3$\3$\3")
        buf.write("$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u0309\n")
        buf.write("%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3")
        buf.write("\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'")
        buf.write("\u0326\n\'\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\7)\u0332\n)\f")
        buf.write(")\16)\u0335\13)\3)\3)\5)\u0339\n)\3*\3*\5*\u033d\n*\3")
        buf.write("*\3*\3*\5*\u0342\n*\3*\5*\u0345\n*\3+\3+\3+\3+\3+\3+\3")
        buf.write("+\3+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u0357\n+\3+\3+\3+\3+\3")
        buf.write("+\3+\5+\u035f\n+\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\3")
        buf.write("-\3-\3-\5-\u0370\n-\3-\3-\3-\3-\3-\3-\5-\u0378\n-\3-\3")
        buf.write("-\3-\3-\5-\u037e\n-\3-\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0389")
        buf.write("\n-\3-\5-\u038c\n-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\5.\u0398")
        buf.write("\n.\3.\3.\3.\3.\3.\5.\u039f\n.\3/\3/\3/\3/\3/\3/\3/\3")
        buf.write("/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3")
        buf.write("/\5/\u03bb\n/\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60")
        buf.write("\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62")
        buf.write("\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
        buf.write("\3\62\3\62\5\62\u03dd\n\62\3\62\3\62\3\62\3\62\3\62\3")
        buf.write("\62\3\62\3\62\5\62\u03e7\n\62\3\62\3\62\3\62\5\62\u03ec")
        buf.write("\n\62\3\63\3\63\3\63\5\63\u03f1\n\63\3\63\3\63\5\63\u03f5")
        buf.write("\n\63\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65")
        buf.write("\5\65\u0401\n\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\3")
        buf.write("\67\38\38\38\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\5:\u0419")
        buf.write("\n:\3;\3;\3;\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3")
        buf.write("<\3<\5<\u042d\n<\3<\3<\3<\3<\5<\u0433\n<\3<\3<\3<\3<\5")
        buf.write("<\u0439\n<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\5<\u0445\n<\3")
        buf.write("<\3<\3<\3<\5<\u044b\n<\3<\3<\3<\3<\5<\u0451\n<\3<\3<\3")
        buf.write("<\3<\3<\3<\5<\u0459\n<\3<\3<\3<\3<\3<\3<\3<\3<\5<\u0463")
        buf.write("\n<\3<\3<\3<\3<\5<\u0469\n<\3<\3<\3<\3<\5<\u046f\n<\3")
        buf.write("<\3<\3<\3<\3<\3<\3<\3<\3<\5<\u047a\n<\3<\5<\u047d\n<\3")
        buf.write("<\5<\u0480\n<\3<\3<\5<\u0484\n<\3=\3=\3=\3=\3=\3=\3=\3")
        buf.write("=\3=\3=\5=\u0490\n=\3=\3=\3=\3=\3=\5=\u0497\n=\3=\3=\3")
        buf.write("=\3=\3=\5=\u049e\n=\3>\3>\3>\3>\3>\5>\u04a5\n>\3?\3?\3")
        buf.write("?\3?\3?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3")
        buf.write("@\3@\3@\3@\3@\3@\3@\5@\u04c2\n@\3A\3A\3A\3A\3A\3A\3A\3")
        buf.write("A\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
        buf.write("B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
        buf.write("B\3B\3B\3B\3B\5B\u04f4\nB\3B\3B\3B\3B\3B\3B\3B\3B\3B\3")
        buf.write("B\3B\3B\3B\3B\3B\3B\3B\5B\u0507\nB\3C\3C\3C\3C\3C\3C\3")
        buf.write("D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3")
        buf.write("D\3D\3D\3D\3D\3D\3D\3D\3D\5D\u052a\nD\3E\3E\3E\3E\3E\3")
        buf.write("E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3")
        buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u0552\n")
        buf.write("F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3")
        buf.write("G\3G\3G\3G\3G\5G\u056a\nG\3H\3H\3H\3H\3H\3H\3H\3H\3H\3")
        buf.write("H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3")
        buf.write("I\3I\3I\3I\3I\3I\3I\3I\5I\u058f\nI\3I\3I\3I\3I\3I\3I\5")
        buf.write("I\u0597\nI\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u05a6")
        buf.write("\nJ\3K\3K\3K\5K\u05ab\nK\3K\3K\3K\5K\u05b0\nK\3K\3K\3")
        buf.write("K\3K\5K\u05b6\nK\3K\3K\3K\5K\u05bb\nK\3K\3K\3K\3K\5K\u05c1")
        buf.write("\nK\3K\3K\3K\3K\5K\u05c7\nK\3K\3K\3K\3K\5K\u05cd\nK\3")
        buf.write("K\3K\3K\3K\3K\3K\3K\3K\3K\3K\5K\u05d9\nK\3K\3K\5K\u05dd")
        buf.write("\nK\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3")
        buf.write("M\3M\3M\3M\3M\3M\3M\3M\3M\5M\u05f8\nM\3M\3M\3M\3M\3M\3")
        buf.write("M\3M\3M\3M\3M\3M\3M\3M\3M\3M\5M\u0609\nM\3N\3N\3N\3N\3")
        buf.write("N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3")
        buf.write("O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u062e\nO\3P\3")
        buf.write("P\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3")
        buf.write("Q\3Q\5Q\u0645\nQ\3R\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\5S\u065f\nS\3T\3T\3")
        buf.write("T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u0673")
        buf.write("\nU\3V\3V\3V\3V\3V\3W\3W\3W\3W\3X\3X\3X\7X\u0681\nX\f")
        buf.write("X\16X\u0684\13X\3Y\3Y\3Y\7Y\u0689\nY\fY\16Y\u068c\13Y")
        buf.write("\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u069a\nZ\3Z\3")
        buf.write("Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u06aa\nZ\5Z\u06ac")
        buf.write("\nZ\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u06b7\nZ\5Z\u06b9\n")
        buf.write("Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u06c1\nZ\3Z\3Z\5Z\u06c5\nZ\3Z\3")
        buf.write("Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u06d0\nZ\3Z\3Z\5Z\u06d4\nZ\3")
        buf.write("Z\3Z\5Z\u06d8\nZ\3Z\5Z\u06db\nZ\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3")
        buf.write("Z\3Z\3Z\3Z\5Z\u06e8\nZ\5Z\u06ea\nZ\3Z\3Z\3Z\3Z\3Z\5Z\u06f1")
        buf.write("\nZ\5Z\u06f3\nZ\3Z\3Z\3Z\3Z\3Z\5Z\u06fa\nZ\3Z\3Z\3Z\5")
        buf.write("Z\u06ff\nZ\5Z\u0701\nZ\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5")
        buf.write("Z\u070d\nZ\3Z\3Z\3Z\3Z\3Z\3Z\7Z\u0715\nZ\fZ\16Z\u0718")
        buf.write("\13Z\3[\3[\3\\\3\\\3]\3]\3^\3^\3_\3_\3_\7_\u0725\n_\f")
        buf.write("_\16_\u0728\13_\3_\5_\u072b\n_\5_\u072d\n_\3_\3_\7_\u0731")
        buf.write("\n_\f_\16_\u0734\13_\3_\3_\3`\3`\3`\3`\3a\3a\3a\3a\3a")
        buf.write("\3a\5a\u0742\na\3b\3b\3b\5b\u0747\nb\3c\3c\3c\7c\u074c")
        buf.write("\nc\fc\16c\u074f\13c\3d\3d\3d\3d\3d\3d\5d\u0757\nd\3e")
        buf.write("\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3")
        buf.write("e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3")
        buf.write("e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3")
        buf.write("e\3e\3e\3e\3e\3e\7e\u0795\ne\fe\16e\u0798\13e\3e\3e\3")
        buf.write("e\3e\3e\3e\3e\3e\3e\3e\3e\3e\7e\u07a6\ne\fe\16e\u07a9")
        buf.write("\13e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3")
        buf.write("e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3")
        buf.write("e\3e\3e\5e\u07d0\ne\3f\3f\3f\3f\3f\3f\2\3\u00b2g\2\4\6")
        buf.write("\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66")
        buf.write("8:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084")
        buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096")
        buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8")
        buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba")
        buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\2\t\3")
        buf.write("\2,-\3\2\u00a4\u00a5\4\2\u00a0\u00a0\u00a6\u00a6\4\2\u00a0")
        buf.write("\u00a0\u00a2\u00a2\3\2\u0096\u0097\3\2\u00ce\u00d2\3\2")
        buf.write("\u00f2\u00f8\2\u0949\2\u00f1\3\2\2\2\4\u00f6\3\2\2\2\6")
        buf.write("\u0100\3\2\2\2\b\u0133\3\2\2\2\n\u0136\3\2\2\2\f\u0141")
        buf.write("\3\2\2\2\16\u014a\3\2\2\2\20\u0153\3\2\2\2\22\u015c\3")
        buf.write("\2\2\2\24\u0165\3\2\2\2\26\u016e\3\2\2\2\30\u0177\3\2")
        buf.write("\2\2\32\u0180\3\2\2\2\34\u0189\3\2\2\2\36\u0192\3\2\2")
        buf.write("\2 \u019b\3\2\2\2\"\u01a4\3\2\2\2$\u01ad\3\2\2\2&\u01b6")
        buf.write("\3\2\2\2(\u01bf\3\2\2\2*\u01c8\3\2\2\2,\u01d1\3\2\2\2")
        buf.write(".\u01da\3\2\2\2\60\u022a\3\2\2\2\62\u022c\3\2\2\2\64\u024f")
        buf.write("\3\2\2\2\66\u0274\3\2\2\28\u027f\3\2\2\2:\u0281\3\2\2")
        buf.write("\2<\u029d\3\2\2\2>\u029f\3\2\2\2@\u02c5\3\2\2\2B\u02c7")
        buf.write("\3\2\2\2D\u02ef\3\2\2\2F\u02f1\3\2\2\2H\u0308\3\2\2\2")
        buf.write("J\u030a\3\2\2\2L\u0325\3\2\2\2N\u0327\3\2\2\2P\u0338\3")
        buf.write("\2\2\2R\u0344\3\2\2\2T\u035e\3\2\2\2V\u0360\3\2\2\2X\u038b")
        buf.write("\3\2\2\2Z\u038d\3\2\2\2\\\u03ba\3\2\2\2^\u03bc\3\2\2\2")
        buf.write("`\u03c5\3\2\2\2b\u03eb\3\2\2\2d\u03ed\3\2\2\2f\u03f6\3")
        buf.write("\2\2\2h\u03fa\3\2\2\2j\u0404\3\2\2\2l\u0407\3\2\2\2n\u040a")
        buf.write("\3\2\2\2p\u040d\3\2\2\2r\u0410\3\2\2\2t\u041a\3\2\2\2")
        buf.write("v\u0483\3\2\2\2x\u0485\3\2\2\2z\u04a4\3\2\2\2|\u04a6\3")
        buf.write("\2\2\2~\u04c1\3\2\2\2\u0080\u04c3\3\2\2\2\u0082\u0506")
        buf.write("\3\2\2\2\u0084\u0508\3\2\2\2\u0086\u0529\3\2\2\2\u0088")
        buf.write("\u052b\3\2\2\2\u008a\u0551\3\2\2\2\u008c\u0569\3\2\2\2")
        buf.write("\u008e\u056b\3\2\2\2\u0090\u0596\3\2\2\2\u0092\u0598\3")
        buf.write("\2\2\2\u0094\u05dc\3\2\2\2\u0096\u05de\3\2\2\2\u0098\u0608")
        buf.write("\3\2\2\2\u009a\u060a\3\2\2\2\u009c\u062d\3\2\2\2\u009e")
        buf.write("\u062f\3\2\2\2\u00a0\u0644\3\2\2\2\u00a2\u0646\3\2\2\2")
        buf.write("\u00a4\u065e\3\2\2\2\u00a6\u0660\3\2\2\2\u00a8\u0672\3")
        buf.write("\2\2\2\u00aa\u0674\3\2\2\2\u00ac\u0679\3\2\2\2\u00ae\u067d")
        buf.write("\3\2\2\2\u00b0\u0685\3\2\2\2\u00b2\u070c\3\2\2\2\u00b4")
        buf.write("\u0719\3\2\2\2\u00b6\u071b\3\2\2\2\u00b8\u071d\3\2\2\2")
        buf.write("\u00ba\u071f\3\2\2\2\u00bc\u0721\3\2\2\2\u00be\u0737\3")
        buf.write("\2\2\2\u00c0\u0741\3\2\2\2\u00c2\u0743\3\2\2\2\u00c4\u0748")
        buf.write("\3\2\2\2\u00c6\u0756\3\2\2\2\u00c8\u07cf\3\2\2\2\u00ca")
        buf.write("\u07d1\3\2\2\2\u00cc\u00f0\5\4\3\2\u00cd\u00f0\5\6\4\2")
        buf.write("\u00ce\u00f0\5\b\5\2\u00cf\u00f0\5\n\6\2\u00d0\u00f0\5")
        buf.write("\f\7\2\u00d1\u00f0\5\16\b\2\u00d2\u00f0\5\20\t\2\u00d3")
        buf.write("\u00f0\5\22\n\2\u00d4\u00f0\5\24\13\2\u00d5\u00f0\5\26")
        buf.write("\f\2\u00d6\u00f0\5\30\r\2\u00d7\u00f0\5\32\16\2\u00d8")
        buf.write("\u00f0\5\34\17\2\u00d9\u00f0\5\36\20\2\u00da\u00f0\5 ")
        buf.write("\21\2\u00db\u00f0\5\"\22\2\u00dc\u00f0\5$\23\2\u00dd\u00f0")
        buf.write("\5&\24\2\u00de\u00f0\5(\25\2\u00df\u00f0\5*\26\2\u00e0")
        buf.write("\u00f0\5,\27\2\u00e1\u00f0\5.\30\2\u00e2\u00f0\5\u00bc")
        buf.write("_\2\u00e3\u00f0\5\u00be`\2\u00e4\u00f0\5\62\32\2\u00e5")
        buf.write("\u00f0\5:\36\2\u00e6\u00f0\5> \2\u00e7\u00f0\5P)\2\u00e8")
        buf.write("\u00f0\5\u00aaV\2\u00e9\u00f0\5Z.\2\u00ea\u00f0\5V,\2")
        buf.write("\u00eb\u00f0\5|?\2\u00ec\u00f0\5\u0088E\2\u00ed\u00f0")
        buf.write("\5\u0096L\2\u00ee\u00f0\5\u009aN\2\u00ef\u00cc\3\2\2\2")
        buf.write("\u00ef\u00cd\3\2\2\2\u00ef\u00ce\3\2\2\2\u00ef\u00cf\3")
        buf.write("\2\2\2\u00ef\u00d0\3\2\2\2\u00ef\u00d1\3\2\2\2\u00ef\u00d2")
        buf.write("\3\2\2\2\u00ef\u00d3\3\2\2\2\u00ef\u00d4\3\2\2\2\u00ef")
        buf.write("\u00d5\3\2\2\2\u00ef\u00d6\3\2\2\2\u00ef\u00d7\3\2\2\2")
        buf.write("\u00ef\u00d8\3\2\2\2\u00ef\u00d9\3\2\2\2\u00ef\u00da\3")
        buf.write("\2\2\2\u00ef\u00db\3\2\2\2\u00ef\u00dc\3\2\2\2\u00ef\u00dd")
        buf.write("\3\2\2\2\u00ef\u00de\3\2\2\2\u00ef\u00df\3\2\2\2\u00ef")
        buf.write("\u00e0\3\2\2\2\u00ef\u00e1\3\2\2\2\u00ef\u00e2\3\2\2\2")
        buf.write("\u00ef\u00e3\3\2\2\2\u00ef\u00e4\3\2\2\2\u00ef\u00e5\3")
        buf.write("\2\2\2\u00ef\u00e6\3\2\2\2\u00ef\u00e7\3\2\2\2\u00ef\u00e8")
        buf.write("\3\2\2\2\u00ef\u00e9\3\2\2\2\u00ef\u00ea\3\2\2\2\u00ef")
        buf.write("\u00eb\3\2\2\2\u00ef\u00ec\3\2\2\2\u00ef\u00ed\3\2\2\2")
        buf.write("\u00ef\u00ee\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3")
        buf.write("\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f4\3\2\2\2\u00f3\u00f1")
        buf.write("\3\2\2\2\u00f4\u00f5\7\2\2\3\u00f5\3\3\2\2\2\u00f6\u00fa")
        buf.write("\7\5\2\2\u00f7\u00f9\5\60\31\2\u00f8\u00f7\3\2\2\2\u00f9")
        buf.write("\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2")
        buf.write("\u00fb\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\7")
        buf.write("\4\2\2\u00fe\5\3\2\2\2\u00ff\u0101\7&\2\2\u0100\u00ff")
        buf.write("\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\3\2\2\2\u0102")
        buf.write("\u0106\7\'\2\2\u0103\u0105\58\35\2\u0104\u0103\3\2\2\2")
        buf.write("\u0105\u0108\3\2\2\2\u0106\u0104\3\2\2\2\u0106\u0107\3")
        buf.write("\2\2\2\u0107\u0109\3\2\2\2\u0108\u0106\3\2\2\2\u0109\u010a")
        buf.write("\7\4\2\2\u010a\7\3\2\2\2\u010b\u010f\7)\2\2\u010c\u010e")
        buf.write("\5<\37\2\u010d\u010c\3\2\2\2\u010e\u0111\3\2\2\2\u010f")
        buf.write("\u010d\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u0112\3\2\2\2")
        buf.write("\u0111\u010f\3\2\2\2\u0112\u0134\7\4\2\2\u0113\u0117\t")
        buf.write("\2\2\2\u0114\u0116\5@!\2\u0115\u0114\3\2\2\2\u0116\u0119")
        buf.write("\3\2\2\2\u0117\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118")
        buf.write("\u011a\3\2\2\2\u0119\u0117\3\2\2\2\u011a\u0134\7\4\2\2")
        buf.write("\u011b\u011f\7\61\2\2\u011c\u011e\5D#\2\u011d\u011c\3")
        buf.write("\2\2\2\u011e\u0121\3\2\2\2\u011f\u011d\3\2\2\2\u011f\u0120")
        buf.write("\3\2\2\2\u0120\u0122\3\2\2\2\u0121\u011f\3\2\2\2\u0122")
        buf.write("\u0134\7\4\2\2\u0123\u0127\7\64\2\2\u0124\u0126\5H%\2")
        buf.write("\u0125\u0124\3\2\2\2\u0126\u0129\3\2\2\2\u0127\u0125\3")
        buf.write("\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2\u0129\u0127")
        buf.write("\3\2\2\2\u012a\u0134\7\4\2\2\u012b\u012f\7\65\2\2\u012c")
        buf.write("\u012e\5L\'\2\u012d\u012c\3\2\2\2\u012e\u0131\3\2\2\2")
        buf.write("\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0132\3")
        buf.write("\2\2\2\u0131\u012f\3\2\2\2\u0132\u0134\7\4\2\2\u0133\u010b")
        buf.write("\3\2\2\2\u0133\u0113\3\2\2\2\u0133\u011b\3\2\2\2\u0133")
        buf.write("\u0123\3\2\2\2\u0133\u012b\3\2\2\2\u0134\t\3\2\2\2\u0135")
        buf.write("\u0137\7&\2\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2")
        buf.write("\u0137\u0138\3\2\2\2\u0138\u013c\7\66\2\2\u0139\u013b")
        buf.write("\5P)\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a")
        buf.write("\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e")
        buf.write("\u013c\3\2\2\2\u013f\u0140\7\4\2\2\u0140\13\3\2\2\2\u0141")
        buf.write("\u0145\7;\2\2\u0142\u0144\5T+\2\u0143\u0142\3\2\2\2\u0144")
        buf.write("\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146\3\2\2\2")
        buf.write("\u0146\u0148\3\2\2\2\u0147\u0145\3\2\2\2\u0148\u0149\7")
        buf.write("\4\2\2\u0149\r\3\2\2\2\u014a\u014e\7?\2\2\u014b\u014d")
        buf.write("\5X-\2\u014c\u014b\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c")
        buf.write("\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150")
        buf.write("\u014e\3\2\2\2\u0151\u0152\7\4\2\2\u0152\17\3\2\2\2\u0153")
        buf.write("\u0157\7A\2\2\u0154\u0156\5\\/\2\u0155\u0154\3\2\2\2\u0156")
        buf.write("\u0159\3\2\2\2\u0157\u0155\3\2\2\2\u0157\u0158\3\2\2\2")
        buf.write("\u0158\u015a\3\2\2\2\u0159\u0157\3\2\2\2\u015a\u015b\7")
        buf.write("\4\2\2\u015b\21\3\2\2\2\u015c\u0160\7E\2\2\u015d\u015f")
        buf.write("\5b\62\2\u015e\u015d\3\2\2\2\u015f\u0162\3\2\2\2\u0160")
        buf.write("\u015e\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0163\3\2\2\2")
        buf.write("\u0162\u0160\3\2\2\2\u0163\u0164\7\4\2\2\u0164\23\3\2")
        buf.write("\2\2\u0165\u0169\7M\2\2\u0166\u0168\5v<\2\u0167\u0166")
        buf.write("\3\2\2\2\u0168\u016b\3\2\2\2\u0169\u0167\3\2\2\2\u0169")
        buf.write("\u016a\3\2\2\2\u016a\u016c\3\2\2\2\u016b\u0169\3\2\2\2")
        buf.write("\u016c\u016d\7\4\2\2\u016d\25\3\2\2\2\u016e\u0172\7T\2")
        buf.write("\2\u016f\u0171\5z>\2\u0170\u016f\3\2\2\2\u0171\u0174\3")
        buf.write("\2\2\2\u0172\u0170\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0175")
        buf.write("\3\2\2\2\u0174\u0172\3\2\2\2\u0175\u0176\7\4\2\2\u0176")
        buf.write("\27\3\2\2\2\u0177\u017b\7U\2\2\u0178\u017a\5~@\2\u0179")
        buf.write("\u0178\3\2\2\2\u017a\u017d\3\2\2\2\u017b\u0179\3\2\2\2")
        buf.write("\u017b\u017c\3\2\2\2\u017c\u017e\3\2\2\2\u017d\u017b\3")
        buf.write("\2\2\2\u017e\u017f\7\4\2\2\u017f\31\3\2\2\2\u0180\u0184")
        buf.write("\7V\2\2\u0181\u0183\5\u0082B\2\u0182\u0181\3\2\2\2\u0183")
        buf.write("\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184\u0185\3\2\2\2")
        buf.write("\u0185\u0187\3\2\2\2\u0186\u0184\3\2\2\2\u0187\u0188\7")
        buf.write("\4\2\2\u0188\33\3\2\2\2\u0189\u018d\7Z\2\2\u018a\u018c")
        buf.write("\5\u0086D\2\u018b\u018a\3\2\2\2\u018c\u018f\3\2\2\2\u018d")
        buf.write("\u018b\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u0190\3\2\2\2")
        buf.write("\u018f\u018d\3\2\2\2\u0190\u0191\7\4\2\2\u0191\35\3\2")
        buf.write("\2\2\u0192\u0196\7\\\2\2\u0193\u0195\5\u008aF\2\u0194")
        buf.write("\u0193\3\2\2\2\u0195\u0198\3\2\2\2\u0196\u0194\3\2\2\2")
        buf.write("\u0196\u0197\3\2\2\2\u0197\u0199\3\2\2\2\u0198\u0196\3")
        buf.write("\2\2\2\u0199\u019a\7\4\2\2\u019a\37\3\2\2\2\u019b\u019f")
        buf.write("\7]\2\2\u019c\u019e\5\u008cG\2\u019d\u019c\3\2\2\2\u019e")
        buf.write("\u01a1\3\2\2\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2")
        buf.write("\u01a0\u01a2\3\2\2\2\u01a1\u019f\3\2\2\2\u01a2\u01a3\7")
        buf.write("\4\2\2\u01a3!\3\2\2\2\u01a4\u01a8\7^\2\2\u01a5\u01a7\5")
        buf.write("\u0090I\2\u01a6\u01a5\3\2\2\2\u01a7\u01aa\3\2\2\2\u01a8")
        buf.write("\u01a6\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01ab\3\2\2\2")
        buf.write("\u01aa\u01a8\3\2\2\2\u01ab\u01ac\7\4\2\2\u01ac#\3\2\2")
        buf.write("\2\u01ad\u01b1\7a\2\2\u01ae\u01b0\5\u0094K\2\u01af\u01ae")
        buf.write("\3\2\2\2\u01b0\u01b3\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1")
        buf.write("\u01b2\3\2\2\2\u01b2\u01b4\3\2\2\2\u01b3\u01b1\3\2\2\2")
        buf.write("\u01b4\u01b5\7\4\2\2\u01b5%\3\2\2\2\u01b6\u01ba\7f\2\2")
        buf.write("\u01b7\u01b9\5\u0098M\2\u01b8\u01b7\3\2\2\2\u01b9\u01bc")
        buf.write("\3\2\2\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb")
        buf.write("\u01bd\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bd\u01be\7\4\2\2")
        buf.write("\u01be\'\3\2\2\2\u01bf\u01c3\7q\2\2\u01c0\u01c2\5\u009c")
        buf.write("O\2\u01c1\u01c0\3\2\2\2\u01c2\u01c5\3\2\2\2\u01c3\u01c1")
        buf.write("\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c6\3\2\2\2\u01c5")
        buf.write("\u01c3\3\2\2\2\u01c6\u01c7\7\4\2\2\u01c7)\3\2\2\2\u01c8")
        buf.write("\u01cc\7r\2\2\u01c9\u01cb\5\u00a0Q\2\u01ca\u01c9\3\2\2")
        buf.write("\2\u01cb\u01ce\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cc\u01cd")
        buf.write("\3\2\2\2\u01cd\u01cf\3\2\2\2\u01ce\u01cc\3\2\2\2\u01cf")
        buf.write("\u01d0\7\4\2\2\u01d0+\3\2\2\2\u01d1\u01d5\7s\2\2\u01d2")
        buf.write("\u01d4\5\u00a4S\2\u01d3\u01d2\3\2\2\2\u01d4\u01d7\3\2")
        buf.write("\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d8")
        buf.write("\3\2\2\2\u01d7\u01d5\3\2\2\2\u01d8\u01d9\7\4\2\2\u01d9")
        buf.write("-\3\2\2\2\u01da\u01de\7u\2\2\u01db\u01dd\5\u00a8U\2\u01dc")
        buf.write("\u01db\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2")
        buf.write("\u01de\u01df\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01de\3")
        buf.write("\2\2\2\u01e1\u01e2\7\4\2\2\u01e2/\3\2\2\2\u01e3\u022b")
        buf.write("\5\62\32\2\u01e4\u01e5\7\7\2\2\u01e5\u01e6\7\u00a4\2\2")
        buf.write("\u01e6\u022b\5\u00b8]\2\u01e7\u01e8\7\b\2\2\u01e8\u01e9")
        buf.write("\7\u00ba\2\2\u01e9\u022b\7\u00b9\2\2\u01ea\u01eb\7\t\2")
        buf.write("\2\u01eb\u01ec\7\u00a4\2\2\u01ec\u022b\5\u00b8]\2\u01ed")
        buf.write("\u01ef\7\n\2\2\u01ee\u01f0\7\u00aa\2\2\u01ef\u01ee\3\2")
        buf.write("\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u022b")
        buf.write("\5\u00b8]\2\u01f2\u01f3\7\13\2\2\u01f3\u022b\7\u00a4\2")
        buf.write("\2\u01f4\u01f5\7\f\2\2\u01f5\u022b\7\u00a4\2\2\u01f6\u01f7")
        buf.write("\7\r\2\2\u01f7\u01f8\7\u00a4\2\2\u01f8\u01f9\7\u00a4\2")
        buf.write("\2\u01f9\u022b\5\u00b8]\2\u01fa\u01fb\7\16\2\2\u01fb\u01fc")
        buf.write("\7\u00a4\2\2\u01fc\u022b\7\u00a0\2\2\u01fd\u01fe\7\17")
        buf.write("\2\2\u01fe\u01ff\7\u00a4\2\2\u01ff\u022b\7\u00a0\2\2\u0200")
        buf.write("\u0202\7\20\2\2\u0201\u0203\7\u00aa\2\2\u0202\u0201\3")
        buf.write("\2\2\2\u0202\u0203\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u022b")
        buf.write("\7\u00a0\2\2\u0205\u0206\7\21\2\2\u0206\u0207\7\u00be")
        buf.write("\2\2\u0207\u022b\7\u00bd\2\2\u0208\u0209\7\22\2\2\u0209")
        buf.write("\u020a\5\64\33\2\u020a\u020b\7\4\2\2\u020b\u022b\3\2\2")
        buf.write("\2\u020c\u020d\7\23\2\2\u020d\u020f\7\24\2\2\u020e\u0210")
        buf.write("\7\u00aa\2\2\u020f\u020e\3\2\2\2\u020f\u0210\3\2\2\2\u0210")
        buf.write("\u0211\3\2\2\2\u0211\u022b\5\u00b8]\2\u0212\u022b\7\25")
        buf.write("\2\2\u0213\u0214\7\26\2\2\u0214\u0215\7\u00a4\2\2\u0215")
        buf.write("\u022b\5\u00b8]\2\u0216\u0217\7\27\2\2\u0217\u0218\7\u00a4")
        buf.write("\2\2\u0218\u022b\5\u00b8]\2\u0219\u021a\7\30\2\2\u021a")
        buf.write("\u021b\7\u00a4\2\2\u021b\u022b\5\u00b8]\2\u021c\u021d")
        buf.write("\7\31\2\2\u021d\u021e\7\u00a4\2\2\u021e\u022b\5\u00b8")
        buf.write("]\2\u021f\u0220\7\32\2\2\u0220\u0221\7\u00a4\2\2\u0221")
        buf.write("\u022b\5\u00b8]\2\u0222\u0223\7\33\2\2\u0223\u0224\7\u00a4")
        buf.write("\2\2\u0224\u022b\5\u00b8]\2\u0225\u0227\7\34\2\2\u0226")
        buf.write("\u0228\7\u00aa\2\2\u0227\u0226\3\2\2\2\u0227\u0228\3\2")
        buf.write("\2\2\u0228\u0229\3\2\2\2\u0229\u022b\5\u00b8]\2\u022a")
        buf.write("\u01e3\3\2\2\2\u022a\u01e4\3\2\2\2\u022a\u01e7\3\2\2\2")
        buf.write("\u022a\u01ea\3\2\2\2\u022a\u01ed\3\2\2\2\u022a\u01f2\3")
        buf.write("\2\2\2\u022a\u01f4\3\2\2\2\u022a\u01f6\3\2\2\2\u022a\u01fa")
        buf.write("\3\2\2\2\u022a\u01fd\3\2\2\2\u022a\u0200\3\2\2\2\u022a")
        buf.write("\u0205\3\2\2\2\u022a\u0208\3\2\2\2\u022a\u020c\3\2\2\2")
        buf.write("\u022a\u0212\3\2\2\2\u022a\u0213\3\2\2\2\u022a\u0216\3")
        buf.write("\2\2\2\u022a\u0219\3\2\2\2\u022a\u021c\3\2\2\2\u022a\u021f")
        buf.write("\3\2\2\2\u022a\u0222\3\2\2\2\u022a\u0225\3\2\2\2\u022b")
        buf.write("\61\3\2\2\2\u022c\u022d\7\6\2\2\u022d\u022e\5\u00acW\2")
        buf.write("\u022e\u022f\5\u00acW\2\u022f\u0230\5\u00b4[\2\u0230\u0231")
        buf.write("\5\u00b4[\2\u0231\u0235\5\u00b4[\2\u0232\u0234\5\66\34")
        buf.write("\2\u0233\u0232\3\2\2\2\u0234\u0237\3\2\2\2\u0235\u0233")
        buf.write("\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u023e\3\2\2\2\u0237")
        buf.write("\u0235\3\2\2\2\u0238\u0239\7\u009b\2\2\u0239\u023a\5\u00ac")
        buf.write("W\2\u023a\u023b\5\u00acW\2\u023b\u023d\3\2\2\2\u023c\u0238")
        buf.write("\3\2\2\2\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023e")
        buf.write("\u023f\3\2\2\2\u023f\63\3\2\2\2\u0240\u023e\3\2\2\2\u0241")
        buf.write("\u0243\7\35\2\2\u0242\u0244\7\u00aa\2\2\u0243\u0242\3")
        buf.write("\2\2\2\u0243\u0244\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0250")
        buf.write("\5\u00b8]\2\u0246\u0248\7\36\2\2\u0247\u0249\7\u00aa\2")
        buf.write("\2\u0248\u0247\3\2\2\2\u0248\u0249\3\2\2\2\u0249\u024a")
        buf.write("\3\2\2\2\u024a\u0250\5\u00b8]\2\u024b\u024c\7\37\2\2\u024c")
        buf.write("\u0250\5\u00acW\2\u024d\u024e\7 \2\2\u024e\u0250\5\u00ac")
        buf.write("W\2\u024f\u0241\3\2\2\2\u024f\u0246\3\2\2\2\u024f\u024b")
        buf.write("\3\2\2\2\u024f\u024d\3\2\2\2\u0250\65\3\2\2\2\u0251\u0253")
        buf.write("\7!\2\2\u0252\u0254\7\u00aa\2\2\u0253\u0252\3\2\2\2\u0253")
        buf.write("\u0254\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0275\5\u00ba")
        buf.write("^\2\u0256\u0258\7\"\2\2\u0257\u0259\7\u00aa\2\2\u0258")
        buf.write("\u0257\3\2\2\2\u0258\u0259\3\2\2\2\u0259\u025a\3\2\2\2")
        buf.write("\u025a\u0275\5\u00ba^\2\u025b\u025d\7:\2\2\u025c\u025e")
        buf.write("\7\u00aa\2\2\u025d\u025c\3\2\2\2\u025d\u025e\3\2\2\2\u025e")
        buf.write("\u025f\3\2\2\2\u025f\u0275\5\u00ba^\2\u0260\u0262\7#\2")
        buf.write("\2\u0261\u0263\7\u00aa\2\2\u0262\u0261\3\2\2\2\u0262\u0263")
        buf.write("\3\2\2\2\u0263\u0264\3\2\2\2\u0264\u0275\5\u00ba^\2\u0265")
        buf.write("\u0267\7$\2\2\u0266\u0268\7\u00aa\2\2\u0267\u0266\3\2")
        buf.write("\2\2\u0267\u0268\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u0275")
        buf.write("\5\u00ba^\2\u026a\u026c\7%\2\2\u026b\u026d\7\u00aa\2\2")
        buf.write("\u026c\u026b\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u026e\3")
        buf.write("\2\2\2\u026e\u0275\5\u00ba^\2\u026f\u0271\7\62\2\2\u0270")
        buf.write("\u0272\7\u00aa\2\2\u0271\u0270\3\2\2\2\u0271\u0272\3\2")
        buf.write("\2\2\u0272\u0273\3\2\2\2\u0273\u0275\5\u00ba^\2\u0274")
        buf.write("\u0251\3\2\2\2\u0274\u0256\3\2\2\2\u0274\u025b\3\2\2\2")
        buf.write("\u0274\u0260\3\2\2\2\u0274\u0265\3\2\2\2\u0274\u026a\3")
        buf.write("\2\2\2\u0274\u026f\3\2\2\2\u0275\67\3\2\2\2\u0276\u0280")
        buf.write("\5:\36\2\u0277\u0279\7(\2\2\u0278\u027a\7\u00aa\2\2\u0279")
        buf.write("\u0278\3\2\2\2\u0279\u027a\3\2\2\2\u027a\u027b\3\2\2\2")
        buf.write("\u027b\u0280\7\u00a0\2\2\u027c\u0280\7\25\2\2\u027d\u027e")
        buf.write("\7\27\2\2\u027e\u0280\5\u00b8]\2\u027f\u0276\3\2\2\2\u027f")
        buf.write("\u0277\3\2\2\2\u027f\u027c\3\2\2\2\u027f\u027d\3\2\2\2")
        buf.write("\u02809\3\2\2\2\u0281\u0282\7\6\2\2\u0282\u0283\5\u00ac")
        buf.write("W\2\u0283\u0284\5\u00acW\2\u0284\u0285\5\u00acW\2\u0285")
        buf.write("\u0286\5\u00acW\2\u0286\u0287\5\u00b4[\2\u0287\u0288\5")
        buf.write("\u00b4[\2\u0288\u0289\5\u00b4[\2\u0289\u028a\7\u00a0\2")
        buf.write("\2\u028a;\3\2\2\2\u028b\u029e\5> \2\u028c\u028d\7\13\2")
        buf.write("\2\u028d\u029e\7\u00a4\2\2\u028e\u028f\7*\2\2\u028f\u0290")
        buf.write("\5\u00b8]\2\u0290\u0291\5\u00b8]\2\u0291\u0292\5\u00b8")
        buf.write("]\2\u0292\u029e\3\2\2\2\u0293\u0294\7+\2\2\u0294\u029e")
        buf.write("\5\u00b8]\2\u0295\u0296\7\20\2\2\u0296\u029e\7\u00a0\2")
        buf.write("\2\u0297\u0298\7\21\2\2\u0298\u029e\7\u00bd\2\2\u0299")
        buf.write("\u029a\7\23\2\2\u029a\u029b\7\24\2\2\u029b\u029e\5\u00b8")
        buf.write("]\2\u029c\u029e\7\25\2\2\u029d\u028b\3\2\2\2\u029d\u028c")
        buf.write("\3\2\2\2\u029d\u028e\3\2\2\2\u029d\u0293\3\2\2\2\u029d")
        buf.write("\u0295\3\2\2\2\u029d\u0297\3\2\2\2\u029d\u0299\3\2\2\2")
        buf.write("\u029d\u029c\3\2\2\2\u029e=\3\2\2\2\u029f\u02a0\7\6\2")
        buf.write("\2\u02a0\u02a1\5\u00acW\2\u02a1\u02a2\5\u00acW\2\u02a2")
        buf.write("\u02a3\5\u00acW\2\u02a3\u02a4\5\u00acW\2\u02a4\u02a5\5")
        buf.write("\u00acW\2\u02a5\u02a6\5\u00acW\2\u02a6\u02a7\5\u00b4[")
        buf.write("\2\u02a7\u02a9\5\u00b4[\2\u02a8\u02aa\5\u00b4[\2\u02a9")
        buf.write("\u02a8\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa?\3\2\2\2\u02ab")
        buf.write("\u02c6\5B\"\2\u02ac\u02ad\7\13\2\2\u02ad\u02c6\7\u00a4")
        buf.write("\2\2\u02ae\u02af\7.\2\2\u02af\u02c6\7\u00c0\2\2\u02b0")
        buf.write("\u02b1\7\27\2\2\u02b1\u02c6\5\u00b8]\2\u02b2\u02b3\7/")
        buf.write("\2\2\u02b3\u02c6\7\u00a1\2\2\u02b4\u02b5\7\60\2\2\u02b5")
        buf.write("\u02c6\7\u00b9\2\2\u02b6\u02b7\7*\2\2\u02b7\u02b8\5\u00b8")
        buf.write("]\2\u02b8\u02b9\5\u00b8]\2\u02b9\u02ba\5\u00b8]\2\u02ba")
        buf.write("\u02c6\3\2\2\2\u02bb\u02bc\7+\2\2\u02bc\u02c6\5\u00b8")
        buf.write("]\2\u02bd\u02be\7\20\2\2\u02be\u02c6\7\u00a0\2\2\u02bf")
        buf.write("\u02c0\7\21\2\2\u02c0\u02c6\7\u00bd\2\2\u02c1\u02c2\7")
        buf.write("\23\2\2\u02c2\u02c3\7\24\2\2\u02c3\u02c6\5\u00b8]\2\u02c4")
        buf.write("\u02c6\7\25\2\2\u02c5\u02ab\3\2\2\2\u02c5\u02ac\3\2\2")
        buf.write("\2\u02c5\u02ae\3\2\2\2\u02c5\u02b0\3\2\2\2\u02c5\u02b2")
        buf.write("\3\2\2\2\u02c5\u02b4\3\2\2\2\u02c5\u02b6\3\2\2\2\u02c5")
        buf.write("\u02bb\3\2\2\2\u02c5\u02bd\3\2\2\2\u02c5\u02bf\3\2\2\2")
        buf.write("\u02c5\u02c1\3\2\2\2\u02c5\u02c4\3\2\2\2\u02c6A\3\2\2")
        buf.write("\2\u02c7\u02c8\7\6\2\2\u02c8\u02c9\5\u00acW\2\u02c9\u02ca")
        buf.write("\5\u00acW\2\u02ca\u02cb\5\u00acW\2\u02cb\u02cc\5\u00ac")
        buf.write("W\2\u02cc\u02cd\5\u00acW\2\u02cd\u02ce\5\u00acW\2\u02ce")
        buf.write("\u02cf\5\u00b4[\2\u02cf\u02d6\5\u00b4[\2\u02d0\u02d7\5")
        buf.write("\u00b4[\2\u02d1\u02d2\5\u00b4[\2\u02d2\u02d3\5\u00b4[")
        buf.write("\2\u02d3\u02d4\5\u00b4[\2\u02d4\u02d5\5\u00b4[\2\u02d5")
        buf.write("\u02d7\3\2\2\2\u02d6\u02d0\3\2\2\2\u02d6\u02d1\3\2\2\2")
        buf.write("\u02d6\u02d7\3\2\2\2\u02d7C\3\2\2\2\u02d8\u02f0\5F$\2")
        buf.write("\u02d9\u02db\7\62\2\2\u02da\u02dc\7\u00aa\2\2\u02db\u02da")
        buf.write("\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02dd\3\2\2\2\u02dd")
        buf.write("\u02f0\7\u00a0\2\2\u02de\u02df\7\13\2\2\u02df\u02f0\7")
        buf.write("\u00a4\2\2\u02e0\u02e1\7+\2\2\u02e1\u02e2\5\u00b8]\2\u02e2")
        buf.write("\u02e3\5\u00b8]\2\u02e3\u02f0\3\2\2\2\u02e4\u02e5\7\20")
        buf.write("\2\2\u02e5\u02f0\7\u00a0\2\2\u02e6\u02e8\7\63\2\2\u02e7")
        buf.write("\u02e9\7\u00aa\2\2\u02e8\u02e7\3\2\2\2\u02e8\u02e9\3\2")
        buf.write("\2\2\u02e9\u02ea\3\2\2\2\u02ea\u02f0\7\u00a0\2\2\u02eb")
        buf.write("\u02ec\7\23\2\2\u02ec\u02ed\7\24\2\2\u02ed\u02f0\5\u00b8")
        buf.write("]\2\u02ee\u02f0\7\25\2\2\u02ef\u02d8\3\2\2\2\u02ef\u02d9")
        buf.write("\3\2\2\2\u02ef\u02de\3\2\2\2\u02ef\u02e0\3\2\2\2\u02ef")
        buf.write("\u02e4\3\2\2\2\u02ef\u02e6\3\2\2\2\u02ef\u02eb\3\2\2\2")
        buf.write("\u02ef\u02ee\3\2\2\2\u02f0E\3\2\2\2\u02f1\u02f2\7\6\2")
        buf.write("\2\u02f2\u02f3\5\u00acW\2\u02f3\u02f4\5\u00acW\2\u02f4")
        buf.write("\u02f5\5\u00acW\2\u02f5\u02f6\5\u00acW\2\u02f6\u02f7\5")
        buf.write("\u00b4[\2\u02f7\u02f8\5\u00b4[\2\u02f8\u02f9\5\u00b4[")
        buf.write("\2\u02f9\u02fa\5\u00b4[\2\u02faG\3\2\2\2\u02fb\u0309\5")
        buf.write("J&\2\u02fc\u02fd\7\13\2\2\u02fd\u0309\7\u00a4\2\2\u02fe")
        buf.write("\u02ff\7*\2\2\u02ff\u0309\5\u00b8]\2\u0300\u0301\7\20")
        buf.write("\2\2\u0301\u0309\7\u00a0\2\2\u0302\u0303\7\21\2\2\u0303")
        buf.write("\u0309\7\u00bd\2\2\u0304\u0305\7\23\2\2\u0305\u0306\7")
        buf.write("\24\2\2\u0306\u0309\5\u00b8]\2\u0307\u0309\7\25\2\2\u0308")
        buf.write("\u02fb\3\2\2\2\u0308\u02fc\3\2\2\2\u0308\u02fe\3\2\2\2")
        buf.write("\u0308\u0300\3\2\2\2\u0308\u0302\3\2\2\2\u0308\u0304\3")
        buf.write("\2\2\2\u0308\u0307\3\2\2\2\u0309I\3\2\2\2\u030a\u030b")
        buf.write("\7\6\2\2\u030b\u030c\5\u00acW\2\u030c\u030d\5\u00acW\2")
        buf.write("\u030d\u030e\5\u00b4[\2\u030e\u030f\5\u00b4[\2\u030fK")
        buf.write("\3\2\2\2\u0310\u0326\5N(\2\u0311\u0312\7\13\2\2\u0312")
        buf.write("\u0326\7\u00a4\2\2\u0313\u0314\7*\2\2\u0314\u0315\5\u00b8")
        buf.write("]\2\u0315\u0316\5\u00b8]\2\u0316\u0317\5\u00b8]\2\u0317")
        buf.write("\u0318\5\u00b8]\2\u0318\u0326\3\2\2\2\u0319\u031a\7+\2")
        buf.write("\2\u031a\u0326\5\u00b8]\2\u031b\u031c\7\20\2\2\u031c\u0326")
        buf.write("\7\u00a0\2\2\u031d\u031e\7\21\2\2\u031e\u0326\7\u00bd")
        buf.write("\2\2\u031f\u0320\7\23\2\2\u0320\u0321\7\24\2\2\u0321\u0326")
        buf.write("\5\u00b8]\2\u0322\u0326\7\25\2\2\u0323\u0324\7.\2\2\u0324")
        buf.write("\u0326\7\u00c1\2\2\u0325\u0310\3\2\2\2\u0325\u0311\3\2")
        buf.write("\2\2\u0325\u0313\3\2\2\2\u0325\u0319\3\2\2\2\u0325\u031b")
        buf.write("\3\2\2\2\u0325\u031d\3\2\2\2\u0325\u031f\3\2\2\2\u0325")
        buf.write("\u0322\3\2\2\2\u0325\u0323\3\2\2\2\u0326M\3\2\2\2\u0327")
        buf.write("\u0328\7\6\2\2\u0328\u0329\5\u00acW\2\u0329\u032a\5\u00ac")
        buf.write("W\2\u032a\u032b\5\u00acW\2\u032b\u032c\5\u00acW\2\u032c")
        buf.write("\u032d\5\u00b4[\2\u032d\u032e\5\u00b4[\2\u032eO\3\2\2")
        buf.write("\2\u032f\u0333\7\67\2\2\u0330\u0332\5R*\2\u0331\u0330")
        buf.write("\3\2\2\2\u0332\u0335\3\2\2\2\u0333\u0331\3\2\2\2\u0333")
        buf.write("\u0334\3\2\2\2\u0334\u0336\3\2\2\2\u0335\u0333\3\2\2\2")
        buf.write("\u0336\u0339\7\4\2\2\u0337\u0339\78\2\2\u0338\u032f\3")
        buf.write("\2\2\2\u0338\u0337\3\2\2\2\u0339Q\3\2\2\2\u033a\u033c")
        buf.write("\79\2\2\u033b\u033d\7\u00aa\2\2\u033c\u033b\3\2\2\2\u033c")
        buf.write("\u033d\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u0345\5\u00ac")
        buf.write("W\2\u033f\u0341\7:\2\2\u0340\u0342\7\u00aa\2\2\u0341\u0340")
        buf.write("\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0343\3\2\2\2\u0343")
        buf.write("\u0345\5\u00b8]\2\u0344\u033a\3\2\2\2\u0344\u033f\3\2")
        buf.write("\2\2\u0345S\3\2\2\2\u0346\u035f\5V,\2\u0347\u0348\7\13")
        buf.write("\2\2\u0348\u035f\7\u00a4\2\2\u0349\u034a\7<\2\2\u034a")
        buf.write("\u034b\7\u00a0\2\2\u034b\u035f\5\u00b8]\2\u034c\u034d")
        buf.write("\7+\2\2\u034d\u035f\5\u00b8]\2\u034e\u034f\7\20\2\2\u034f")
        buf.write("\u035f\7\u00a0\2\2\u0350\u0351\7\23\2\2\u0351\u0352\7")
        buf.write("\24\2\2\u0352\u0356\5\u00b8]\2\u0353\u0357\7w\2\2\u0354")
        buf.write("\u0355\7\13\2\2\u0355\u0357\7\u00a4\2\2\u0356\u0353\3")
        buf.write("\2\2\2\u0356\u0354\3\2\2\2\u0357\u035f\3\2\2\2\u0358\u035f")
        buf.write("\7\25\2\2\u0359\u035a\7=\2\2\u035a\u035b\5\u00b8]\2\u035b")
        buf.write("\u035c\7\u00a0\2\2\u035c\u035f\3\2\2\2\u035d\u035f\7>")
        buf.write("\2\2\u035e\u0346\3\2\2\2\u035e\u0347\3\2\2\2\u035e\u0349")
        buf.write("\3\2\2\2\u035e\u034c\3\2\2\2\u035e\u034e\3\2\2\2\u035e")
        buf.write("\u0350\3\2\2\2\u035e\u0358\3\2\2\2\u035e\u0359\3\2\2\2")
        buf.write("\u035e\u035d\3\2\2\2\u035fU\3\2\2\2\u0360\u0361\7\6\2")
        buf.write("\2\u0361\u0362\5\u00acW\2\u0362\u0363\5\u00acW\2\u0363")
        buf.write("W\3\2\2\2\u0364\u038c\5Z.\2\u0365\u0366\7\13\2\2\u0366")
        buf.write("\u038c\7\u00a4\2\2\u0367\u0368\7*\2\2\u0368\u0369\5\u00b8")
        buf.write("]\2\u0369\u036a\5\u00b8]\2\u036a\u036b\5\u00b8]\2\u036b")
        buf.write("\u036c\5\u00b8]\2\u036c\u038c\3\2\2\2\u036d\u036f\7\62")
        buf.write("\2\2\u036e\u0370\7\u00aa\2\2\u036f\u036e\3\2\2\2\u036f")
        buf.write("\u0370\3\2\2\2\u0370\u0371\3\2\2\2\u0371\u038c\7\u00a0")
        buf.write("\2\2\u0372\u0373\7@\2\2\u0373\u038c\7\u00a0\2\2\u0374")
        buf.write("\u0375\7+\2\2\u0375\u0377\5\u00b8]\2\u0376\u0378\5\u00b8")
        buf.write("]\2\u0377\u0376\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u038c")
        buf.write("\3\2\2\2\u0379\u037a\7\20\2\2\u037a\u038c\7\u00a0\2\2")
        buf.write("\u037b\u037d\7\63\2\2\u037c\u037e\7\u00aa\2\2\u037d\u037c")
        buf.write("\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u037f\3\2\2\2\u037f")
        buf.write("\u038c\7\u00a0\2\2\u0380\u0381\7\21\2\2\u0381\u038c\7")
        buf.write("\u00bd\2\2\u0382\u0383\7\23\2\2\u0383\u0384\7\24\2\2\u0384")
        buf.write("\u0388\5\u00b8]\2\u0385\u0389\7w\2\2\u0386\u0387\7\13")
        buf.write("\2\2\u0387\u0389\7\u00a4\2\2\u0388\u0385\3\2\2\2\u0388")
        buf.write("\u0386\3\2\2\2\u0389\u038c\3\2\2\2\u038a\u038c\7\25\2")
        buf.write("\2\u038b\u0364\3\2\2\2\u038b\u0365\3\2\2\2\u038b\u0367")
        buf.write("\3\2\2\2\u038b\u036d\3\2\2\2\u038b\u0372\3\2\2\2\u038b")
        buf.write("\u0374\3\2\2\2\u038b\u0379\3\2\2\2\u038b\u037b\3\2\2\2")
        buf.write("\u038b\u0380\3\2\2\2\u038b\u0382\3\2\2\2\u038b\u038a\3")
        buf.write("\2\2\2\u038cY\3\2\2\2\u038d\u038e\7\6\2\2\u038e\u038f")
        buf.write("\5\u00acW\2\u038f\u0390\5\u00acW\2\u0390\u0391\5\u00ac")
        buf.write("W\2\u0391\u0397\5\u00acW\2\u0392\u0393\5\u00acW\2\u0393")
        buf.write("\u0394\5\u00acW\2\u0394\u0395\5\u00acW\2\u0395\u0396\5")
        buf.write("\u00acW\2\u0396\u0398\3\2\2\2\u0397\u0392\3\2\2\2\u0397")
        buf.write("\u0398\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u039a\5\u00b4")
        buf.write("[\2\u039a\u039e\5\u00b4[\2\u039b\u039c\5\u00b4[\2\u039c")
        buf.write("\u039d\5\u00b4[\2\u039d\u039f\3\2\2\2\u039e\u039b\3\2")
        buf.write("\2\2\u039e\u039f\3\2\2\2\u039f[\3\2\2\2\u03a0\u03bb\5")
        buf.write("^\60\2\u03a1\u03a2\7\13\2\2\u03a2\u03bb\7\u00a4\2\2\u03a3")
        buf.write("\u03a4\7<\2\2\u03a4\u03a5\7\u00a0\2\2\u03a5\u03a6\7\u00a0")
        buf.write("\2\2\u03a6\u03a7\5\u00b8]\2\u03a7\u03a8\5\u00b8]\2\u03a8")
        buf.write("\u03a9\5\u00b8]\2\u03a9\u03bb\3\2\2\2\u03aa\u03ab\7+\2")
        buf.write("\2\u03ab\u03bb\5\u00b8]\2\u03ac\u03ad\7\20\2\2\u03ad\u03bb")
        buf.write("\7\u00a0\2\2\u03ae\u03af\7B\2\2\u03af\u03bb\5\u00b8]\2")
        buf.write("\u03b0\u03b1\7C\2\2\u03b1\u03bb\5\u00b8]\2\u03b2\u03b3")
        buf.write("\7\21\2\2\u03b3\u03bb\7\u00bd\2\2\u03b4\u03b5\7\23\2\2")
        buf.write("\u03b5\u03b6\7\24\2\2\u03b6\u03bb\5\u00b8]\2\u03b7\u03bb")
        buf.write("\5`\61\2\u03b8\u03bb\7\25\2\2\u03b9\u03bb\7>\2\2\u03ba")
        buf.write("\u03a0\3\2\2\2\u03ba\u03a1\3\2\2\2\u03ba\u03a3\3\2\2\2")
        buf.write("\u03ba\u03aa\3\2\2\2\u03ba\u03ac\3\2\2\2\u03ba\u03ae\3")
        buf.write("\2\2\2\u03ba\u03b0\3\2\2\2\u03ba\u03b2\3\2\2\2\u03ba\u03b4")
        buf.write("\3\2\2\2\u03ba\u03b7\3\2\2\2\u03ba\u03b8\3\2\2\2\u03ba")
        buf.write("\u03b9\3\2\2\2\u03bb]\3\2\2\2\u03bc\u03bd\7\6\2\2\u03bd")
        buf.write("\u03be\5\u00acW\2\u03be\u03bf\5\u00acW\2\u03bf\u03c0\5")
        buf.write("\u00acW\2\u03c0\u03c1\5\u00acW\2\u03c1\u03c2\5\u00acW")
        buf.write("\2\u03c2\u03c3\5\u00b4[\2\u03c3\u03c4\5\u00b4[\2\u03c4")
        buf.write("_\3\2\2\2\u03c5\u03c6\7D\2\2\u03c6\u03c7\5\u00acW\2\u03c7")
        buf.write("\u03c8\5\u00b8]\2\u03c8\u03c9\5\u00b8]\2\u03c9a\3\2\2")
        buf.write("\2\u03ca\u03ec\5d\63\2\u03cb\u03ec\5f\64\2\u03cc\u03ec")
        buf.write("\5h\65\2\u03cd\u03ec\5j\66\2\u03ce\u03ec\5l\67\2\u03cf")
        buf.write("\u03ec\5n8\2\u03d0\u03ec\5p9\2\u03d1\u03ec\5r:\2\u03d2")
        buf.write("\u03ec\5t;\2\u03d3\u03d4\7\13\2\2\u03d4\u03ec\7\u00a4")
        buf.write("\2\2\u03d5\u03d6\7L\2\2\u03d6\u03ec\5\u00b8]\2\u03d7\u03d8")
        buf.write("\7@\2\2\u03d8\u03ec\7\u00a0\2\2\u03d9\u03da\7+\2\2\u03da")
        buf.write("\u03dc\5\u00b8]\2\u03db\u03dd\5\u00b8]\2\u03dc\u03db\3")
        buf.write("\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03ec\3\2\2\2\u03de\u03df")
        buf.write("\7\21\2\2\u03df\u03ec\7\u00bd\2\2\u03e0\u03e1\7\23\2\2")
        buf.write("\u03e1\u03e2\7\24\2\2\u03e2\u03e6\5\u00b8]\2\u03e3\u03e7")
        buf.write("\7w\2\2\u03e4\u03e5\7\13\2\2\u03e5\u03e7\7\u00a4\2\2\u03e6")
        buf.write("\u03e3\3\2\2\2\u03e6\u03e4\3\2\2\2\u03e7\u03e8\3\2\2\2")
        buf.write("\u03e8\u03e9\7\u00a4\2\2\u03e9\u03ec\3\2\2\2\u03ea\u03ec")
        buf.write("\7\25\2\2\u03eb\u03ca\3\2\2\2\u03eb\u03cb\3\2\2\2\u03eb")
        buf.write("\u03cc\3\2\2\2\u03eb\u03cd\3\2\2\2\u03eb\u03ce\3\2\2\2")
        buf.write("\u03eb\u03cf\3\2\2\2\u03eb\u03d0\3\2\2\2\u03eb\u03d1\3")
        buf.write("\2\2\2\u03eb\u03d2\3\2\2\2\u03eb\u03d3\3\2\2\2\u03eb\u03d5")
        buf.write("\3\2\2\2\u03eb\u03d7\3\2\2\2\u03eb\u03d9\3\2\2\2\u03eb")
        buf.write("\u03de\3\2\2\2\u03eb\u03e0\3\2\2\2\u03eb\u03ea\3\2\2\2")
        buf.write("\u03ecc\3\2\2\2\u03ed\u03ee\7F\2\2\u03ee\u03f0\5\u00ac")
        buf.write("W\2\u03ef\u03f1\5\u00acW\2\u03f0\u03ef\3\2\2\2\u03f0\u03f1")
        buf.write("\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f4\5\u00b8]\2\u03f3")
        buf.write("\u03f5\5\u00b8]\2\u03f4\u03f3\3\2\2\2\u03f4\u03f5\3\2")
        buf.write("\2\2\u03f5e\3\2\2\2\u03f6\u03f7\7D\2\2\u03f7\u03f8\5\u00ac")
        buf.write("W\2\u03f8\u03f9\5\u00b8]\2\u03f9g\3\2\2\2\u03fa\u03fb")
        buf.write("\7\65\2\2\u03fb\u03fc\5\u00acW\2\u03fc\u03fd\5\u00acW")
        buf.write("\2\u03fd\u03fe\5\u00acW\2\u03fe\u0400\7\u00a4\2\2\u03ff")
        buf.write("\u0401\7\u00a1\2\2\u0400\u03ff\3\2\2\2\u0400\u0401\3\2")
        buf.write("\2\2\u0401\u0402\3\2\2\2\u0402\u0403\7\u00a4\2\2\u0403")
        buf.write("i\3\2\2\2\u0404\u0405\7G\2\2\u0405\u0406\5\u00acW\2\u0406")
        buf.write("k\3\2\2\2\u0407\u0408\7A\2\2\u0408\u0409\5\u00acW\2\u0409")
        buf.write("m\3\2\2\2\u040a\u040b\7H\2\2\u040b\u040c\5\u00acW\2\u040c")
        buf.write("o\3\2\2\2\u040d\u040e\7I\2\2\u040e\u040f\5\u00acW\2\u040f")
        buf.write("q\3\2\2\2\u0410\u0411\7J\2\2\u0411\u0412\7\u00a4\2\2\u0412")
        buf.write("\u0413\5\u00acW\2\u0413\u0414\5\u00acW\2\u0414\u0415\5")
        buf.write("\u00acW\2\u0415\u0416\5\u00acW\2\u0416\u0418\5\u00acW")
        buf.write("\2\u0417\u0419\5\u00acW\2\u0418\u0417\3\2\2\2\u0418\u0419")
        buf.write("\3\2\2\2\u0419s\3\2\2\2\u041a\u041b\7K\2\2\u041b\u041c")
        buf.write("\5\u00acW\2\u041cu\3\2\2\2\u041d\u0484\5x=\2\u041e\u041f")
        buf.write("\7\13\2\2\u041f\u0484\7\u00a4\2\2\u0420\u0421\7\35\2\2")
        buf.write("\u0421\u0484\5\u00b8]\2\u0422\u0423\7+\2\2\u0423\u0484")
        buf.write("\5\u00b8]\2\u0424\u0425\7N\2\2\u0425\u0426\5\u00b8]\2")
        buf.write("\u0426\u0427\5\u00b8]\2\u0427\u042c\5\u00b8]\2\u0428\u0429")
        buf.write("\5\u00b8]\2\u0429\u042a\5\u00b8]\2\u042a\u042b\5\u00b8")
        buf.write("]\2\u042b\u042d\3\2\2\2\u042c\u0428\3\2\2\2\u042c\u042d")
        buf.write("\3\2\2\2\u042d\u0432\3\2\2\2\u042e\u042f\5\u00b8]\2\u042f")
        buf.write("\u0430\5\u00b8]\2\u0430\u0431\5\u00b8]\2\u0431\u0433\3")
        buf.write("\2\2\2\u0432\u042e\3\2\2\2\u0432\u0433\3\2\2\2\u0433\u0438")
        buf.write("\3\2\2\2\u0434\u0435\5\u00b8]\2\u0435\u0436\5\u00b8]\2")
        buf.write("\u0436\u0437\5\u00b8]\2\u0437\u0439\3\2\2\2\u0438\u0434")
        buf.write("\3\2\2\2\u0438\u0439\3\2\2\2\u0439\u0484\3\2\2\2\u043a")
        buf.write("\u043b\7\20\2\2\u043b\u0484\7\u00a0\2\2\u043c\u043d\7")
        buf.write("O\2\2\u043d\u043e\5\u00b8]\2\u043e\u043f\5\u00b8]\2\u043f")
        buf.write("\u0444\5\u00b8]\2\u0440\u0441\5\u00b8]\2\u0441\u0442\5")
        buf.write("\u00b8]\2\u0442\u0443\5\u00b8]\2\u0443\u0445\3\2\2\2\u0444")
        buf.write("\u0440\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u044a\3\2\2\2")
        buf.write("\u0446\u0447\5\u00b8]\2\u0447\u0448\5\u00b8]\2\u0448\u0449")
        buf.write("\5\u00b8]\2\u0449\u044b\3\2\2\2\u044a\u0446\3\2\2\2\u044a")
        buf.write("\u044b\3\2\2\2\u044b\u0450\3\2\2\2\u044c\u044d\5\u00b8")
        buf.write("]\2\u044d\u044e\5\u00b8]\2\u044e\u044f\5\u00b8]\2\u044f")
        buf.write("\u0451\3\2\2\2\u0450\u044c\3\2\2\2\u0450\u0451\3\2\2\2")
        buf.write("\u0451\u0484\3\2\2\2\u0452\u0453\7\23\2\2\u0453\u0454")
        buf.write("\7\24\2\2\u0454\u0458\5\u00b8]\2\u0455\u0459\7w\2\2\u0456")
        buf.write("\u0457\7\13\2\2\u0457\u0459\7\u00a4\2\2\u0458\u0455\3")
        buf.write("\2\2\2\u0458\u0456\3\2\2\2\u0459\u0484\3\2\2\2\u045a\u045b")
        buf.write("\7P\2\2\u045b\u045c\5\u00b8]\2\u045c\u045d\5\u00b8]\2")
        buf.write("\u045d\u0462\5\u00b8]\2\u045e\u045f\5\u00b8]\2\u045f\u0460")
        buf.write("\5\u00b8]\2\u0460\u0461\5\u00b8]\2\u0461\u0463\3\2\2\2")
        buf.write("\u0462\u045e\3\2\2\2\u0462\u0463\3\2\2\2\u0463\u0468\3")
        buf.write("\2\2\2\u0464\u0465\5\u00b8]\2\u0465\u0466\5\u00b8]\2\u0466")
        buf.write("\u0467\5\u00b8]\2\u0467\u0469\3\2\2\2\u0468\u0464\3\2")
        buf.write("\2\2\u0468\u0469\3\2\2\2\u0469\u046e\3\2\2\2\u046a\u046b")
        buf.write("\5\u00b8]\2\u046b\u046c\5\u00b8]\2\u046c\u046d\5\u00b8")
        buf.write("]\2\u046d\u046f\3\2\2\2\u046e\u046a\3\2\2\2\u046e\u046f")
        buf.write("\3\2\2\2\u046f\u0484\3\2\2\2\u0470\u0484\7\25\2\2\u0471")
        buf.write("\u0472\7\27\2\2\u0472\u0484\5\u00b8]\2\u0473\u0474\7Q")
        buf.write("\2\2\u0474\u0484\7\u00c4\2\2\u0475\u0476\7=\2\2\u0476")
        buf.write("\u0477\7S\2\2\u0477\u0479\5\u00b8]\2\u0478\u047a\5\u00b8")
        buf.write("]\2\u0479\u0478\3\2\2\2\u0479\u047a\3\2\2\2\u047a\u047c")
        buf.write("\3\2\2\2\u047b\u047d\5\u00b8]\2\u047c\u047b\3\2\2\2\u047c")
        buf.write("\u047d\3\2\2\2\u047d\u047f\3\2\2\2\u047e\u0480\5\u00b8")
        buf.write("]\2\u047f\u047e\3\2\2\2\u047f\u0480\3\2\2\2\u0480\u0484")
        buf.write("\3\2\2\2\u0481\u0484\7R\2\2\u0482\u0484\7>\2\2\u0483\u041d")
        buf.write("\3\2\2\2\u0483\u041e\3\2\2\2\u0483\u0420\3\2\2\2\u0483")
        buf.write("\u0422\3\2\2\2\u0483\u0424\3\2\2\2\u0483\u043a\3\2\2\2")
        buf.write("\u0483\u043c\3\2\2\2\u0483\u0452\3\2\2\2\u0483\u045a\3")
        buf.write("\2\2\2\u0483\u0470\3\2\2\2\u0483\u0471\3\2\2\2\u0483\u0473")
        buf.write("\3\2\2\2\u0483\u0475\3\2\2\2\u0483\u0481\3\2\2\2\u0483")
        buf.write("\u0482\3\2\2\2\u0484w\3\2\2\2\u0485\u0486\7\6\2\2\u0486")
        buf.write("\u0487\5\u00acW\2\u0487\u0488\5\u00acW\2\u0488\u0489\5")
        buf.write("\u00acW\2\u0489\u048f\5\u00acW\2\u048a\u048b\5\u00acW")
        buf.write("\2\u048b\u048c\5\u00acW\2\u048c\u048d\5\u00acW\2\u048d")
        buf.write("\u048e\5\u00acW\2\u048e\u0490\3\2\2\2\u048f\u048a\3\2")
        buf.write("\2\2\u048f\u0490\3\2\2\2\u0490\u0496\3\2\2\2\u0491\u0492")
        buf.write("\5\u00acW\2\u0492\u0493\5\u00acW\2\u0493\u0494\5\u00ac")
        buf.write("W\2\u0494\u0495\5\u00acW\2\u0495\u0497\3\2\2\2\u0496\u0491")
        buf.write("\3\2\2\2\u0496\u0497\3\2\2\2\u0497\u049d\3\2\2\2\u0498")
        buf.write("\u0499\5\u00acW\2\u0499\u049a\5\u00acW\2\u049a\u049b\5")
        buf.write("\u00acW\2\u049b\u049c\5\u00acW\2\u049c\u049e\3\2\2\2\u049d")
        buf.write("\u0498\3\2\2\2\u049d\u049e\3\2\2\2\u049ey\3\2\2\2\u049f")
        buf.write("\u04a5\5|?\2\u04a0\u04a1\7\27\2\2\u04a1\u04a5\5\u00b8")
        buf.write("]\2\u04a2\u04a5\7\23\2\2\u04a3\u04a5\7\25\2\2\u04a4\u049f")
        buf.write("\3\2\2\2\u04a4\u04a0\3\2\2\2\u04a4\u04a2\3\2\2\2\u04a4")
        buf.write("\u04a3\3\2\2\2\u04a5{\3\2\2\2\u04a6\u04a7\7\6\2\2\u04a7")
        buf.write("\u04a8\5\u00acW\2\u04a8\u04a9\5\u00b4[\2\u04a9\u04aa\5")
        buf.write("\u00b4[\2\u04aa}\3\2\2\2\u04ab\u04c2\5\u0080A\2\u04ac")
        buf.write("\u04ad\7\13\2\2\u04ad\u04c2\7\u00a4\2\2\u04ae\u04af\7")
        buf.write("*\2\2\u04af\u04b0\5\u00b8]\2\u04b0\u04b1\5\u00b8]\2\u04b1")
        buf.write("\u04b2\5\u00b8]\2\u04b2\u04b3\5\u00b8]\2\u04b3\u04b4\5")
        buf.write("\u00b8]\2\u04b4\u04c2\3\2\2\2\u04b5\u04b6\7+\2\2\u04b6")
        buf.write("\u04c2\5\u00b8]\2\u04b7\u04b8\7\20\2\2\u04b8\u04c2\7\u00a0")
        buf.write("\2\2\u04b9\u04ba\7\21\2\2\u04ba\u04c2\7\u00bd\2\2\u04bb")
        buf.write("\u04bc\7\23\2\2\u04bc\u04bd\7\24\2\2\u04bd\u04c2\5\u00b8")
        buf.write("]\2\u04be\u04c2\7\25\2\2\u04bf\u04c0\7.\2\2\u04c0\u04c2")
        buf.write("\7\u00c1\2\2\u04c1\u04ab\3\2\2\2\u04c1\u04ac\3\2\2\2\u04c1")
        buf.write("\u04ae\3\2\2\2\u04c1\u04b5\3\2\2\2\u04c1\u04b7\3\2\2\2")
        buf.write("\u04c1\u04b9\3\2\2\2\u04c1\u04bb\3\2\2\2\u04c1\u04be\3")
        buf.write("\2\2\2\u04c1\u04bf\3\2\2\2\u04c2\177\3\2\2\2\u04c3\u04c4")
        buf.write("\7\6\2\2\u04c4\u04c5\5\u00acW\2\u04c5\u04c6\5\u00acW\2")
        buf.write("\u04c6\u04c7\5\u00acW\2\u04c7\u04c8\5\u00acW\2\u04c8\u04c9")
        buf.write("\5\u00acW\2\u04c9\u04ca\5\u00acW\2\u04ca\u04cb\5\u00b4")
        buf.write("[\2\u04cb\u04cc\5\u00b4[\2\u04cc\u0081\3\2\2\2\u04cd\u0507")
        buf.write("\5\u0084C\2\u04ce\u04cf\7\13\2\2\u04cf\u0507\7\u00a4\2")
        buf.write("\2\u04d0\u04d1\7\35\2\2\u04d1\u0507\5\u00b8]\2\u04d2\u04d3")
        buf.write("\7W\2\2\u04d3\u0507\5\u00b8]\2\u04d4\u04d5\7+\2\2\u04d5")
        buf.write("\u0507\5\u00b8]\2\u04d6\u04d7\7N\2\2\u04d7\u04d8\5\u00b8")
        buf.write("]\2\u04d8\u04d9\5\u00b8]\2\u04d9\u04da\5\u00b8]\2\u04da")
        buf.write("\u04db\5\u00b8]\2\u04db\u04dc\5\u00b8]\2\u04dc\u04dd\5")
        buf.write("\u00b8]\2\u04dd\u04de\5\u00b8]\2\u04de\u0507\3\2\2\2\u04df")
        buf.write("\u04e0\7X\2\2\u04e0\u0507\7\u00a0\2\2\u04e1\u04e2\7Y\2")
        buf.write("\2\u04e2\u04e3\5\u00b8]\2\u04e3\u04e4\5\u00b8]\2\u04e4")
        buf.write("\u04e5\5\u00b8]\2\u04e5\u04e6\5\u00b8]\2\u04e6\u04e7\5")
        buf.write("\u00b8]\2\u04e7\u04e8\5\u00b8]\2\u04e8\u04e9\5\u00b8]")
        buf.write("\2\u04e9\u04ea\5\u00b8]\2\u04ea\u0507\3\2\2\2\u04eb\u04ec")
        buf.write("\7\20\2\2\u04ec\u0507\7\u00a0\2\2\u04ed\u04ee\7\23\2\2")
        buf.write("\u04ee\u04ef\7\24\2\2\u04ef\u04f3\5\u00b8]\2\u04f0\u04f4")
        buf.write("\7w\2\2\u04f1\u04f2\7\13\2\2\u04f2\u04f4\7\u00a4\2\2\u04f3")
        buf.write("\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f4\u0507\3\2\2\2")
        buf.write("\u04f5\u04f6\7P\2\2\u04f6\u04f7\5\u00b8]\2\u04f7\u04f8")
        buf.write("\5\u00b8]\2\u04f8\u04f9\5\u00b8]\2\u04f9\u04fa\5\u00b8")
        buf.write("]\2\u04fa\u04fb\5\u00b8]\2\u04fb\u04fc\5\u00b8]\2\u04fc")
        buf.write("\u04fd\5\u00b8]\2\u04fd\u0507\3\2\2\2\u04fe\u0507\7\25")
        buf.write("\2\2\u04ff\u0500\7\u0087\2\2\u0500\u0507\7\u00a0\2\2\u0501")
        buf.write("\u0502\7=\2\2\u0502\u0503\5\u00b8]\2\u0503\u0504\5\u00b8")
        buf.write("]\2\u0504\u0507\3\2\2\2\u0505\u0507\7>\2\2\u0506\u04cd")
        buf.write("\3\2\2\2\u0506\u04ce\3\2\2\2\u0506\u04d0\3\2\2\2\u0506")
        buf.write("\u04d2\3\2\2\2\u0506\u04d4\3\2\2\2\u0506\u04d6\3\2\2\2")
        buf.write("\u0506\u04df\3\2\2\2\u0506\u04e1\3\2\2\2\u0506\u04eb\3")
        buf.write("\2\2\2\u0506\u04ed\3\2\2\2\u0506\u04f5\3\2\2\2\u0506\u04fe")
        buf.write("\3\2\2\2\u0506\u04ff\3\2\2\2\u0506\u0501\3\2\2\2\u0506")
        buf.write("\u0505\3\2\2\2\u0507\u0083\3\2\2\2\u0508\u0509\7\6\2\2")
        buf.write("\u0509\u050a\5\u00acW\2\u050a\u050b\5\u00acW\2\u050b\u050c")
        buf.write("\5\u00acW\2\u050c\u050d\5\u00acW\2\u050d\u0085\3\2\2\2")
        buf.write("\u050e\u052a\5\u0088E\2\u050f\u0510\7\13\2\2\u0510\u052a")
        buf.write("\7\u00a4\2\2\u0511\u0512\7\27\2\2\u0512\u052a\5\u00b8")
        buf.write("]\2\u0513\u0514\7.\2\2\u0514\u052a\7\u00c2\2\2\u0515\u0516")
        buf.write("\7*\2\2\u0516\u0517\5\u00b8]\2\u0517\u0518\5\u00b8]\2")
        buf.write("\u0518\u0519\5\u00b8]\2\u0519\u052a\3\2\2\2\u051a\u051b")
        buf.write("\7[\2\2\u051b\u051c\5\u00b8]\2\u051c\u051d\5\u00b8]\2")
        buf.write("\u051d\u051e\5\u00b8]\2\u051e\u052a\3\2\2\2\u051f\u0520")
        buf.write("\7+\2\2\u0520\u052a\5\u00b8]\2\u0521\u0522\7\20\2\2\u0522")
        buf.write("\u052a\7\u00a0\2\2\u0523\u0524\7\21\2\2\u0524\u052a\7")
        buf.write("\u00bd\2\2\u0525\u0526\7\23\2\2\u0526\u0527\7\24\2\2\u0527")
        buf.write("\u052a\5\u00b8]\2\u0528\u052a\7\25\2\2\u0529\u050e\3\2")
        buf.write("\2\2\u0529\u050f\3\2\2\2\u0529\u0511\3\2\2\2\u0529\u0513")
        buf.write("\3\2\2\2\u0529\u0515\3\2\2\2\u0529\u051a\3\2\2\2\u0529")
        buf.write("\u051f\3\2\2\2\u0529\u0521\3\2\2\2\u0529\u0523\3\2\2\2")
        buf.write("\u0529\u0525\3\2\2\2\u0529\u0528\3\2\2\2\u052a\u0087\3")
        buf.write("\2\2\2\u052b\u052c\7\6\2\2\u052c\u052d\5\u00acW\2\u052d")
        buf.write("\u052e\5\u00acW\2\u052e\u052f\5\u00acW\2\u052f\u0530\5")
        buf.write("\u00acW\2\u0530\u0531\5\u00acW\2\u0531\u0532\5\u00acW")
        buf.write("\2\u0532\u0533\5\u00acW\2\u0533\u0534\5\u00b4[\2\u0534")
        buf.write("\u0535\5\u00b4[\2\u0535\u0536\5\u00b4[\2\u0536\u0089\3")
        buf.write("\2\2\2\u0537\u0552\5\u0088E\2\u0538\u0539\7\13\2\2\u0539")
        buf.write("\u0552\7\u00a4\2\2\u053a\u053b\7\27\2\2\u053b\u0552\5")
        buf.write("\u00b8]\2\u053c\u053d\7*\2\2\u053d\u053e\5\u00b8]\2\u053e")
        buf.write("\u053f\5\u00b8]\2\u053f\u0540\5\u00b8]\2\u0540\u0552\3")
        buf.write("\2\2\2\u0541\u0542\7[\2\2\u0542\u0543\5\u00b8]\2\u0543")
        buf.write("\u0544\5\u00b8]\2\u0544\u0545\5\u00b8]\2\u0545\u0546\5")
        buf.write("\u00b8]\2\u0546\u0552\3\2\2\2\u0547\u0548\7+\2\2\u0548")
        buf.write("\u0552\5\u00b8]\2\u0549\u054a\7\20\2\2\u054a\u0552\7\u00a0")
        buf.write("\2\2\u054b\u054c\7\21\2\2\u054c\u0552\7\u00bd\2\2\u054d")
        buf.write("\u054e\7\23\2\2\u054e\u054f\7\24\2\2\u054f\u0552\5\u00b8")
        buf.write("]\2\u0550\u0552\7\25\2\2\u0551\u0537\3\2\2\2\u0551\u0538")
        buf.write("\3\2\2\2\u0551\u053a\3\2\2\2\u0551\u053c\3\2\2\2\u0551")
        buf.write("\u0541\3\2\2\2\u0551\u0547\3\2\2\2\u0551\u0549\3\2\2\2")
        buf.write("\u0551\u054b\3\2\2\2\u0551\u054d\3\2\2\2\u0551\u0550\3")
        buf.write("\2\2\2\u0552\u008b\3\2\2\2\u0553\u056a\5\u008eH\2\u0554")
        buf.write("\u0555\7\13\2\2\u0555\u056a\7\u00a4\2\2\u0556\u0557\7")
        buf.write("*\2\2\u0557\u0558\5\u00b8]\2\u0558\u0559\5\u00b8]\2\u0559")
        buf.write("\u055a\5\u00b8]\2\u055a\u055b\5\u00b8]\2\u055b\u055c\5")
        buf.write("\u00b8]\2\u055c\u055d\5\u00b8]\2\u055d\u055e\5\u00b8]")
        buf.write("\2\u055e\u056a\3\2\2\2\u055f\u0560\7+\2\2\u0560\u056a")
        buf.write("\5\u00b8]\2\u0561\u0562\7\20\2\2\u0562\u056a\7\u00a0\2")
        buf.write("\2\u0563\u0564\7\21\2\2\u0564\u056a\7\u00bd\2\2\u0565")
        buf.write("\u0566\7\23\2\2\u0566\u0567\7\24\2\2\u0567\u056a\5\u00b8")
        buf.write("]\2\u0568\u056a\7\25\2\2\u0569\u0553\3\2\2\2\u0569\u0554")
        buf.write("\3\2\2\2\u0569\u0556\3\2\2\2\u0569\u055f\3\2\2\2\u0569")
        buf.write("\u0561\3\2\2\2\u0569\u0563\3\2\2\2\u0569\u0565\3\2\2\2")
        buf.write("\u0569\u0568\3\2\2\2\u056a\u008d\3\2\2\2\u056b\u056c\7")
        buf.write("\6\2\2\u056c\u056d\5\u00acW\2\u056d\u056e\5\u00acW\2\u056e")
        buf.write("\u056f\5\u00acW\2\u056f\u0570\5\u00acW\2\u0570\u0571\5")
        buf.write("\u00acW\2\u0571\u0572\5\u00acW\2\u0572\u0573\5\u00acW")
        buf.write("\2\u0573\u0574\5\u00acW\2\u0574\u0575\5\u00b4[\2\u0575")
        buf.write("\u0576\5\u00b4[\2\u0576\u008f\3\2\2\2\u0577\u0597\5\u0092")
        buf.write("J\2\u0578\u0579\7\13\2\2\u0579\u0597\7\u00a4\2\2\u057a")
        buf.write("\u057b\7_\2\2\u057b\u0597\7\u00a4\2\2\u057c\u057d\7<\2")
        buf.write("\2\u057d\u057e\7\u00a0\2\2\u057e\u057f\7\u00a0\2\2\u057f")
        buf.write("\u0597\5\u00b8]\2\u0580\u0581\7L\2\2\u0581\u0597\5\u00b8")
        buf.write("]\2\u0582\u0583\7+\2\2\u0583\u0597\5\u00b8]\2\u0584\u0585")
        buf.write("\7\20\2\2\u0585\u0597\7\u00a0\2\2\u0586\u0587\7\21\2\2")
        buf.write("\u0587\u0597\7\u00bd\2\2\u0588\u0589\7\23\2\2\u0589\u058a")
        buf.write("\7\24\2\2\u058a\u058e\5\u00b8]\2\u058b\u058f\7w\2\2\u058c")
        buf.write("\u058d\7\13\2\2\u058d\u058f\7\u00a4\2\2\u058e\u058b\3")
        buf.write("\2\2\2\u058e\u058c\3\2\2\2\u058f\u0597\3\2\2\2\u0590\u0597")
        buf.write("\7\25\2\2\u0591\u0592\7=\2\2\u0592\u0593\7`\2\2\u0593")
        buf.write("\u0594\7\u00a0\2\2\u0594\u0597\7\u00a0\2\2\u0595\u0597")
        buf.write("\7>\2\2\u0596\u0577\3\2\2\2\u0596\u0578\3\2\2\2\u0596")
        buf.write("\u057a\3\2\2\2\u0596\u057c\3\2\2\2\u0596\u0580\3\2\2\2")
        buf.write("\u0596\u0582\3\2\2\2\u0596\u0584\3\2\2\2\u0596\u0586\3")
        buf.write("\2\2\2\u0596\u0588\3\2\2\2\u0596\u0590\3\2\2\2\u0596\u0591")
        buf.write("\3\2\2\2\u0596\u0595\3\2\2\2\u0597\u0091\3\2\2\2\u0598")
        buf.write("\u0599\7\6\2\2\u0599\u059a\5\u00acW\2\u059a\u059b\5\u00ac")
        buf.write("W\2\u059b\u059c\5\u00acW\2\u059c\u059d\5\u00acW\2\u059d")
        buf.write("\u059e\5\u00acW\2\u059e\u059f\5\u00acW\2\u059f\u05a0\5")
        buf.write("\u00acW\2\u05a0\u05a1\5\u00acW\2\u05a1\u05a2\5\u00acW")
        buf.write("\2\u05a2\u05a3\5\u00acW\2\u05a3\u05a5\5\u00acW\2\u05a4")
        buf.write("\u05a6\5\u00acW\2\u05a5\u05a4\3\2\2\2\u05a5\u05a6\3\2")
        buf.write("\2\2\u05a6\u0093\3\2\2\2\u05a7\u05dd\5\u0096L\2\u05a8")
        buf.write("\u05aa\7\13\2\2\u05a9\u05ab\7\u00aa\2\2\u05aa\u05a9\3")
        buf.write("\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05ac\3\2\2\2\u05ac\u05dd")
        buf.write("\7\u00a4\2\2\u05ad\u05af\7+\2\2\u05ae\u05b0\7\u00aa\2")
        buf.write("\2\u05af\u05ae\3\2\2\2\u05af\u05b0\3\2\2\2\u05b0\u05b1")
        buf.write("\3\2\2\2\u05b1\u05b2\7\u00a4\2\2\u05b2\u05dd\5\u00b8]")
        buf.write("\2\u05b3\u05b5\7\20\2\2\u05b4\u05b6\7\u00aa\2\2\u05b5")
        buf.write("\u05b4\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u05b7\3\2\2\2")
        buf.write("\u05b7\u05dd\7\u00a0\2\2\u05b8\u05ba\7\21\2\2\u05b9\u05bb")
        buf.write("\7\u00bc\2\2\u05ba\u05b9\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb")
        buf.write("\u05bc\3\2\2\2\u05bc\u05bd\7\u00be\2\2\u05bd\u05dd\7\u00bd")
        buf.write("\2\2\u05be\u05c0\7b\2\2\u05bf\u05c1\7\u00aa\2\2\u05c0")
        buf.write("\u05bf\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1\u05c2\3\2\2\2")
        buf.write("\u05c2\u05c3\7\u00a4\2\2\u05c3\u05dd\5\u00b8]\2\u05c4")
        buf.write("\u05c6\7c\2\2\u05c5\u05c7\7\u00aa\2\2\u05c6\u05c5\3\2")
        buf.write("\2\2\u05c6\u05c7\3\2\2\2\u05c7\u05c8\3\2\2\2\u05c8\u05c9")
        buf.write("\7\u00a4\2\2\u05c9\u05dd\5\u00b8]\2\u05ca\u05cc\7d\2\2")
        buf.write("\u05cb\u05cd\7\u00aa\2\2\u05cc\u05cb\3\2\2\2\u05cc\u05cd")
        buf.write("\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05cf\7\u00a4\2\2\u05cf")
        buf.write("\u05d0\5\u00b8]\2\u05d0\u05d1\5\u00b8]\2\u05d1\u05dd\3")
        buf.write("\2\2\2\u05d2\u05d3\7\23\2\2\u05d3\u05d4\7\24\2\2\u05d4")
        buf.write("\u05d8\5\u00b8]\2\u05d5\u05d9\7w\2\2\u05d6\u05d7\7\13")
        buf.write("\2\2\u05d7\u05d9\7\u00a4\2\2\u05d8\u05d5\3\2\2\2\u05d8")
        buf.write("\u05d6\3\2\2\2\u05d9\u05dd\3\2\2\2\u05da\u05dd\7\25\2")
        buf.write("\2\u05db\u05dd\7e\2\2\u05dc\u05a7\3\2\2\2\u05dc\u05a8")
        buf.write("\3\2\2\2\u05dc\u05ad\3\2\2\2\u05dc\u05b3\3\2\2\2\u05dc")
        buf.write("\u05b8\3\2\2\2\u05dc\u05be\3\2\2\2\u05dc\u05c4\3\2\2\2")
        buf.write("\u05dc\u05ca\3\2\2\2\u05dc\u05d2\3\2\2\2\u05dc\u05da\3")
        buf.write("\2\2\2\u05dc\u05db\3\2\2\2\u05dd\u0095\3\2\2\2\u05de\u05df")
        buf.write("\7\6\2\2\u05df\u05e0\5\u00acW\2\u05e0\u05e1\5\u00acW\2")
        buf.write("\u05e1\u05e2\5\u00b4[\2\u05e2\u05e3\5\u00b4[\2\u05e3\u0097")
        buf.write("\3\2\2\2\u05e4\u0609\5\u009aN\2\u05e5\u05e6\7\13\2\2\u05e6")
        buf.write("\u0609\7\u00a4\2\2\u05e7\u05e8\7g\2\2\u05e8\u0609\7\u00a0")
        buf.write("\2\2\u05e9\u05ea\7*\2\2\u05ea\u05eb\5\u00b8]\2\u05eb\u05ec")
        buf.write("\5\u00b8]\2\u05ec\u0609\3\2\2\2\u05ed\u05ee\7+\2\2\u05ee")
        buf.write("\u0609\5\u00b8]\2\u05ef\u05f0\7\20\2\2\u05f0\u0609\7\u00a0")
        buf.write("\2\2\u05f1\u05f2\7\23\2\2\u05f2\u05f3\7\24\2\2\u05f3\u05f7")
        buf.write("\5\u00b8]\2\u05f4\u05f8\7w\2\2\u05f5\u05f6\7\13\2\2\u05f6")
        buf.write("\u05f8\7\u00a4\2\2\u05f7\u05f4\3\2\2\2\u05f7\u05f5\3\2")
        buf.write("\2\2\u05f8\u0609\3\2\2\2\u05f9\u0609\7\25\2\2\u05fa\u05fb")
        buf.write("\7h\2\2\u05fb\u0609\7\u00a4\2\2\u05fc\u05fd\7i\2\2\u05fd")
        buf.write("\u05fe\5\u00b8]\2\u05fe\u05ff\7\u00a0\2\2\u05ff\u0609")
        buf.write("\3\2\2\2\u0600\u0609\7j\2\2\u0601\u0609\7k\2\2\u0602\u0609")
        buf.write("\7l\2\2\u0603\u0609\7m\2\2\u0604\u0609\7n\2\2\u0605\u0609")
        buf.write("\7o\2\2\u0606\u0607\7p\2\2\u0607\u0609\7\u00a0\2\2\u0608")
        buf.write("\u05e4\3\2\2\2\u0608\u05e5\3\2\2\2\u0608\u05e7\3\2\2\2")
        buf.write("\u0608\u05e9\3\2\2\2\u0608\u05ed\3\2\2\2\u0608\u05ef\3")
        buf.write("\2\2\2\u0608\u05f1\3\2\2\2\u0608\u05f9\3\2\2\2\u0608\u05fa")
        buf.write("\3\2\2\2\u0608\u05fc\3\2\2\2\u0608\u0600\3\2\2\2\u0608")
        buf.write("\u0601\3\2\2\2\u0608\u0602\3\2\2\2\u0608\u0603\3\2\2\2")
        buf.write("\u0608\u0604\3\2\2\2\u0608\u0605\3\2\2\2\u0608\u0606\3")
        buf.write("\2\2\2\u0609\u0099\3\2\2\2\u060a\u060b\7\6\2\2\u060b\u060c")
        buf.write("\5\u00acW\2\u060c\u060d\5\u00acW\2\u060d\u060e\5\u00ac")
        buf.write("W\2\u060e\u060f\5\u00acW\2\u060f\u0610\5\u00acW\2\u0610")
        buf.write("\u0611\5\u00b4[\2\u0611\u0612\5\u00b4[\2\u0612\u009b\3")
        buf.write("\2\2\2\u0613\u062e\5\u009eP\2\u0614\u0615\7\13\2\2\u0615")
        buf.write("\u062e\7\u00a4\2\2\u0616\u0617\7g\2\2\u0617\u062e\7\u00a0")
        buf.write("\2\2\u0618\u0619\7*\2\2\u0619\u061a\5\u00b8]\2\u061a\u061b")
        buf.write("\5\u00b8]\2\u061b\u062e\3\2\2\2\u061c\u061d\7+\2\2\u061d")
        buf.write("\u062e\5\u00b8]\2\u061e\u061f\7\20\2\2\u061f\u062e\7\u00a0")
        buf.write("\2\2\u0620\u062e\7j\2\2\u0621\u062e\7k\2\2\u0622\u062e")
        buf.write("\7i\2\2\u0623\u062e\7l\2\2\u0624\u062e\7m\2\2\u0625\u062e")
        buf.write("\7p\2\2\u0626\u0627\7\23\2\2\u0627\u062e\7\24\2\2\u0628")
        buf.write("\u062e\7\25\2\2\u0629\u062a\7h\2\2\u062a\u062e\7\u00a4")
        buf.write("\2\2\u062b\u062e\7n\2\2\u062c\u062e\7o\2\2\u062d\u0613")
        buf.write("\3\2\2\2\u062d\u0614\3\2\2\2\u062d\u0616\3\2\2\2\u062d")
        buf.write("\u0618\3\2\2\2\u062d\u061c\3\2\2\2\u062d\u061e\3\2\2\2")
        buf.write("\u062d\u0620\3\2\2\2\u062d\u0621\3\2\2\2\u062d\u0622\3")
        buf.write("\2\2\2\u062d\u0623\3\2\2\2\u062d\u0624\3\2\2\2\u062d\u0625")
        buf.write("\3\2\2\2\u062d\u0626\3\2\2\2\u062d\u0628\3\2\2\2\u062d")
        buf.write("\u0629\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062c\3\2\2\2")
        buf.write("\u062e\u009d\3\2\2\2\u062f\u0630\7\6\2\2\u0630\u0631\5")
        buf.write("\u00acW\2\u0631\u0632\5\u00acW\2\u0632\u0633\5\u00acW")
        buf.write("\2\u0633\u0634\5\u00acW\2\u0634\u0635\5\u00acW\2\u0635")
        buf.write("\u0636\5\u00acW\2\u0636\u0637\5\u00b4[\2\u0637\u0638\5")
        buf.write("\u00b4[\2\u0638\u009f\3\2\2\2\u0639\u0645\5\u00a2R\2\u063a")
        buf.write("\u063b\7\13\2\2\u063b\u0645\7\u00a4\2\2\u063c\u063d\7")
        buf.write("+\2\2\u063d\u0645\5\u00b8]\2\u063e\u063f\7\20\2\2\u063f")
        buf.write("\u0645\7\u00a0\2\2\u0640\u0641\7\23\2\2\u0641\u0642\7")
        buf.write("\24\2\2\u0642\u0645\5\u00b8]\2\u0643\u0645\7\25\2\2\u0644")
        buf.write("\u0639\3\2\2\2\u0644\u063a\3\2\2\2\u0644\u063c\3\2\2\2")
        buf.write("\u0644\u063e\3\2\2\2\u0644\u0640\3\2\2\2\u0644\u0643\3")
        buf.write("\2\2\2\u0645\u00a1\3\2\2\2\u0646\u0647\7\6\2\2\u0647\u0648")
        buf.write("\5\u00acW\2\u0648\u0649\5\u00acW\2\u0649\u064a\5\u00b4")
        buf.write("[\2\u064a\u064b\5\u00b4[\2\u064b\u064c\5\u00b4[\2\u064c")
        buf.write("\u00a3\3\2\2\2\u064d\u065f\5\u00a6T\2\u064e\u064f\7\13")
        buf.write("\2\2\u064f\u065f\7\u00a4\2\2\u0650\u0651\7t\2\2\u0651")
        buf.write("\u065f\7\u00a0\2\2\u0652\u0653\7*\2\2\u0653\u065f\5\u00b8")
        buf.write("]\2\u0654\u0655\7+\2\2\u0655\u065f\5\u00b8]\2\u0656\u0657")
        buf.write("\7\20\2\2\u0657\u065f\7\u00a0\2\2\u0658\u0659\7\23\2\2")
        buf.write("\u0659\u065a\7\24\2\2\u065a\u065f\5\u00b8]\2\u065b\u065f")
        buf.write("\7\25\2\2\u065c\u065d\7p\2\2\u065d\u065f\7\u00a0\2\2\u065e")
        buf.write("\u064d\3\2\2\2\u065e\u064e\3\2\2\2\u065e\u0650\3\2\2\2")
        buf.write("\u065e\u0652\3\2\2\2\u065e\u0654\3\2\2\2\u065e\u0656\3")
        buf.write("\2\2\2\u065e\u0658\3\2\2\2\u065e\u065b\3\2\2\2\u065e\u065c")
        buf.write("\3\2\2\2\u065f\u00a5\3\2\2\2\u0660\u0661\7\6\2\2\u0661")
        buf.write("\u0662\5\u00acW\2\u0662\u0663\5\u00acW\2\u0663\u0664\5")
        buf.write("\u00acW\2\u0664\u0665\5\u00b4[\2\u0665\u0666\5\u00b4[")
        buf.write("\2\u0666\u00a7\3\2\2\2\u0667\u0673\5\u00aaV\2\u0668\u0669")
        buf.write("\7\13\2\2\u0669\u0673\7\u00a4\2\2\u066a\u066b\7+\2\2\u066b")
        buf.write("\u0673\5\u00b8]\2\u066c\u066d\7\20\2\2\u066d\u0673\7\u00a0")
        buf.write("\2\2\u066e\u066f\7\23\2\2\u066f\u0670\7\24\2\2\u0670\u0673")
        buf.write("\5\u00b8]\2\u0671\u0673\7\25\2\2\u0672\u0667\3\2\2\2\u0672")
        buf.write("\u0668\3\2\2\2\u0672\u066a\3\2\2\2\u0672\u066c\3\2\2\2")
        buf.write("\u0672\u066e\3\2\2\2\u0672\u0671\3\2\2\2\u0673\u00a9\3")
        buf.write("\2\2\2\u0674\u0675\7\6\2\2\u0675\u0676\5\u00acW\2\u0676")
        buf.write("\u0677\5\u00acW\2\u0677\u0678\5\u00acW\2\u0678\u00ab\3")
        buf.write("\2\2\2\u0679\u067a\7\u00a7\2\2\u067a\u067b\5\u00aeX\2")
        buf.write("\u067b\u067c\7\u00a8\2\2\u067c\u00ad\3\2\2\2\u067d\u0682")
        buf.write("\5\u00b0Y\2\u067e\u067f\7\u009b\2\2\u067f\u0681\5\u00b0")
        buf.write("Y\2\u0680\u067e\3\2\2\2\u0681\u0684\3\2\2\2\u0682\u0680")
        buf.write("\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u00af\3\2\2\2\u0684")
        buf.write("\u0682\3\2\2\2\u0685\u068a\5\u00b2Z\2\u0686\u0687\7\u009c")
        buf.write("\2\2\u0687\u0689\5\u00b2Z\2\u0688\u0686\3\2\2\2\u0689")
        buf.write("\u068c\3\2\2\2\u068a\u0688\3\2\2\2\u068a\u068b\3\2\2\2")
        buf.write("\u068b\u00b1\3\2\2\2\u068c\u068a\3\2\2\2\u068d\u068e\b")
        buf.write("Z\1\2\u068e\u068f\7\u00a7\2\2\u068f\u0690\5\u00aeX\2\u0690")
        buf.write("\u0691\7\u00a8\2\2\u0691\u070d\3\2\2\2\u0692\u070d\7w")
        buf.write("\2\2\u0693\u0694\7y\2\2\u0694\u0695\t\3\2\2\u0695\u0696")
        buf.write("\t\4\2\2\u0696\u070d\t\3\2\2\u0697\u0699\7z\2\2\u0698")
        buf.write("\u069a\7\u00b5\2\2\u0699\u0698\3\2\2\2\u0699\u069a\3\2")
        buf.write("\2\2\u069a\u069b\3\2\2\2\u069b\u069c\7\u00b6\2\2\u069c")
        buf.write("\u069d\7\u00b7\2\2\u069d\u070d\5\u00b6\\\2\u069e\u069f")
        buf.write("\7{\2\2\u069f\u070d\5\u00b2Z\35\u06a0\u06a1\7|\2\2\u06a1")
        buf.write("\u070d\5\u00b2Z\34\u06a2\u06a3\7}\2\2\u06a3\u070d\5\u00b2")
        buf.write("Z\33\u06a4\u06ab\7~\2\2\u06a5\u06ac\7\u00a5\2\2\u06a6")
        buf.write("\u06a9\7\u00a4\2\2\u06a7\u06a8\7\u00a9\2\2\u06a8\u06aa")
        buf.write("\7\u00a4\2\2\u06a9\u06a7\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa")
        buf.write("\u06ac\3\2\2\2\u06ab\u06a5\3\2\2\2\u06ab\u06a6\3\2\2\2")
        buf.write("\u06ac\u070d\3\2\2\2\u06ad\u070d\7\177\2\2\u06ae\u06af")
        buf.write("\7\u0080\2\2\u06af\u070d\7\u00a0\2\2\u06b0\u070d\7\u0081")
        buf.write("\2\2\u06b1\u06b8\7\u0082\2\2\u06b2\u06b9\7\u00a5\2\2\u06b3")
        buf.write("\u06b6\7\u00a4\2\2\u06b4\u06b5\7\u00a9\2\2\u06b5\u06b7")
        buf.write("\7\u00a4\2\2\u06b6\u06b4\3\2\2\2\u06b6\u06b7\3\2\2\2\u06b7")
        buf.write("\u06b9\3\2\2\2\u06b8\u06b2\3\2\2\2\u06b8\u06b3\3\2\2\2")
        buf.write("\u06b9\u070d\3\2\2\2\u06ba\u06bb\7\u009d\2\2\u06bb\u070d")
        buf.write("\5\u00b2Z\25\u06bc\u06bd\7\u0083\2\2\u06bd\u06be\7\u00a7")
        buf.write("\2\2\u06be\u06c0\5\u00b6\\\2\u06bf\u06c1\7\u009e\2\2\u06c0")
        buf.write("\u06bf\3\2\2\2\u06c0\u06c1\3\2\2\2\u06c1\u06c2\3\2\2\2")
        buf.write("\u06c2\u06c4\5\u00b6\\\2\u06c3\u06c5\7\u009e\2\2\u06c4")
        buf.write("\u06c3\3\2\2\2\u06c4\u06c5\3\2\2\2\u06c5\u06c6\3\2\2\2")
        buf.write("\u06c6\u06c7\5\u00b6\\\2\u06c7\u06c8\7\u00a8\2\2\u06c8")
        buf.write("\u06c9\7\u0084\2\2\u06c9\u06ca\5\u00b6\\\2\u06ca\u070d")
        buf.write("\3\2\2\2\u06cb\u06cc\7\u0083\2\2\u06cc\u06cd\7\u00a7\2")
        buf.write("\2\u06cd\u06cf\7\u0099\2\2\u06ce\u06d0\7\u00aa\2\2\u06cf")
        buf.write("\u06ce\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u06d1\3\2\2\2")
        buf.write("\u06d1\u06d3\5\u00acW\2\u06d2\u06d4\7\u009e\2\2\u06d3")
        buf.write("\u06d2\3\2\2\2\u06d3\u06d4\3\2\2\2\u06d4\u06da\3\2\2\2")
        buf.write("\u06d5\u06d7\7\u009a\2\2\u06d6\u06d8\7\u00aa\2\2\u06d7")
        buf.write("\u06d6\3\2\2\2\u06d7\u06d8\3\2\2\2\u06d8\u06d9\3\2\2\2")
        buf.write("\u06d9\u06db\5\u00acW\2\u06da\u06d5\3\2\2\2\u06da\u06db")
        buf.write("\3\2\2\2\u06db\u06dc\3\2\2\2\u06dc\u06dd\7\u00a8\2\2\u06dd")
        buf.write("\u06de\7\u0084\2\2\u06de\u06df\5\u00b6\\\2\u06df\u070d")
        buf.write("\3\2\2\2\u06e0\u070d\7\u0085\2\2\u06e1\u070d\7\u0086\2")
        buf.write("\2\u06e2\u06e9\7\u0087\2\2\u06e3\u06ea\7\u00a6\2\2\u06e4")
        buf.write("\u06e7\7\u00a0\2\2\u06e5\u06e6\7\u00a9\2\2\u06e6\u06e8")
        buf.write("\7\u00a0\2\2\u06e7\u06e5\3\2\2\2\u06e7\u06e8\3\2\2\2\u06e8")
        buf.write("\u06ea\3\2\2\2\u06e9\u06e3\3\2\2\2\u06e9\u06e4\3\2\2\2")
        buf.write("\u06ea\u070d\3\2\2\2\u06eb\u06f2\7\u0088\2\2\u06ec\u06f3")
        buf.write("\7\u00a5\2\2\u06ed\u06f0\7\u00a4\2\2\u06ee\u06ef\7\u00a9")
        buf.write("\2\2\u06ef\u06f1\7\u00a4\2\2\u06f0\u06ee\3\2\2\2\u06f0")
        buf.write("\u06f1\3\2\2\2\u06f1\u06f3\3\2\2\2\u06f2\u06ec\3\2\2\2")
        buf.write("\u06f2\u06ed\3\2\2\2\u06f3\u070d\3\2\2\2\u06f4\u0700\7")
        buf.write("\u008a\2\2\u06f5\u0701\7\u00a5\2\2\u06f6\u06f9\7\u00a4")
        buf.write("\2\2\u06f7\u06f8\7\u00a9\2\2\u06f8\u06fa\7\u00a4\2\2\u06f9")
        buf.write("\u06f7\3\2\2\2\u06f9\u06fa\3\2\2\2\u06fa\u0701\3\2\2\2")
        buf.write("\u06fb\u06fe\7\u00a3\2\2\u06fc\u06fd\7\u00a9\2\2\u06fd")
        buf.write("\u06ff\7\u00a3\2\2\u06fe\u06fc\3\2\2\2\u06fe\u06ff\3\2")
        buf.write("\2\2\u06ff\u0701\3\2\2\2\u0700\u06f5\3\2\2\2\u0700\u06f6")
        buf.write("\3\2\2\2\u0700\u06fb\3\2\2\2\u0701\u070d\3\2\2\2\u0702")
        buf.write("\u070d\7\u008b\2\2\u0703\u070d\7\u008c\2\2\u0704\u070d")
        buf.write("\7\u008d\2\2\u0705\u070d\7\u008e\2\2\u0706\u070d\7\u008f")
        buf.write("\2\2\u0707\u070d\7\u0090\2\2\u0708\u070d\7\u0091\2\2\u0709")
        buf.write("\u070d\7\u0092\2\2\u070a\u070d\7\u0093\2\2\u070b\u070d")
        buf.write("\7\u0094\2\2\u070c\u068d\3\2\2\2\u070c\u0692\3\2\2\2\u070c")
        buf.write("\u0693\3\2\2\2\u070c\u0697\3\2\2\2\u070c\u069e\3\2\2\2")
        buf.write("\u070c\u06a0\3\2\2\2\u070c\u06a2\3\2\2\2\u070c\u06a4\3")
        buf.write("\2\2\2\u070c\u06ad\3\2\2\2\u070c\u06ae\3\2\2\2\u070c\u06b0")
        buf.write("\3\2\2\2\u070c\u06b1\3\2\2\2\u070c\u06ba\3\2\2\2\u070c")
        buf.write("\u06bc\3\2\2\2\u070c\u06cb\3\2\2\2\u070c\u06e0\3\2\2\2")
        buf.write("\u070c\u06e1\3\2\2\2\u070c\u06e2\3\2\2\2\u070c\u06eb\3")
        buf.write("\2\2\2\u070c\u06f4\3\2\2\2\u070c\u0702\3\2\2\2\u070c\u0703")
        buf.write("\3\2\2\2\u070c\u0704\3\2\2\2\u070c\u0705\3\2\2\2\u070c")
        buf.write("\u0706\3\2\2\2\u070c\u0707\3\2\2\2\u070c\u0708\3\2\2\2")
        buf.write("\u070c\u0709\3\2\2\2\u070c\u070a\3\2\2\2\u070c\u070b\3")
        buf.write("\2\2\2\u070d\u0716\3\2\2\2\u070e\u070f\f \2\2\u070f\u0710")
        buf.write("\7x\2\2\u0710\u0715\5\u00b6\\\2\u0711\u0712\f\16\2\2\u0712")
        buf.write("\u0713\7\u0089\2\2\u0713\u0715\5\u00b6\\\2\u0714\u070e")
        buf.write("\3\2\2\2\u0714\u0711\3\2\2\2\u0715\u0718\3\2\2\2\u0716")
        buf.write("\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717\u00b3\3\2\2\2")
        buf.write("\u0718\u0716\3\2\2\2\u0719\u071a\t\5\2\2\u071a\u00b5\3")
        buf.write("\2\2\2\u071b\u071c\t\5\2\2\u071c\u00b7\3\2\2\2\u071d\u071e")
        buf.write("\t\5\2\2\u071e\u00b9\3\2\2\2\u071f\u0720\t\5\2\2\u0720")
        buf.write("\u00bb\3\2\2\2\u0721\u072c\7v\2\2\u0722\u072a\7\u00c6")
        buf.write("\2\2\u0723\u0725\7\u00c9\2\2\u0724\u0723\3\2\2\2\u0725")
        buf.write("\u0728\3\2\2\2\u0726\u0724\3\2\2\2\u0726\u0727\3\2\2\2")
        buf.write("\u0727\u072b\3\2\2\2\u0728\u0726\3\2\2\2\u0729\u072b\7")
        buf.write("\u00ca\2\2\u072a\u0726\3\2\2\2\u072a\u0729\3\2\2\2\u072b")
        buf.write("\u072d\3\2\2\2\u072c\u0722\3\2\2\2\u072c\u072d\3\2\2\2")
        buf.write("\u072d\u072e\3\2\2\2\u072e\u0732\7\u00c7\2\2\u072f\u0731")
        buf.write("\7\u00c9\2\2\u0730\u072f\3\2\2\2\u0731\u0734\3\2\2\2\u0732")
        buf.write("\u0730\3\2\2\2\u0732\u0733\3\2\2\2\u0733\u0735\3\2\2\2")
        buf.write("\u0734\u0732\3\2\2\2\u0735\u0736\7\u00c8\2\2\u0736\u00bd")
        buf.write("\3\2\2\2\u0737\u0738\7\u0095\2\2\u0738\u0739\5\u00c0a")
        buf.write("\2\u0739\u073a\5\u00acW\2\u073a\u00bf\3\2\2\2\u073b\u073c")
        buf.write("\t\6\2\2\u073c\u073d\5\u00c2b\2\u073d\u073e\7\u00cc\2")
        buf.write("\2\u073e\u0742\3\2\2\2\u073f\u0740\7\u0098\2\2\u0740\u0742")
        buf.write("\5\u00caf\2\u0741\u073b\3\2\2\2\u0741\u073f\3\2\2\2\u0742")
        buf.write("\u00c1\3\2\2\2\u0743\u0746\7\u00d6\2\2\u0744\u0745\7\u00cd")
        buf.write("\2\2\u0745\u0747\5\u00c4c\2\u0746\u0744\3\2\2\2\u0746")
        buf.write("\u0747\3\2\2\2\u0747\u00c3\3\2\2\2\u0748\u074d\5\u00c6")
        buf.write("d\2\u0749\u074a\t\7\2\2\u074a\u074c\5\u00c4c\2\u074b\u0749")
        buf.write("\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074d")
        buf.write("\u074e\3\2\2\2\u074e\u00c5\3\2\2\2\u074f\u074d\3\2\2\2")
        buf.write("\u0750\u0757\7\u00d6\2\2\u0751\u0757\5\u00c8e\2\u0752")
        buf.write("\u0757\7\u00d4\2\2\u0753\u0757\7\u00d5\2\2\u0754\u0757")
        buf.write("\7\u00ed\2\2\u0755\u0757\7\u00ee\2\2\u0756\u0750\3\2\2")
        buf.write("\2\u0756\u0751\3\2\2\2\u0756\u0752\3\2\2\2\u0756\u0753")
        buf.write("\3\2\2\2\u0756\u0754\3\2\2\2\u0756\u0755\3\2\2\2\u0757")
        buf.write("\u00c7\3\2\2\2\u0758\u0759\7\u00d7\2\2\u0759\u075a\7\u00ef")
        buf.write("\2\2\u075a\u075b\5\u00c6d\2\u075b\u075c\7\u00cc\2\2\u075c")
        buf.write("\u07d0\3\2\2\2\u075d\u075e\7\u00d8\2\2\u075e\u075f\7\u00ef")
        buf.write("\2\2\u075f\u0760\5\u00c6d\2\u0760\u0761\7\u00cc\2\2\u0761")
        buf.write("\u07d0\3\2\2\2\u0762\u0763\7\u00da\2\2\u0763\u0764\7\u00ef")
        buf.write("\2\2\u0764\u0765\5\u00c6d\2\u0765\u0766\7\u00cc\2\2\u0766")
        buf.write("\u07d0\3\2\2\2\u0767\u0768\7\u00db\2\2\u0768\u0769\7\u00ef")
        buf.write("\2\2\u0769\u076a\5\u00c6d\2\u076a\u076b\7\u00cc\2\2\u076b")
        buf.write("\u07d0\3\2\2\2\u076c\u076d\7\u00dc\2\2\u076d\u076e\7\u00ef")
        buf.write("\2\2\u076e\u076f\5\u00c6d\2\u076f\u0770\7\u00cc\2\2\u0770")
        buf.write("\u07d0\3\2\2\2\u0771\u0772\7\u00dd\2\2\u0772\u0773\7\u00ef")
        buf.write("\2\2\u0773\u0774\5\u00c6d\2\u0774\u0775\7\u00cc\2\2\u0775")
        buf.write("\u07d0\3\2\2\2\u0776\u0777\7\u00de\2\2\u0777\u0778\7\u00ef")
        buf.write("\2\2\u0778\u0779\5\u00c6d\2\u0779\u077a\7\u00cc\2\2\u077a")
        buf.write("\u07d0\3\2\2\2\u077b\u077c\7\u00df\2\2\u077c\u077d\7\u00ef")
        buf.write("\2\2\u077d\u077e\5\u00c6d\2\u077e\u077f\7\u00cc\2\2\u077f")
        buf.write("\u07d0\3\2\2\2\u0780\u0781\7\u00e0\2\2\u0781\u0782\7\u00ef")
        buf.write("\2\2\u0782\u0783\5\u00c6d\2\u0783\u0784\7\u00cc\2\2\u0784")
        buf.write("\u07d0\3\2\2\2\u0785\u0786\7\u00e1\2\2\u0786\u0787\7\u00ef")
        buf.write("\2\2\u0787\u0788\5\u00c6d\2\u0788\u0789\7\u00cc\2\2\u0789")
        buf.write("\u07d0\3\2\2\2\u078a\u078b\7\u00e2\2\2\u078b\u078c\7\u00ef")
        buf.write("\2\2\u078c\u078d\5\u00c6d\2\u078d\u078e\7\u00cc\2\2\u078e")
        buf.write("\u07d0\3\2\2\2\u078f\u0790\7\u00e3\2\2\u0790\u0791\7\u00ef")
        buf.write("\2\2\u0791\u0796\5\u00c6d\2\u0792\u0793\7\u00d3\2\2\u0793")
        buf.write("\u0795\5\u00c6d\2\u0794\u0792\3\2\2\2\u0795\u0798\3\2")
        buf.write("\2\2\u0796\u0794\3\2\2\2\u0796\u0797\3\2\2\2\u0797\u0799")
        buf.write("\3\2\2\2\u0798\u0796\3\2\2\2\u0799\u079a\7\u00cc\2\2\u079a")
        buf.write("\u07d0\3\2\2\2\u079b\u079c\7\u00e4\2\2\u079c\u079d\7\u00ef")
        buf.write("\2\2\u079d\u079e\5\u00c6d\2\u079e\u079f\7\u00cc\2\2\u079f")
        buf.write("\u07d0\3\2\2\2\u07a0\u07a1\7\u00e5\2\2\u07a1\u07a2\7\u00ef")
        buf.write("\2\2\u07a2\u07a7\5\u00c6d\2\u07a3\u07a4\7\u00d3\2\2\u07a4")
        buf.write("\u07a6\5\u00c6d\2\u07a5\u07a3\3\2\2\2\u07a6\u07a9\3\2")
        buf.write("\2\2\u07a7\u07a5\3\2\2\2\u07a7\u07a8\3\2\2\2\u07a8\u07aa")
        buf.write("\3\2\2\2\u07a9\u07a7\3\2\2\2\u07aa\u07ab\7\u00cc\2\2\u07ab")
        buf.write("\u07d0\3\2\2\2\u07ac\u07ad\7\u00e6\2\2\u07ad\u07ae\7\u00ef")
        buf.write("\2\2\u07ae\u07af\5\u00c6d\2\u07af\u07b0\7\u00d3\2\2\u07b0")
        buf.write("\u07b1\5\u00c6d\2\u07b1\u07b2\7\u00cc\2\2\u07b2\u07d0")
        buf.write("\3\2\2\2\u07b3\u07b4\7\u00e7\2\2\u07b4\u07b5\7\u00ef\2")
        buf.write("\2\u07b5\u07b6\5\u00c6d\2\u07b6\u07b7\7\u00cc\2\2\u07b7")
        buf.write("\u07d0\3\2\2\2\u07b8\u07b9\7\u00e8\2\2\u07b9\u07ba\7\u00ef")
        buf.write("\2\2\u07ba\u07d0\7\u00cc\2\2\u07bb\u07bc\7\u00e9\2\2\u07bc")
        buf.write("\u07bd\7\u00ef\2\2\u07bd\u07be\5\u00c6d\2\u07be\u07bf")
        buf.write("\7\u00cc\2\2\u07bf\u07d0\3\2\2\2\u07c0\u07c1\7\u00ea\2")
        buf.write("\2\u07c1\u07c2\7\u00ef\2\2\u07c2\u07c3\5\u00c6d\2\u07c3")
        buf.write("\u07c4\7\u00cc\2\2\u07c4\u07d0\3\2\2\2\u07c5\u07c6\7\u00eb")
        buf.write("\2\2\u07c6\u07c7\7\u00ef\2\2\u07c7\u07c8\5\u00c6d\2\u07c8")
        buf.write("\u07c9\7\u00cc\2\2\u07c9\u07d0\3\2\2\2\u07ca\u07cb\7\u00ec")
        buf.write("\2\2\u07cb\u07cc\7\u00ef\2\2\u07cc\u07cd\5\u00c6d\2\u07cd")
        buf.write("\u07ce\7\u00cc\2\2\u07ce\u07d0\3\2\2\2\u07cf\u0758\3\2")
        buf.write("\2\2\u07cf\u075d\3\2\2\2\u07cf\u0762\3\2\2\2\u07cf\u0767")
        buf.write("\3\2\2\2\u07cf\u076c\3\2\2\2\u07cf\u0771\3\2\2\2\u07cf")
        buf.write("\u0776\3\2\2\2\u07cf\u077b\3\2\2\2\u07cf\u0780\3\2\2\2")
        buf.write("\u07cf\u0785\3\2\2\2\u07cf\u078a\3\2\2\2\u07cf\u078f\3")
        buf.write("\2\2\2\u07cf\u079b\3\2\2\2\u07cf\u07a0\3\2\2\2\u07cf\u07ac")
        buf.write("\3\2\2\2\u07cf\u07b3\3\2\2\2\u07cf\u07b8\3\2\2\2\u07cf")
        buf.write("\u07bb\3\2\2\2\u07cf\u07c0\3\2\2\2\u07cf\u07c5\3\2\2\2")
        buf.write("\u07cf\u07ca\3\2\2\2\u07d0\u00c9\3\2\2\2\u07d1\u07d2\t")
        buf.write("\b\2\2\u07d2\u07d3\7\u00f0\2\2\u07d3\u07d4\7\u00f9\2\2")
        buf.write("\u07d4\u07d5\7\u00f1\2\2\u07d5\u00cb\3\2\2\2\u00a0\u00ef")
        buf.write("\u00f1\u00fa\u0100\u0106\u010f\u0117\u011f\u0127\u012f")
        buf.write("\u0133\u0136\u013c\u0145\u014e\u0157\u0160\u0169\u0172")
        buf.write("\u017b\u0184\u018d\u0196\u019f\u01a8\u01b1\u01ba\u01c3")
        buf.write("\u01cc\u01d5\u01de\u01ef\u0202\u020f\u0227\u022a\u0235")
        buf.write("\u023e\u0243\u0248\u024f\u0253\u0258\u025d\u0262\u0267")
        buf.write("\u026c\u0271\u0274\u0279\u027f\u029d\u02a9\u02c5\u02d6")
        buf.write("\u02db\u02e8\u02ef\u0308\u0325\u0333\u0338\u033c\u0341")
        buf.write("\u0344\u0356\u035e\u036f\u0377\u037d\u0388\u038b\u0397")
        buf.write("\u039e\u03ba\u03dc\u03e6\u03eb\u03f0\u03f4\u0400\u0418")
        buf.write("\u042c\u0432\u0438\u0444\u044a\u0450\u0458\u0462\u0468")
        buf.write("\u046e\u0479\u047c\u047f\u0483\u048f\u0496\u049d\u04a4")
        buf.write("\u04c1\u04f3\u0506\u0529\u0551\u0569\u058e\u0596\u05a5")
        buf.write("\u05aa\u05af\u05b5\u05ba\u05c0\u05c6\u05cc\u05d8\u05dc")
        buf.write("\u05f7\u0608\u062d\u0644\u065e\u0672\u0682\u068a\u0699")
        buf.write("\u06a9\u06ab\u06b6\u06b8\u06c0\u06c4\u06cf\u06d3\u06d7")
        buf.write("\u06da\u06e7\u06e9\u06f0\u06f2\u06f9\u06fe\u0700\u070c")
        buf.write("\u0714\u0716\u0726\u072a\u072c\u0732\u0741\u0746\u074d")
        buf.write("\u0756\u0796\u07a7\u07cf")
        return buf.getvalue()


class XplorMRParser ( Parser ):

    grammarFileName = "XplorMRParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "':'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'<'", "'>'", "'<='", "'>='", "'#'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'+'", "'-'", "<INVALID>", "'/'" ]

    symbolicNames = [ "<INVALID>", "Set", "End", "Noe", "Assign", "Asymptote", 
                      "Averaging", "Bhig", "Ceiling", "Classification", 
                      "CountViol", "Distribute", "Monomers", "Ncount", "Nrestraints", 
                      "Potential", "Predict", "Print", "Threshold", "Reset", 
                      "Rswitch", "Scale", "SoExponent", "SqConstant", "SqExponent", 
                      "SqOffset", "Temperature", "Cutoff", "Cuton", "From", 
                      "To", "Peak", "Spectrum", "Volume", "Ppm1", "Ppm2", 
                      "Restraints", "Dihedral", "Nassign", "Sanisotropy", 
                      "Coefficients", "ForceConstant", "Xdipolar", "Dipolar", 
                      "Type", "Sign", "Average", "VectorAngle", "Cv", "Partition", 
                      "Tensor", "Anisotropy", "Planar", "Group", "Initialize", 
                      "Selection", "Weight", "Xadc", "Expectation", "Size", 
                      "Zero", "Coupling", "DegEnergy", "Carbon", "PhiStep", 
                      "PsiStep", "Rcoil", "Proton", "Observed", "Amides", 
                      "Nitrogens", "Oxygens", "RingAtoms", "AlphasAndAmides", 
                      "Error", "Ramachandran", "Gaussian", "Phase", "Quartic", 
                      "Shape", "Sort", "Dimensions", "Collapse", "Danisotropy", 
                      "Orient", "Height", "MaxGaussians", "NewGaussian", 
                      "Dcsa", "Sigma", "Pcsa", "OneBond", "AngleDb", "DerivFlag", 
                      "Angle_or_Dihedral", "Paramagnetic", "Kconst", "Omega", 
                      "Tauc", "Debug", "Xpcs", "Tolerance", "Save", "Fmed", 
                      "ErrOn", "ErrOff", "Fon", "Foff", "Son", "Soff", "Frun", 
                      "Xrdcoupling", "Xangle", "Xccr", "Weip", "Hbda", "Flags", 
                      "All", "Around", "Atom", "Attribute", "BondedTo", 
                      "ByGroup", "ByRes", "Chemical", "Hydrogen", "Id", 
                      "Known", "Name", "Point", "Cut", "Previous", "Pseudo", 
                      "Residue", "Resname", "Saround", "SegIdentifier", 
                      "Store_1", "Store_2", "Store_3", "Store_4", "Store_5", 
                      "Store_6", "Store_7", "Store_8", "Store_9", "Tag", 
                      "Vector", "Do_Lp", "Identify_Lp", "Show", "Tail", 
                      "Head", "Or_op", "And_op", "Not_op", "Comma", "Complex", 
                      "Integer", "Logical", "Real", "Double_quote_string", 
                      "Simple_name", "Simple_names", "Integers", "L_paren", 
                      "R_paren", "Colon", "Equ_op", "SPACE", "COMMENT", 
                      "SECTION_COMMENT", "LINE_COMMENT", "SET_VARIABLE", 
                      "Lt_op", "Gt_op", "Leq_op", "Geq_op", "Neq_op", "Abs", 
                      "Attr_properties", "Comparison_ops", "SPACE_ATTR", 
                      "Averaging_methods", "Simple_name_A", "SPACE_AVER", 
                      "Equ_op_P", "Potential_types", "Simple_name_P", "SPACE_POTE", 
                      "Rdc_dist_fix_types", "Rdc_or_Diff_anis_types", "Csa_types", 
                      "SPACE_TYPE", "Gauss_or_Quart", "SPACE_SHAP", "Exclude", 
                      "Include", "End_F", "Class_name", "Any_class", "SPACE_FLAG", 
                      "R_paren_VE", "Equ_op_VE", "Add_op_VE", "Sub_op_VE", 
                      "Mul_op_VE", "Div_op_VE", "Exp_op_VE", "Comma_VE", 
                      "Integer_VE", "Real_VE", "Atom_properties_VE", "Abs_VE", 
                      "Acos_VE", "Asin_VE", "Cos_VE", "Decode_VE", "Encode_VE", 
                      "Exp_VE", "Gauss_VE", "Heavy_VE", "Int_VE", "Log10_VE", 
                      "Log_VE", "Max_VE", "Maxw_VE", "Min_VE", "Mod_VE", 
                      "Norm_VE", "Random_VE", "Sign_VE", "Sin_VE", "Sqrt_VE", 
                      "Tan_VE", "Simple_name_VE", "Double_quote_string_VE", 
                      "L_paren_VF", "L_paren_VS", "R_paren_VS", "Average_VS", 
                      "Element_VS", "Max_VS", "Min_VS", "Norm_VS", "Rms_VS", 
                      "Sum_VS", "Atom_properties_VS", "SPACE_VS" ]

    RULE_xplor_nih_mr = 0
    RULE_distance_restraint = 1
    RULE_dihedral_angle_restraint = 2
    RULE_rdc_restraint = 3
    RULE_planar_restraint = 4
    RULE_antidistance_restraint = 5
    RULE_coupling_restraint = 6
    RULE_carbon_shift_restraint = 7
    RULE_proton_shift_restraint = 8
    RULE_dihedral_angle_db_restraint = 9
    RULE_radius_of_gyration_restraint = 10
    RULE_diffusion_anisotropy_restraint = 11
    RULE_orientation_db_restraint = 12
    RULE_csa_restraint = 13
    RULE_pcsa_restraint = 14
    RULE_one_bond_coupling_restraint = 15
    RULE_angle_db_restraint = 16
    RULE_pre_restraint = 17
    RULE_pcs_restraint = 18
    RULE_prdc_restraint = 19
    RULE_porientation_restraint = 20
    RULE_pccr_restraint = 21
    RULE_hbond_restraint = 22
    RULE_noe_statement = 23
    RULE_noe_assign = 24
    RULE_predict_statement = 25
    RULE_noe_annotation = 26
    RULE_dihedral_statement = 27
    RULE_dihedral_assign = 28
    RULE_sani_statement = 29
    RULE_sani_assign = 30
    RULE_xdip_statement = 31
    RULE_xdip_assign = 32
    RULE_vean_statement = 33
    RULE_vean_assign = 34
    RULE_tenso_statement = 35
    RULE_tenso_assign = 36
    RULE_anis_statement = 37
    RULE_anis_assign = 38
    RULE_planar_statement = 39
    RULE_group_statement = 40
    RULE_antidistance_statement = 41
    RULE_xadc_assign = 42
    RULE_coupling_statement = 43
    RULE_coup_assign = 44
    RULE_carbon_shift_statement = 45
    RULE_carbon_shift_assign = 46
    RULE_carbon_shift_rcoil = 47
    RULE_proton_shift_statement = 48
    RULE_observed = 49
    RULE_proton_shift_rcoil = 50
    RULE_proton_shift_anisotropy = 51
    RULE_proton_shift_amides = 52
    RULE_proton_shift_carbons = 53
    RULE_proton_shift_nitrogens = 54
    RULE_proton_shift_oxygens = 55
    RULE_proton_shift_ring_atoms = 56
    RULE_proton_shift_alphas_and_amides = 57
    RULE_ramachandran_statement = 58
    RULE_rama_assign = 59
    RULE_collapse_statement = 60
    RULE_coll_assign = 61
    RULE_diffusion_statement = 62
    RULE_dani_assign = 63
    RULE_orientation_statement = 64
    RULE_orie_assign = 65
    RULE_csa_statement = 66
    RULE_csa_assign = 67
    RULE_pcsa_statement = 68
    RULE_one_bond_coupling_statement = 69
    RULE_one_bond_assign = 70
    RULE_angle_db_statement = 71
    RULE_angle_db_assign = 72
    RULE_pre_statement = 73
    RULE_pre_assign = 74
    RULE_pcs_statement = 75
    RULE_pcs_assign = 76
    RULE_prdc_statement = 77
    RULE_prdc_assign = 78
    RULE_porientation_statement = 79
    RULE_porientation_assign = 80
    RULE_pccr_statement = 81
    RULE_pccr_assign = 82
    RULE_hbond_statement = 83
    RULE_hbond_assign = 84
    RULE_selection = 85
    RULE_selection_expression = 86
    RULE_term = 87
    RULE_factor = 88
    RULE_number = 89
    RULE_number_f = 90
    RULE_number_s = 91
    RULE_number_a = 92
    RULE_flag_statement = 93
    RULE_vector_statement = 94
    RULE_vector_mode = 95
    RULE_vector_expression = 96
    RULE_vector_operation = 97
    RULE_vflc = 98
    RULE_vector_func_call = 99
    RULE_vector_show_property = 100

    ruleNames =  [ "xplor_nih_mr", "distance_restraint", "dihedral_angle_restraint", 
                   "rdc_restraint", "planar_restraint", "antidistance_restraint", 
                   "coupling_restraint", "carbon_shift_restraint", "proton_shift_restraint", 
                   "dihedral_angle_db_restraint", "radius_of_gyration_restraint", 
                   "diffusion_anisotropy_restraint", "orientation_db_restraint", 
                   "csa_restraint", "pcsa_restraint", "one_bond_coupling_restraint", 
                   "angle_db_restraint", "pre_restraint", "pcs_restraint", 
                   "prdc_restraint", "porientation_restraint", "pccr_restraint", 
                   "hbond_restraint", "noe_statement", "noe_assign", "predict_statement", 
                   "noe_annotation", "dihedral_statement", "dihedral_assign", 
                   "sani_statement", "sani_assign", "xdip_statement", "xdip_assign", 
                   "vean_statement", "vean_assign", "tenso_statement", "tenso_assign", 
                   "anis_statement", "anis_assign", "planar_statement", 
                   "group_statement", "antidistance_statement", "xadc_assign", 
                   "coupling_statement", "coup_assign", "carbon_shift_statement", 
                   "carbon_shift_assign", "carbon_shift_rcoil", "proton_shift_statement", 
                   "observed", "proton_shift_rcoil", "proton_shift_anisotropy", 
                   "proton_shift_amides", "proton_shift_carbons", "proton_shift_nitrogens", 
                   "proton_shift_oxygens", "proton_shift_ring_atoms", "proton_shift_alphas_and_amides", 
                   "ramachandran_statement", "rama_assign", "collapse_statement", 
                   "coll_assign", "diffusion_statement", "dani_assign", 
                   "orientation_statement", "orie_assign", "csa_statement", 
                   "csa_assign", "pcsa_statement", "one_bond_coupling_statement", 
                   "one_bond_assign", "angle_db_statement", "angle_db_assign", 
                   "pre_statement", "pre_assign", "pcs_statement", "pcs_assign", 
                   "prdc_statement", "prdc_assign", "porientation_statement", 
                   "porientation_assign", "pccr_statement", "pccr_assign", 
                   "hbond_statement", "hbond_assign", "selection", "selection_expression", 
                   "term", "factor", "number", "number_f", "number_s", "number_a", 
                   "flag_statement", "vector_statement", "vector_mode", 
                   "vector_expression", "vector_operation", "vflc", "vector_func_call", 
                   "vector_show_property" ]

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

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




    class Xplor_nih_mrContext(ParserRuleContext):

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

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_xplor_nih_mr

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

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




    def xplor_nih_mr(self):

        localctx = XplorMRParser.Xplor_nih_mrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_xplor_nih_mr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Noe) | (1 << XplorMRParser.Assign) | (1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Dihedral) | (1 << XplorMRParser.Sanisotropy) | (1 << XplorMRParser.Xdipolar) | (1 << XplorMRParser.Dipolar) | (1 << XplorMRParser.VectorAngle) | (1 << XplorMRParser.Tensor) | (1 << XplorMRParser.Anisotropy) | (1 << XplorMRParser.Planar) | (1 << XplorMRParser.Group) | (1 << XplorMRParser.Initialize) | (1 << XplorMRParser.Xadc) | (1 << XplorMRParser.Coupling) | (1 << XplorMRParser.Carbon))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (XplorMRParser.Proton - 67)) | (1 << (XplorMRParser.Ramachandran - 67)) | (1 << (XplorMRParser.Collapse - 67)) | (1 << (XplorMRParser.Danisotropy - 67)) | (1 << (XplorMRParser.Orient - 67)) | (1 << (XplorMRParser.Dcsa - 67)) | (1 << (XplorMRParser.Pcsa - 67)) | (1 << (XplorMRParser.OneBond - 67)) | (1 << (XplorMRParser.AngleDb - 67)) | (1 << (XplorMRParser.Paramagnetic - 67)) | (1 << (XplorMRParser.Xpcs - 67)) | (1 << (XplorMRParser.Xrdcoupling - 67)) | (1 << (XplorMRParser.Xangle - 67)) | (1 << (XplorMRParser.Xccr - 67)) | (1 << (XplorMRParser.Hbda - 67)) | (1 << (XplorMRParser.Flags - 67)))) != 0) or _la==XplorMRParser.Vector:
                self.state = 237
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 202
                    self.distance_restraint()
                    pass

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

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

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

                elif la_ == 5:
                    self.state = 206
                    self.antidistance_restraint()
                    pass

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

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

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

                elif la_ == 9:
                    self.state = 210
                    self.dihedral_angle_db_restraint()
                    pass

                elif la_ == 10:
                    self.state = 211
                    self.radius_of_gyration_restraint()
                    pass

                elif la_ == 11:
                    self.state = 212
                    self.diffusion_anisotropy_restraint()
                    pass

                elif la_ == 12:
                    self.state = 213
                    self.orientation_db_restraint()
                    pass

                elif la_ == 13:
                    self.state = 214
                    self.csa_restraint()
                    pass

                elif la_ == 14:
                    self.state = 215
                    self.pcsa_restraint()
                    pass

                elif la_ == 15:
                    self.state = 216
                    self.one_bond_coupling_restraint()
                    pass

                elif la_ == 16:
                    self.state = 217
                    self.angle_db_restraint()
                    pass

                elif la_ == 17:
                    self.state = 218
                    self.pre_restraint()
                    pass

                elif la_ == 18:
                    self.state = 219
                    self.pcs_restraint()
                    pass

                elif la_ == 19:
                    self.state = 220
                    self.prdc_restraint()
                    pass

                elif la_ == 20:
                    self.state = 221
                    self.porientation_restraint()
                    pass

                elif la_ == 21:
                    self.state = 222
                    self.pccr_restraint()
                    pass

                elif la_ == 22:
                    self.state = 223
                    self.hbond_restraint()
                    pass

                elif la_ == 23:
                    self.state = 224
                    self.flag_statement()
                    pass

                elif la_ == 24:
                    self.state = 225
                    self.vector_statement()
                    pass

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

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

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

                elif la_ == 28:
                    self.state = 229
                    self.planar_statement()
                    pass

                elif la_ == 29:
                    self.state = 230
                    self.hbond_assign()
                    pass

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

                elif la_ == 31:
                    self.state = 232
                    self.xadc_assign()
                    pass

                elif la_ == 32:
                    self.state = 233
                    self.coll_assign()
                    pass

                elif la_ == 33:
                    self.state = 234
                    self.csa_assign()
                    pass

                elif la_ == 34:
                    self.state = 235
                    self.pre_assign()
                    pass

                elif la_ == 35:
                    self.state = 236
                    self.pcs_assign()
                    pass


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

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


    class Distance_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_distance_restraint

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

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




    def distance_restraint(self):

        localctx = XplorMRParser.Distance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_distance_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 244
            self.match(XplorMRParser.Noe)
            self.state = 248
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Asymptote) | (1 << XplorMRParser.Averaging) | (1 << XplorMRParser.Bhig) | (1 << XplorMRParser.Ceiling) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.CountViol) | (1 << XplorMRParser.Distribute) | (1 << XplorMRParser.Monomers) | (1 << XplorMRParser.Ncount) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Predict) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Rswitch) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.SoExponent) | (1 << XplorMRParser.SqConstant) | (1 << XplorMRParser.SqExponent) | (1 << XplorMRParser.SqOffset) | (1 << XplorMRParser.Temperature))) != 0):
                self.state = 245
                self.noe_statement()
                self.state = 250
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Dihedral_angle_restraintContext(ParserRuleContext):

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

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_angle_restraint

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

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




    def dihedral_angle_restraint(self):

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


            self.state = 256
            self.match(XplorMRParser.Dihedral)
            self.state = 260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Nassign))) != 0):
                self.state = 257
                self.dihedral_statement()
                self.state = 262
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Rdc_restraintContext(ParserRuleContext):

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

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

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

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


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

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

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


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

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


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

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


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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_rdc_restraint

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

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




    def rdc_restraint(self):

        localctx = XplorMRParser.Rdc_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_rdc_restraint)
        self._la = 0 # Token type
        try:
            self.state = 305
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Sanisotropy]:
                self.enterOuterAlt(localctx, 1)
                self.state = 265
                self.match(XplorMRParser.Sanisotropy)
                self.state = 269
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0):
                    self.state = 266
                    self.sani_statement()
                    self.state = 271
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 272
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Xdipolar, XplorMRParser.Dipolar]:
                self.enterOuterAlt(localctx, 2)
                self.state = 273
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Xdipolar or _la==XplorMRParser.Dipolar):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type) | (1 << XplorMRParser.Sign) | (1 << XplorMRParser.Average))) != 0):
                    self.state = 274
                    self.xdip_statement()
                    self.state = 279
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 280
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.VectorAngle]:
                self.enterOuterAlt(localctx, 3)
                self.state = 281
                self.match(XplorMRParser.VectorAngle)
                self.state = 285
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Cv) | (1 << XplorMRParser.Partition))) != 0):
                    self.state = 282
                    self.vean_statement()
                    self.state = 287
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 288
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Tensor]:
                self.enterOuterAlt(localctx, 4)
                self.state = 289
                self.match(XplorMRParser.Tensor)
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients))) != 0):
                    self.state = 290
                    self.tenso_statement()
                    self.state = 295
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 296
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Anisotropy]:
                self.enterOuterAlt(localctx, 5)
                self.state = 297
                self.match(XplorMRParser.Anisotropy)
                self.state = 301
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type))) != 0):
                    self.state = 298
                    self.anis_statement()
                    self.state = 303
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 304
                self.match(XplorMRParser.End)
                pass
            else:
                raise NoViableAltException(self)

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


    class Planar_restraintContext(ParserRuleContext):

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

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_restraint

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

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




    def planar_restraint(self):

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


            self.state = 310
            self.match(XplorMRParser.Planar)
            self.state = 314
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Group or _la==XplorMRParser.Initialize:
                self.state = 311
                self.planar_statement()
                self.state = 316
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Antidistance_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_antidistance_restraint

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

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




    def antidistance_restraint(self):

        localctx = XplorMRParser.Antidistance_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_antidistance_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.match(XplorMRParser.Xadc)
            self.state = 323
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Expectation) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0):
                self.state = 320
                self.antidistance_statement()
                self.state = 325
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Coupling_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_coupling_restraint

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

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




    def coupling_restraint(self):

        localctx = XplorMRParser.Coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_coupling_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 328
            self.match(XplorMRParser.Coupling)
            self.state = 332
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Cv) | (1 << XplorMRParser.Partition) | (1 << XplorMRParser.DegEnergy))) != 0):
                self.state = 329
                self.coupling_statement()
                self.state = 334
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Carbon_shift_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_restraint

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

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




    def carbon_shift_restraint(self):

        localctx = XplorMRParser.Carbon_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_carbon_shift_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337
            self.match(XplorMRParser.Carbon)
            self.state = 341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 4)) & ~0x3f) == 0 and ((1 << (_la - 4)) & ((1 << (XplorMRParser.Assign - 4)) | (1 << (XplorMRParser.Classification - 4)) | (1 << (XplorMRParser.Nrestraints - 4)) | (1 << (XplorMRParser.Potential - 4)) | (1 << (XplorMRParser.Print - 4)) | (1 << (XplorMRParser.Reset - 4)) | (1 << (XplorMRParser.ForceConstant - 4)) | (1 << (XplorMRParser.Expectation - 4)) | (1 << (XplorMRParser.Zero - 4)) | (1 << (XplorMRParser.PhiStep - 4)) | (1 << (XplorMRParser.PsiStep - 4)) | (1 << (XplorMRParser.Rcoil - 4)))) != 0):
                self.state = 338
                self.carbon_shift_statement()
                self.state = 343
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Proton_shift_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_restraint

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

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




    def proton_shift_restraint(self):

        localctx = XplorMRParser.Proton_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_proton_shift_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 346
            self.match(XplorMRParser.Proton)
            self.state = 350
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Classification) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Anisotropy) | (1 << XplorMRParser.DegEnergy) | (1 << XplorMRParser.Carbon))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (XplorMRParser.Rcoil - 66)) | (1 << (XplorMRParser.Observed - 66)) | (1 << (XplorMRParser.Amides - 66)) | (1 << (XplorMRParser.Nitrogens - 66)) | (1 << (XplorMRParser.Oxygens - 66)) | (1 << (XplorMRParser.RingAtoms - 66)) | (1 << (XplorMRParser.AlphasAndAmides - 66)) | (1 << (XplorMRParser.Error - 66)))) != 0):
                self.state = 347
                self.proton_shift_statement()
                self.state = 352
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Dihedral_angle_db_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_angle_db_restraint

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

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




    def dihedral_angle_db_restraint(self):

        localctx = XplorMRParser.Dihedral_angle_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_dihedral_angle_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 355
            self.match(XplorMRParser.Ramachandran)
            self.state = 359
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Cutoff) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (XplorMRParser.Gaussian - 76)) | (1 << (XplorMRParser.Phase - 76)) | (1 << (XplorMRParser.Quartic - 76)) | (1 << (XplorMRParser.Shape - 76)) | (1 << (XplorMRParser.Sort - 76)))) != 0):
                self.state = 356
                self.ramachandran_statement()
                self.state = 361
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Radius_of_gyration_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_radius_of_gyration_restraint

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

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




    def radius_of_gyration_restraint(self):

        localctx = XplorMRParser.Radius_of_gyration_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_radius_of_gyration_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self.match(XplorMRParser.Collapse)
            self.state = 368
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale))) != 0):
                self.state = 365
                self.collapse_statement()
                self.state = 370
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Diffusion_anisotropy_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_diffusion_anisotropy_restraint

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

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




    def diffusion_anisotropy_restraint(self):

        localctx = XplorMRParser.Diffusion_anisotropy_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_diffusion_anisotropy_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 373
            self.match(XplorMRParser.Danisotropy)
            self.state = 377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type))) != 0):
                self.state = 374
                self.diffusion_statement()
                self.state = 379
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Orientation_db_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_orientation_db_restraint

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

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




    def orientation_db_restraint(self):

        localctx = XplorMRParser.Orientation_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_orientation_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 382
            self.match(XplorMRParser.Orient)
            self.state = 386
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Cutoff) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (XplorMRParser.Gaussian - 76)) | (1 << (XplorMRParser.Quartic - 76)) | (1 << (XplorMRParser.Height - 76)) | (1 << (XplorMRParser.MaxGaussians - 76)) | (1 << (XplorMRParser.NewGaussian - 76)) | (1 << (XplorMRParser.Residue - 76)))) != 0):
                self.state = 383
                self.orientation_statement()
                self.state = 388
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Csa_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_restraint

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

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




    def csa_restraint(self):

        localctx = XplorMRParser.Csa_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_csa_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 391
            self.match(XplorMRParser.Dcsa)
            self.state = 395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type))) != 0) or _la==XplorMRParser.Sigma:
                self.state = 392
                self.csa_statement()
                self.state = 397
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Pcsa_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcsa_restraint

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

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




    def pcsa_restraint(self):

        localctx = XplorMRParser.Pcsa_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_pcsa_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 400
            self.match(XplorMRParser.Pcsa)
            self.state = 404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or _la==XplorMRParser.Sigma:
                self.state = 401
                self.pcsa_statement()
                self.state = 406
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class One_bond_coupling_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_coupling_restraint

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

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




    def one_bond_coupling_restraint(self):

        localctx = XplorMRParser.One_bond_coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_one_bond_coupling_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 409
            self.match(XplorMRParser.OneBond)
            self.state = 413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0):
                self.state = 410
                self.one_bond_coupling_statement()
                self.state = 415
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Angle_db_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_restraint

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

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




    def angle_db_restraint(self):

        localctx = XplorMRParser.Angle_db_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_angle_db_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 418
            self.match(XplorMRParser.AngleDb)
            self.state = 422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Expectation) | (1 << XplorMRParser.Size) | (1 << XplorMRParser.Zero))) != 0) or _la==XplorMRParser.Error or _la==XplorMRParser.DerivFlag:
                self.state = 419
                self.angle_db_statement()
                self.state = 424
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Pre_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_restraint

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

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




    def pre_restraint(self):

        localctx = XplorMRParser.Pre_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_pre_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 427
            self.match(XplorMRParser.Paramagnetic)
            self.state = 431
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (XplorMRParser.Kconst - 96)) | (1 << (XplorMRParser.Omega - 96)) | (1 << (XplorMRParser.Tauc - 96)) | (1 << (XplorMRParser.Debug - 96)))) != 0):
                self.state = 428
                self.pre_statement()
                self.state = 433
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Pcs_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_restraint

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

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




    def pcs_restraint(self):

        localctx = XplorMRParser.Pcs_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_pcs_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 436
            self.match(XplorMRParser.Xpcs)
            self.state = 440
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or ((((_la - 101)) & ~0x3f) == 0 and ((1 << (_la - 101)) & ((1 << (XplorMRParser.Tolerance - 101)) | (1 << (XplorMRParser.Save - 101)) | (1 << (XplorMRParser.Fmed - 101)) | (1 << (XplorMRParser.ErrOn - 101)) | (1 << (XplorMRParser.ErrOff - 101)) | (1 << (XplorMRParser.Fon - 101)) | (1 << (XplorMRParser.Foff - 101)) | (1 << (XplorMRParser.Son - 101)) | (1 << (XplorMRParser.Soff - 101)) | (1 << (XplorMRParser.Frun - 101)))) != 0):
                self.state = 437
                self.pcs_statement()
                self.state = 442
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Prdc_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_restraint

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

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




    def prdc_restraint(self):

        localctx = XplorMRParser.Prdc_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_prdc_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 445
            self.match(XplorMRParser.Xrdcoupling)
            self.state = 449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or ((((_la - 101)) & ~0x3f) == 0 and ((1 << (_la - 101)) & ((1 << (XplorMRParser.Tolerance - 101)) | (1 << (XplorMRParser.Save - 101)) | (1 << (XplorMRParser.Fmed - 101)) | (1 << (XplorMRParser.ErrOn - 101)) | (1 << (XplorMRParser.ErrOff - 101)) | (1 << (XplorMRParser.Fon - 101)) | (1 << (XplorMRParser.Foff - 101)) | (1 << (XplorMRParser.Son - 101)) | (1 << (XplorMRParser.Soff - 101)) | (1 << (XplorMRParser.Frun - 101)))) != 0):
                self.state = 446
                self.prdc_statement()
                self.state = 451
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Porientation_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_restraint

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

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




    def porientation_restraint(self):

        localctx = XplorMRParser.Porientation_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_porientation_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 454
            self.match(XplorMRParser.Xangle)
            self.state = 458
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant))) != 0):
                self.state = 455
                self.porientation_statement()
                self.state = 460
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Pccr_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_restraint

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

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




    def pccr_restraint(self):

        localctx = XplorMRParser.Pccr_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_pccr_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.match(XplorMRParser.Xccr)
            self.state = 467
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant))) != 0) or _la==XplorMRParser.Frun or _la==XplorMRParser.Weip:
                self.state = 464
                self.pccr_statement()
                self.state = 469
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Hbond_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_restraint

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

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




    def hbond_restraint(self):

        localctx = XplorMRParser.Hbond_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_hbond_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 472
            self.match(XplorMRParser.Hbda)
            self.state = 476
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.ForceConstant))) != 0):
                self.state = 473
                self.hbond_statement()
                self.state = 478
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Noe_statementContext(ParserRuleContext):

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

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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_statement

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

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




    def noe_statement(self):

        localctx = XplorMRParser.Noe_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_noe_statement)
        self._la = 0 # Token type
        try:
            self.state = 552
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 481
                self.noe_assign()
                pass
            elif token in [XplorMRParser.Asymptote]:
                self.enterOuterAlt(localctx, 2)
                self.state = 482
                self.match(XplorMRParser.Asymptote)
                self.state = 483
                self.match(XplorMRParser.Simple_name)
                self.state = 484
                self.number_s()
                pass
            elif token in [XplorMRParser.Averaging]:
                self.enterOuterAlt(localctx, 3)
                self.state = 485
                self.match(XplorMRParser.Averaging)
                self.state = 486
                self.match(XplorMRParser.Simple_name_A)
                self.state = 487
                self.match(XplorMRParser.Averaging_methods)
                pass
            elif token in [XplorMRParser.Bhig]:
                self.enterOuterAlt(localctx, 4)
                self.state = 488
                self.match(XplorMRParser.Bhig)
                self.state = 489
                self.match(XplorMRParser.Simple_name)
                self.state = 490
                self.number_s()
                pass
            elif token in [XplorMRParser.Ceiling]:
                self.enterOuterAlt(localctx, 5)
                self.state = 491
                self.match(XplorMRParser.Ceiling)
                self.state = 493
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 492
                    self.match(XplorMRParser.Equ_op)


                self.state = 495
                self.number_s()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 6)
                self.state = 496
                self.match(XplorMRParser.Classification)
                self.state = 497
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.CountViol]:
                self.enterOuterAlt(localctx, 7)
                self.state = 498
                self.match(XplorMRParser.CountViol)
                self.state = 499
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Distribute]:
                self.enterOuterAlt(localctx, 8)
                self.state = 500
                self.match(XplorMRParser.Distribute)
                self.state = 501
                self.match(XplorMRParser.Simple_name)
                self.state = 502
                self.match(XplorMRParser.Simple_name)
                self.state = 503
                self.number_s()
                pass
            elif token in [XplorMRParser.Monomers]:
                self.enterOuterAlt(localctx, 9)
                self.state = 504
                self.match(XplorMRParser.Monomers)
                self.state = 505
                self.match(XplorMRParser.Simple_name)
                self.state = 506
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Ncount]:
                self.enterOuterAlt(localctx, 10)
                self.state = 507
                self.match(XplorMRParser.Ncount)
                self.state = 508
                self.match(XplorMRParser.Simple_name)
                self.state = 509
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 11)
                self.state = 510
                self.match(XplorMRParser.Nrestraints)
                self.state = 512
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 511
                    self.match(XplorMRParser.Equ_op)


                self.state = 514
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 12)
                self.state = 515
                self.match(XplorMRParser.Potential)
                self.state = 516
                self.match(XplorMRParser.Simple_name_P)
                self.state = 517
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Predict]:
                self.enterOuterAlt(localctx, 13)
                self.state = 518
                self.match(XplorMRParser.Predict)
                self.state = 519
                self.predict_statement()
                self.state = 520
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 14)
                self.state = 522
                self.match(XplorMRParser.Print)
                self.state = 523
                self.match(XplorMRParser.Threshold)
                self.state = 525
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 524
                    self.match(XplorMRParser.Equ_op)


                self.state = 527
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 15)
                self.state = 528
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Rswitch]:
                self.enterOuterAlt(localctx, 16)
                self.state = 529
                self.match(XplorMRParser.Rswitch)
                self.state = 530
                self.match(XplorMRParser.Simple_name)
                self.state = 531
                self.number_s()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 17)
                self.state = 532
                self.match(XplorMRParser.Scale)
                self.state = 533
                self.match(XplorMRParser.Simple_name)
                self.state = 534
                self.number_s()
                pass
            elif token in [XplorMRParser.SoExponent]:
                self.enterOuterAlt(localctx, 18)
                self.state = 535
                self.match(XplorMRParser.SoExponent)
                self.state = 536
                self.match(XplorMRParser.Simple_name)
                self.state = 537
                self.number_s()
                pass
            elif token in [XplorMRParser.SqConstant]:
                self.enterOuterAlt(localctx, 19)
                self.state = 538
                self.match(XplorMRParser.SqConstant)
                self.state = 539
                self.match(XplorMRParser.Simple_name)
                self.state = 540
                self.number_s()
                pass
            elif token in [XplorMRParser.SqExponent]:
                self.enterOuterAlt(localctx, 20)
                self.state = 541
                self.match(XplorMRParser.SqExponent)
                self.state = 542
                self.match(XplorMRParser.Simple_name)
                self.state = 543
                self.number_s()
                pass
            elif token in [XplorMRParser.SqOffset]:
                self.enterOuterAlt(localctx, 21)
                self.state = 544
                self.match(XplorMRParser.SqOffset)
                self.state = 545
                self.match(XplorMRParser.Simple_name)
                self.state = 546
                self.number_s()
                pass
            elif token in [XplorMRParser.Temperature]:
                self.enterOuterAlt(localctx, 22)
                self.state = 547
                self.match(XplorMRParser.Temperature)
                self.state = 549
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 548
                    self.match(XplorMRParser.Equ_op)


                self.state = 551
                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):

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

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

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


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


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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_assign

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

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




    def noe_assign(self):

        localctx = XplorMRParser.Noe_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_noe_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 554
            self.match(XplorMRParser.Assign)
            self.state = 555
            self.selection()
            self.state = 556
            self.selection()
            self.state = 557
            self.number()
            self.state = 558
            self.number()
            self.state = 559
            self.number()
            self.state = 563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Peak) | (1 << XplorMRParser.Spectrum) | (1 << XplorMRParser.Volume) | (1 << XplorMRParser.Ppm1) | (1 << XplorMRParser.Ppm2) | (1 << XplorMRParser.Cv) | (1 << XplorMRParser.Weight))) != 0):
                self.state = 560
                self.noe_annotation()
                self.state = 565
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 566
                self.match(XplorMRParser.Or_op)
                self.state = 567
                self.selection()
                self.state = 568
                self.selection()
                self.state = 574
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Predict_statementContext(ParserRuleContext):

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

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

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


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

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

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

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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_predict_statement

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

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




    def predict_statement(self):

        localctx = XplorMRParser.Predict_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_predict_statement)
        self._la = 0 # Token type
        try:
            self.state = 589
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 1)
                self.state = 575
                self.match(XplorMRParser.Cutoff)
                self.state = 577
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 576
                    self.match(XplorMRParser.Equ_op)


                self.state = 579
                self.number_s()
                pass
            elif token in [XplorMRParser.Cuton]:
                self.enterOuterAlt(localctx, 2)
                self.state = 580
                self.match(XplorMRParser.Cuton)
                self.state = 582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 581
                    self.match(XplorMRParser.Equ_op)


                self.state = 584
                self.number_s()
                pass
            elif token in [XplorMRParser.From]:
                self.enterOuterAlt(localctx, 3)
                self.state = 585
                self.match(XplorMRParser.From)
                self.state = 586
                self.selection()
                pass
            elif token in [XplorMRParser.To]:
                self.enterOuterAlt(localctx, 4)
                self.state = 587
                self.match(XplorMRParser.To)
                self.state = 588
                self.selection()
                pass
            else:
                raise NoViableAltException(self)

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


    class Noe_annotationContext(ParserRuleContext):

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

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

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


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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_noe_annotation

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

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




    def noe_annotation(self):

        localctx = XplorMRParser.Noe_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_noe_annotation)
        self._la = 0 # Token type
        try:
            self.state = 626
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Peak]:
                self.enterOuterAlt(localctx, 1)
                self.state = 591
                self.match(XplorMRParser.Peak)
                self.state = 593
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 592
                    self.match(XplorMRParser.Equ_op)


                self.state = 595
                self.number_a()
                pass
            elif token in [XplorMRParser.Spectrum]:
                self.enterOuterAlt(localctx, 2)
                self.state = 596
                self.match(XplorMRParser.Spectrum)
                self.state = 598
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 597
                    self.match(XplorMRParser.Equ_op)


                self.state = 600
                self.number_a()
                pass
            elif token in [XplorMRParser.Weight]:
                self.enterOuterAlt(localctx, 3)
                self.state = 601
                self.match(XplorMRParser.Weight)
                self.state = 603
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 602
                    self.match(XplorMRParser.Equ_op)


                self.state = 605
                self.number_a()
                pass
            elif token in [XplorMRParser.Volume]:
                self.enterOuterAlt(localctx, 4)
                self.state = 606
                self.match(XplorMRParser.Volume)
                self.state = 608
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 607
                    self.match(XplorMRParser.Equ_op)


                self.state = 610
                self.number_a()
                pass
            elif token in [XplorMRParser.Ppm1]:
                self.enterOuterAlt(localctx, 5)
                self.state = 611
                self.match(XplorMRParser.Ppm1)
                self.state = 613
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 612
                    self.match(XplorMRParser.Equ_op)


                self.state = 615
                self.number_a()
                pass
            elif token in [XplorMRParser.Ppm2]:
                self.enterOuterAlt(localctx, 6)
                self.state = 616
                self.match(XplorMRParser.Ppm2)
                self.state = 618
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 617
                    self.match(XplorMRParser.Equ_op)


                self.state = 620
                self.number_a()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 7)
                self.state = 621
                self.match(XplorMRParser.Cv)
                self.state = 623
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 622
                    self.match(XplorMRParser.Equ_op)


                self.state = 625
                self.number_a()
                pass
            else:
                raise NoViableAltException(self)

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


    class Dihedral_statementContext(ParserRuleContext):

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

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


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

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

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_statement

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

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




    def dihedral_statement(self):

        localctx = XplorMRParser.Dihedral_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_dihedral_statement)
        self._la = 0 # Token type
        try:
            self.state = 637
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 628
                self.dihedral_assign()
                pass
            elif token in [XplorMRParser.Nassign]:
                self.enterOuterAlt(localctx, 2)
                self.state = 629
                self.match(XplorMRParser.Nassign)
                self.state = 631
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 630
                    self.match(XplorMRParser.Equ_op)


                self.state = 633
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 3)
                self.state = 634
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 635
                self.match(XplorMRParser.Scale)
                self.state = 636
                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 Dihedral_assignContext(ParserRuleContext):

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

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

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


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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_assign

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

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




    def dihedral_assign(self):

        localctx = XplorMRParser.Dihedral_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_dihedral_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.match(XplorMRParser.Assign)
            self.state = 640
            self.selection()
            self.state = 641
            self.selection()
            self.state = 642
            self.selection()
            self.state = 643
            self.selection()
            self.state = 644
            self.number()
            self.state = 645
            self.number()
            self.state = 646
            self.number()
            self.state = 647
            self.match(XplorMRParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sani_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_sani_statement

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

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




    def sani_statement(self):

        localctx = XplorMRParser.Sani_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_sani_statement)
        try:
            self.state = 667
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 649
                self.sani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 650
                self.match(XplorMRParser.Classification)
                self.state = 651
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 652
                self.match(XplorMRParser.Coefficients)
                self.state = 653
                self.number_s()
                self.state = 654
                self.number_s()
                self.state = 655
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 657
                self.match(XplorMRParser.ForceConstant)
                self.state = 658
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 659
                self.match(XplorMRParser.Nrestraints)
                self.state = 660
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 661
                self.match(XplorMRParser.Potential)
                self.state = 662
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 663
                self.match(XplorMRParser.Print)
                self.state = 664
                self.match(XplorMRParser.Threshold)
                self.state = 665
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 666
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Sani_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_sani_assign

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

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




    def sani_assign(self):

        localctx = XplorMRParser.Sani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_sani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 669
            self.match(XplorMRParser.Assign)
            self.state = 670
            self.selection()
            self.state = 671
            self.selection()
            self.state = 672
            self.selection()
            self.state = 673
            self.selection()
            self.state = 674
            self.selection()
            self.state = 675
            self.selection()
            self.state = 676
            self.number()
            self.state = 677
            self.number()
            self.state = 679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 678
                self.number()


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


    class Xdip_statementContext(ParserRuleContext):

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_xdip_statement

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

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




    def xdip_statement(self):

        localctx = XplorMRParser.Xdip_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_xdip_statement)
        try:
            self.state = 707
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 681
                self.xdip_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 682
                self.match(XplorMRParser.Classification)
                self.state = 683
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 3)
                self.state = 684
                self.match(XplorMRParser.Type)
                self.state = 685
                self.match(XplorMRParser.Rdc_dist_fix_types)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 686
                self.match(XplorMRParser.Scale)
                self.state = 687
                self.number_s()
                pass
            elif token in [XplorMRParser.Sign]:
                self.enterOuterAlt(localctx, 5)
                self.state = 688
                self.match(XplorMRParser.Sign)
                self.state = 689
                self.match(XplorMRParser.Logical)
                pass
            elif token in [XplorMRParser.Average]:
                self.enterOuterAlt(localctx, 6)
                self.state = 690
                self.match(XplorMRParser.Average)
                self.state = 691
                self.match(XplorMRParser.Averaging_methods)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 7)
                self.state = 692
                self.match(XplorMRParser.Coefficients)
                self.state = 693
                self.number_s()
                self.state = 694
                self.number_s()
                self.state = 695
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 8)
                self.state = 697
                self.match(XplorMRParser.ForceConstant)
                self.state = 698
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 699
                self.match(XplorMRParser.Nrestraints)
                self.state = 700
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 10)
                self.state = 701
                self.match(XplorMRParser.Potential)
                self.state = 702
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 11)
                self.state = 703
                self.match(XplorMRParser.Print)
                self.state = 704
                self.match(XplorMRParser.Threshold)
                self.state = 705
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 706
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Xdip_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_xdip_assign

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

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




    def xdip_assign(self):

        localctx = XplorMRParser.Xdip_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_xdip_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 709
            self.match(XplorMRParser.Assign)
            self.state = 710
            self.selection()
            self.state = 711
            self.selection()
            self.state = 712
            self.selection()
            self.state = 713
            self.selection()
            self.state = 714
            self.selection()
            self.state = 715
            self.selection()
            self.state = 716
            self.number()
            self.state = 717
            self.number()
            self.state = 724
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.state = 718
                self.number()

            elif la_ == 2:
                self.state = 719
                self.number()
                self.state = 720
                self.number()
                self.state = 721
                self.number()
                self.state = 722
                self.number()


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


    class Vean_statementContext(ParserRuleContext):

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

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


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

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

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

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

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

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_vean_statement

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

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




    def vean_statement(self):

        localctx = XplorMRParser.Vean_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_vean_statement)
        self._la = 0 # Token type
        try:
            self.state = 749
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 726
                self.vean_assign()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 2)
                self.state = 727
                self.match(XplorMRParser.Cv)
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 728
                    self.match(XplorMRParser.Equ_op)


                self.state = 731
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 732
                self.match(XplorMRParser.Classification)
                self.state = 733
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 734
                self.match(XplorMRParser.ForceConstant)
                self.state = 735
                self.number_s()
                self.state = 736
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 738
                self.match(XplorMRParser.Nrestraints)
                self.state = 739
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 6)
                self.state = 740
                self.match(XplorMRParser.Partition)
                self.state = 742
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 741
                    self.match(XplorMRParser.Equ_op)


                self.state = 744
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 745
                self.match(XplorMRParser.Print)
                self.state = 746
                self.match(XplorMRParser.Threshold)
                self.state = 747
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 748
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Vean_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_vean_assign

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

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




    def vean_assign(self):

        localctx = XplorMRParser.Vean_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_vean_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 751
            self.match(XplorMRParser.Assign)
            self.state = 752
            self.selection()
            self.state = 753
            self.selection()
            self.state = 754
            self.selection()
            self.state = 755
            self.selection()
            self.state = 756
            self.number()
            self.state = 757
            self.number()
            self.state = 758
            self.number()
            self.state = 759
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Tenso_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_tenso_statement

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

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




    def tenso_statement(self):

        localctx = XplorMRParser.Tenso_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_tenso_statement)
        try:
            self.state = 774
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 761
                self.tenso_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 762
                self.match(XplorMRParser.Classification)
                self.state = 763
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 764
                self.match(XplorMRParser.Coefficients)
                self.state = 765
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 766
                self.match(XplorMRParser.Nrestraints)
                self.state = 767
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 768
                self.match(XplorMRParser.Potential)
                self.state = 769
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 770
                self.match(XplorMRParser.Print)
                self.state = 771
                self.match(XplorMRParser.Threshold)
                self.state = 772
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 773
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Tenso_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_tenso_assign

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

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




    def tenso_assign(self):

        localctx = XplorMRParser.Tenso_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_tenso_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 776
            self.match(XplorMRParser.Assign)
            self.state = 777
            self.selection()
            self.state = 778
            self.selection()
            self.state = 779
            self.number()
            self.state = 780
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Anis_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_anis_statement

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

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




    def anis_statement(self):

        localctx = XplorMRParser.Anis_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_anis_statement)
        try:
            self.state = 803
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 782
                self.anis_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 783
                self.match(XplorMRParser.Classification)
                self.state = 784
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 785
                self.match(XplorMRParser.Coefficients)
                self.state = 786
                self.number_s()
                self.state = 787
                self.number_s()
                self.state = 788
                self.number_s()
                self.state = 789
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 791
                self.match(XplorMRParser.ForceConstant)
                self.state = 792
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 793
                self.match(XplorMRParser.Nrestraints)
                self.state = 794
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 795
                self.match(XplorMRParser.Potential)
                self.state = 796
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 797
                self.match(XplorMRParser.Print)
                self.state = 798
                self.match(XplorMRParser.Threshold)
                self.state = 799
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 800
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 801
                self.match(XplorMRParser.Type)
                self.state = 802
                self.match(XplorMRParser.Rdc_or_Diff_anis_types)
                pass
            else:
                raise NoViableAltException(self)

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


    class Anis_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_anis_assign

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

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




    def anis_assign(self):

        localctx = XplorMRParser.Anis_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_anis_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 805
            self.match(XplorMRParser.Assign)
            self.state = 806
            self.selection()
            self.state = 807
            self.selection()
            self.state = 808
            self.selection()
            self.state = 809
            self.selection()
            self.state = 810
            self.number()
            self.state = 811
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Planar_statementContext(ParserRuleContext):

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

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

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

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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_statement

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

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




    def planar_statement(self):

        localctx = XplorMRParser.Planar_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_planar_statement)
        self._la = 0 # Token type
        try:
            self.state = 822
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Group]:
                self.enterOuterAlt(localctx, 1)
                self.state = 813
                self.match(XplorMRParser.Group)
                self.state = 817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Selection or _la==XplorMRParser.Weight:
                    self.state = 814
                    self.group_statement()
                    self.state = 819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 820
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Initialize]:
                self.enterOuterAlt(localctx, 2)
                self.state = 821
                self.match(XplorMRParser.Initialize)
                pass
            else:
                raise NoViableAltException(self)

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


    class Group_statementContext(ParserRuleContext):

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

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

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


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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_group_statement

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

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




    def group_statement(self):

        localctx = XplorMRParser.Group_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 834
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Selection]:
                self.enterOuterAlt(localctx, 1)
                self.state = 824
                self.match(XplorMRParser.Selection)
                self.state = 826
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 825
                    self.match(XplorMRParser.Equ_op)


                self.state = 828
                self.selection()
                pass
            elif token in [XplorMRParser.Weight]:
                self.enterOuterAlt(localctx, 2)
                self.state = 829
                self.match(XplorMRParser.Weight)
                self.state = 831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 830
                    self.match(XplorMRParser.Equ_op)


                self.state = 833
                self.number_s()
                pass
            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 Antidistance_statementContext(ParserRuleContext):

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_antidistance_statement

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

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




    def antidistance_statement(self):

        localctx = XplorMRParser.Antidistance_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_antidistance_statement)
        try:
            self.state = 860
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 836
                self.xadc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 837
                self.match(XplorMRParser.Classification)
                self.state = 838
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 839
                self.match(XplorMRParser.Expectation)
                self.state = 840
                self.match(XplorMRParser.Integer)
                self.state = 841
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 842
                self.match(XplorMRParser.ForceConstant)
                self.state = 843
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 844
                self.match(XplorMRParser.Nrestraints)
                self.state = 845
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 846
                self.match(XplorMRParser.Print)
                self.state = 847
                self.match(XplorMRParser.Threshold)
                self.state = 848
                self.number_s()
                self.state = 852
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 849
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 850
                    self.match(XplorMRParser.Classification)
                    self.state = 851
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 854
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 8)
                self.state = 855
                self.match(XplorMRParser.Size)
                self.state = 856
                self.number_s()
                self.state = 857
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 9)
                self.state = 859
                self.match(XplorMRParser.Zero)
                pass
            else:
                raise NoViableAltException(self)

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


    class Xadc_assignContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_xadc_assign

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

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




    def xadc_assign(self):

        localctx = XplorMRParser.Xadc_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_xadc_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 862
            self.match(XplorMRParser.Assign)
            self.state = 863
            self.selection()
            self.state = 864
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Coupling_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_coupling_statement

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

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




    def coupling_statement(self):

        localctx = XplorMRParser.Coupling_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 905
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 866
                self.coup_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 867
                self.match(XplorMRParser.Classification)
                self.state = 868
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 869
                self.match(XplorMRParser.Coefficients)
                self.state = 870
                self.number_s()
                self.state = 871
                self.number_s()
                self.state = 872
                self.number_s()
                self.state = 873
                self.number_s()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 4)
                self.state = 875
                self.match(XplorMRParser.Cv)
                self.state = 877
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 876
                    self.match(XplorMRParser.Equ_op)


                self.state = 879
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 5)
                self.state = 880
                self.match(XplorMRParser.DegEnergy)
                self.state = 881
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 882
                self.match(XplorMRParser.ForceConstant)
                self.state = 883
                self.number_s()
                self.state = 885
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 884
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 887
                self.match(XplorMRParser.Nrestraints)
                self.state = 888
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 8)
                self.state = 889
                self.match(XplorMRParser.Partition)
                self.state = 891
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 890
                    self.match(XplorMRParser.Equ_op)


                self.state = 893
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 894
                self.match(XplorMRParser.Potential)
                self.state = 895
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 896
                self.match(XplorMRParser.Print)
                self.state = 897
                self.match(XplorMRParser.Threshold)
                self.state = 898
                self.number_s()
                self.state = 902
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 899
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 900
                    self.match(XplorMRParser.Classification)
                    self.state = 901
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 904
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Coup_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_coup_assign

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

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




    def coup_assign(self):

        localctx = XplorMRParser.Coup_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_coup_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 907
            self.match(XplorMRParser.Assign)
            self.state = 908
            self.selection()
            self.state = 909
            self.selection()
            self.state = 910
            self.selection()
            self.state = 911
            self.selection()
            self.state = 917
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 912
                self.selection()
                self.state = 913
                self.selection()
                self.state = 914
                self.selection()
                self.state = 915
                self.selection()


            self.state = 919
            self.number()
            self.state = 920
            self.number()
            self.state = 924
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 921
                self.number()
                self.state = 922
                self.number()


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


    class Carbon_shift_statementContext(ParserRuleContext):

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_statement

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

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




    def carbon_shift_statement(self):

        localctx = XplorMRParser.Carbon_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_carbon_shift_statement)
        try:
            self.state = 952
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 926
                self.carbon_shift_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 927
                self.match(XplorMRParser.Classification)
                self.state = 928
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 929
                self.match(XplorMRParser.Expectation)
                self.state = 930
                self.match(XplorMRParser.Integer)
                self.state = 931
                self.match(XplorMRParser.Integer)
                self.state = 932
                self.number_s()
                self.state = 933
                self.number_s()
                self.state = 934
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 936
                self.match(XplorMRParser.ForceConstant)
                self.state = 937
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 938
                self.match(XplorMRParser.Nrestraints)
                self.state = 939
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.PhiStep]:
                self.enterOuterAlt(localctx, 6)
                self.state = 940
                self.match(XplorMRParser.PhiStep)
                self.state = 941
                self.number_s()
                pass
            elif token in [XplorMRParser.PsiStep]:
                self.enterOuterAlt(localctx, 7)
                self.state = 942
                self.match(XplorMRParser.PsiStep)
                self.state = 943
                self.number_s()
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 944
                self.match(XplorMRParser.Potential)
                self.state = 945
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 946
                self.match(XplorMRParser.Print)
                self.state = 947
                self.match(XplorMRParser.Threshold)
                self.state = 948
                self.number_s()
                pass
            elif token in [XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 10)
                self.state = 949
                self.carbon_shift_rcoil()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 950
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 951
                self.match(XplorMRParser.Zero)
                pass
            else:
                raise NoViableAltException(self)

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


    class Carbon_shift_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_assign

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

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




    def carbon_shift_assign(self):

        localctx = XplorMRParser.Carbon_shift_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_carbon_shift_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 954
            self.match(XplorMRParser.Assign)
            self.state = 955
            self.selection()
            self.state = 956
            self.selection()
            self.state = 957
            self.selection()
            self.state = 958
            self.selection()
            self.state = 959
            self.selection()
            self.state = 960
            self.number()
            self.state = 961
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Carbon_shift_rcoilContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_rcoil

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

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




    def carbon_shift_rcoil(self):

        localctx = XplorMRParser.Carbon_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_carbon_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 963
            self.match(XplorMRParser.Rcoil)
            self.state = 964
            self.selection()
            self.state = 965
            self.number_s()
            self.state = 966
            self.number_s()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_statementContext(ParserRuleContext):

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

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


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


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


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


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


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


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


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


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


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

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

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

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


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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_statement

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

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




    def proton_shift_statement(self):

        localctx = XplorMRParser.Proton_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_proton_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 1001
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Observed]:
                self.enterOuterAlt(localctx, 1)
                self.state = 968
                self.observed()
                pass
            elif token in [XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 2)
                self.state = 969
                self.proton_shift_rcoil()
                pass
            elif token in [XplorMRParser.Anisotropy]:
                self.enterOuterAlt(localctx, 3)
                self.state = 970
                self.proton_shift_anisotropy()
                pass
            elif token in [XplorMRParser.Amides]:
                self.enterOuterAlt(localctx, 4)
                self.state = 971
                self.proton_shift_amides()
                pass
            elif token in [XplorMRParser.Carbon]:
                self.enterOuterAlt(localctx, 5)
                self.state = 972
                self.proton_shift_carbons()
                pass
            elif token in [XplorMRParser.Nitrogens]:
                self.enterOuterAlt(localctx, 6)
                self.state = 973
                self.proton_shift_nitrogens()
                pass
            elif token in [XplorMRParser.Oxygens]:
                self.enterOuterAlt(localctx, 7)
                self.state = 974
                self.proton_shift_oxygens()
                pass
            elif token in [XplorMRParser.RingAtoms]:
                self.enterOuterAlt(localctx, 8)
                self.state = 975
                self.proton_shift_ring_atoms()
                pass
            elif token in [XplorMRParser.AlphasAndAmides]:
                self.enterOuterAlt(localctx, 9)
                self.state = 976
                self.proton_shift_alphas_and_amides()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 10)
                self.state = 977
                self.match(XplorMRParser.Classification)
                self.state = 978
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 11)
                self.state = 979
                self.match(XplorMRParser.Error)
                self.state = 980
                self.number_s()
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 12)
                self.state = 981
                self.match(XplorMRParser.DegEnergy)
                self.state = 982
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 13)
                self.state = 983
                self.match(XplorMRParser.ForceConstant)
                self.state = 984
                self.number_s()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 985
                    self.number_s()


                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 14)
                self.state = 988
                self.match(XplorMRParser.Potential)
                self.state = 989
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 15)
                self.state = 990
                self.match(XplorMRParser.Print)
                self.state = 991
                self.match(XplorMRParser.Threshold)
                self.state = 992
                self.number_s()
                self.state = 996
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 993
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 994
                    self.match(XplorMRParser.Classification)
                    self.state = 995
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 998
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1000
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class ObservedContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_observed

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

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




    def observed(self):

        localctx = XplorMRParser.ObservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_observed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1003
            self.match(XplorMRParser.Observed)
            self.state = 1004
            self.selection()
            self.state = 1006
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1005
                self.selection()


            self.state = 1008
            self.number_s()
            self.state = 1010
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 1009
                self.number_s()


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


    class Proton_shift_rcoilContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_rcoil

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

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




    def proton_shift_rcoil(self):

        localctx = XplorMRParser.Proton_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_proton_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1012
            self.match(XplorMRParser.Rcoil)
            self.state = 1013
            self.selection()
            self.state = 1014
            self.number_s()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_anisotropyContext(ParserRuleContext):

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

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

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


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_anisotropy

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

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




    def proton_shift_anisotropy(self):

        localctx = XplorMRParser.Proton_shift_anisotropyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_proton_shift_anisotropy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1016
            self.match(XplorMRParser.Anisotropy)
            self.state = 1017
            self.selection()
            self.state = 1018
            self.selection()
            self.state = 1019
            self.selection()
            self.state = 1020
            self.match(XplorMRParser.Simple_name)
            self.state = 1022
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Logical:
                self.state = 1021
                self.match(XplorMRParser.Logical)


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


    class Proton_shift_amidesContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_amides

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

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




    def proton_shift_amides(self):

        localctx = XplorMRParser.Proton_shift_amidesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_proton_shift_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1026
            self.match(XplorMRParser.Amides)
            self.state = 1027
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_carbonsContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_carbons

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

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




    def proton_shift_carbons(self):

        localctx = XplorMRParser.Proton_shift_carbonsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_proton_shift_carbons)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1029
            self.match(XplorMRParser.Carbon)
            self.state = 1030
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_nitrogensContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_nitrogens

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

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




    def proton_shift_nitrogens(self):

        localctx = XplorMRParser.Proton_shift_nitrogensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_proton_shift_nitrogens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1032
            self.match(XplorMRParser.Nitrogens)
            self.state = 1033
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_oxygensContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_oxygens

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

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




    def proton_shift_oxygens(self):

        localctx = XplorMRParser.Proton_shift_oxygensContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_proton_shift_oxygens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1035
            self.match(XplorMRParser.Oxygens)
            self.state = 1036
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_ring_atomsContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_ring_atoms

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

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




    def proton_shift_ring_atoms(self):

        localctx = XplorMRParser.Proton_shift_ring_atomsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_proton_shift_ring_atoms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1038
            self.match(XplorMRParser.RingAtoms)
            self.state = 1039
            self.match(XplorMRParser.Simple_name)
            self.state = 1040
            self.selection()
            self.state = 1041
            self.selection()
            self.state = 1042
            self.selection()
            self.state = 1043
            self.selection()
            self.state = 1044
            self.selection()
            self.state = 1046
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1045
                self.selection()


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


    class Proton_shift_alphas_and_amidesContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_alphas_and_amides

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

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




    def proton_shift_alphas_and_amides(self):

        localctx = XplorMRParser.Proton_shift_alphas_and_amidesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_proton_shift_alphas_and_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1048
            self.match(XplorMRParser.AlphasAndAmides)
            self.state = 1049
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ramachandran_statementContext(ParserRuleContext):

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

        def rama_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Rama_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_ramachandran_statement

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

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




    def ramachandran_statement(self):

        localctx = XplorMRParser.Ramachandran_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_ramachandran_statement)
        self._la = 0 # Token type
        try:
            self.state = 1153
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1051
                self.rama_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1052
                self.match(XplorMRParser.Classification)
                self.state = 1053
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1054
                self.match(XplorMRParser.Cutoff)
                self.state = 1055
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1056
                self.match(XplorMRParser.ForceConstant)
                self.state = 1057
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1058
                self.match(XplorMRParser.Gaussian)
                self.state = 1059
                self.number_s()
                self.state = 1060
                self.number_s()
                self.state = 1061
                self.number_s()
                self.state = 1066
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
                if la_ == 1:
                    self.state = 1062
                    self.number_s()
                    self.state = 1063
                    self.number_s()
                    self.state = 1064
                    self.number_s()


                self.state = 1072
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
                if la_ == 1:
                    self.state = 1068
                    self.number_s()
                    self.state = 1069
                    self.number_s()
                    self.state = 1070
                    self.number_s()


                self.state = 1078
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1074
                    self.number_s()
                    self.state = 1075
                    self.number_s()
                    self.state = 1076
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1080
                self.match(XplorMRParser.Nrestraints)
                self.state = 1081
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Phase]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1082
                self.match(XplorMRParser.Phase)
                self.state = 1083
                self.number_s()
                self.state = 1084
                self.number_s()
                self.state = 1085
                self.number_s()
                self.state = 1090
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
                if la_ == 1:
                    self.state = 1086
                    self.number_s()
                    self.state = 1087
                    self.number_s()
                    self.state = 1088
                    self.number_s()


                self.state = 1096
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                if la_ == 1:
                    self.state = 1092
                    self.number_s()
                    self.state = 1093
                    self.number_s()
                    self.state = 1094
                    self.number_s()


                self.state = 1102
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1098
                    self.number_s()
                    self.state = 1099
                    self.number_s()
                    self.state = 1100
                    self.number_s()


                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1104
                self.match(XplorMRParser.Print)
                self.state = 1105
                self.match(XplorMRParser.Threshold)
                self.state = 1106
                self.number_s()
                self.state = 1110
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1107
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1108
                    self.match(XplorMRParser.Classification)
                    self.state = 1109
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1112
                self.match(XplorMRParser.Quartic)
                self.state = 1113
                self.number_s()
                self.state = 1114
                self.number_s()
                self.state = 1115
                self.number_s()
                self.state = 1120
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
                if la_ == 1:
                    self.state = 1116
                    self.number_s()
                    self.state = 1117
                    self.number_s()
                    self.state = 1118
                    self.number_s()


                self.state = 1126
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
                if la_ == 1:
                    self.state = 1122
                    self.number_s()
                    self.state = 1123
                    self.number_s()
                    self.state = 1124
                    self.number_s()


                self.state = 1132
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1128
                    self.number_s()
                    self.state = 1129
                    self.number_s()
                    self.state = 1130
                    self.number_s()


                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1134
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1135
                self.match(XplorMRParser.Scale)
                self.state = 1136
                self.number_s()
                pass
            elif token in [XplorMRParser.Shape]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1137
                self.match(XplorMRParser.Shape)
                self.state = 1138
                self.match(XplorMRParser.Gauss_or_Quart)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1139
                self.match(XplorMRParser.Size)
                self.state = 1140
                self.match(XplorMRParser.Dimensions)
                self.state = 1141
                self.number_s()
                self.state = 1143
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                if la_ == 1:
                    self.state = 1142
                    self.number_s()


                self.state = 1146
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
                if la_ == 1:
                    self.state = 1145
                    self.number_s()


                self.state = 1149
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1148
                    self.number_s()


                pass
            elif token in [XplorMRParser.Sort]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1151
                self.match(XplorMRParser.Sort)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1152
                self.match(XplorMRParser.Zero)
                pass
            else:
                raise NoViableAltException(self)

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


    class Rama_assignContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_rama_assign

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

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




    def rama_assign(self):

        localctx = XplorMRParser.Rama_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_rama_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1155
            self.match(XplorMRParser.Assign)
            self.state = 1156
            self.selection()
            self.state = 1157
            self.selection()
            self.state = 1158
            self.selection()
            self.state = 1159
            self.selection()
            self.state = 1165
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.state = 1160
                self.selection()
                self.state = 1161
                self.selection()
                self.state = 1162
                self.selection()
                self.state = 1163
                self.selection()


            self.state = 1172
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.state = 1167
                self.selection()
                self.state = 1168
                self.selection()
                self.state = 1169
                self.selection()
                self.state = 1170
                self.selection()


            self.state = 1179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1174
                self.selection()
                self.state = 1175
                self.selection()
                self.state = 1176
                self.selection()
                self.state = 1177
                self.selection()


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


    class Collapse_statementContext(ParserRuleContext):

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

        def coll_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Coll_assignContext,0)


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

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


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_collapse_statement

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

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




    def collapse_statement(self):

        localctx = XplorMRParser.Collapse_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_collapse_statement)
        try:
            self.state = 1186
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1181
                self.coll_assign()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1182
                self.match(XplorMRParser.Scale)
                self.state = 1183
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1184
                self.match(XplorMRParser.Print)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1185
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Coll_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_coll_assign

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

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




    def coll_assign(self):

        localctx = XplorMRParser.Coll_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_coll_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1188
            self.match(XplorMRParser.Assign)
            self.state = 1189
            self.selection()
            self.state = 1190
            self.number()
            self.state = 1191
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Diffusion_statementContext(ParserRuleContext):

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

        def dani_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Dani_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_diffusion_statement

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

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




    def diffusion_statement(self):

        localctx = XplorMRParser.Diffusion_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_diffusion_statement)
        try:
            self.state = 1215
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1193
                self.dani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1194
                self.match(XplorMRParser.Classification)
                self.state = 1195
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1196
                self.match(XplorMRParser.Coefficients)
                self.state = 1197
                self.number_s()
                self.state = 1198
                self.number_s()
                self.state = 1199
                self.number_s()
                self.state = 1200
                self.number_s()
                self.state = 1201
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1203
                self.match(XplorMRParser.ForceConstant)
                self.state = 1204
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1205
                self.match(XplorMRParser.Nrestraints)
                self.state = 1206
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1207
                self.match(XplorMRParser.Potential)
                self.state = 1208
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1209
                self.match(XplorMRParser.Print)
                self.state = 1210
                self.match(XplorMRParser.Threshold)
                self.state = 1211
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1212
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1213
                self.match(XplorMRParser.Type)
                self.state = 1214
                self.match(XplorMRParser.Rdc_or_Diff_anis_types)
                pass
            else:
                raise NoViableAltException(self)

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


    class Dani_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dani_assign

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

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




    def dani_assign(self):

        localctx = XplorMRParser.Dani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_dani_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1217
            self.match(XplorMRParser.Assign)
            self.state = 1218
            self.selection()
            self.state = 1219
            self.selection()
            self.state = 1220
            self.selection()
            self.state = 1221
            self.selection()
            self.state = 1222
            self.selection()
            self.state = 1223
            self.selection()
            self.state = 1224
            self.number()
            self.state = 1225
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Orientation_statementContext(ParserRuleContext):

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

        def orie_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Orie_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_orientation_statement

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

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




    def orientation_statement(self):

        localctx = XplorMRParser.Orientation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_orientation_statement)
        try:
            self.state = 1284
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1227
                self.orie_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1228
                self.match(XplorMRParser.Classification)
                self.state = 1229
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1230
                self.match(XplorMRParser.Cutoff)
                self.state = 1231
                self.number_s()
                pass
            elif token in [XplorMRParser.Height]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1232
                self.match(XplorMRParser.Height)
                self.state = 1233
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1234
                self.match(XplorMRParser.ForceConstant)
                self.state = 1235
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1236
                self.match(XplorMRParser.Gaussian)
                self.state = 1237
                self.number_s()
                self.state = 1238
                self.number_s()
                self.state = 1239
                self.number_s()
                self.state = 1240
                self.number_s()
                self.state = 1241
                self.number_s()
                self.state = 1242
                self.number_s()
                self.state = 1243
                self.number_s()
                pass
            elif token in [XplorMRParser.MaxGaussians]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1245
                self.match(XplorMRParser.MaxGaussians)
                self.state = 1246
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.NewGaussian]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1247
                self.match(XplorMRParser.NewGaussian)
                self.state = 1248
                self.number_s()
                self.state = 1249
                self.number_s()
                self.state = 1250
                self.number_s()
                self.state = 1251
                self.number_s()
                self.state = 1252
                self.number_s()
                self.state = 1253
                self.number_s()
                self.state = 1254
                self.number_s()
                self.state = 1255
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1257
                self.match(XplorMRParser.Nrestraints)
                self.state = 1258
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1259
                self.match(XplorMRParser.Print)
                self.state = 1260
                self.match(XplorMRParser.Threshold)
                self.state = 1261
                self.number_s()
                self.state = 1265
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1262
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1263
                    self.match(XplorMRParser.Classification)
                    self.state = 1264
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1267
                self.match(XplorMRParser.Quartic)
                self.state = 1268
                self.number_s()
                self.state = 1269
                self.number_s()
                self.state = 1270
                self.number_s()
                self.state = 1271
                self.number_s()
                self.state = 1272
                self.number_s()
                self.state = 1273
                self.number_s()
                self.state = 1274
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1276
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Residue]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1277
                self.match(XplorMRParser.Residue)
                self.state = 1278
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1279
                self.match(XplorMRParser.Size)
                self.state = 1280
                self.number_s()
                self.state = 1281
                self.number_s()
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1283
                self.match(XplorMRParser.Zero)
                pass
            else:
                raise NoViableAltException(self)

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


    class Orie_assignContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_orie_assign

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

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




    def orie_assign(self):

        localctx = XplorMRParser.Orie_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_orie_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1286
            self.match(XplorMRParser.Assign)
            self.state = 1287
            self.selection()
            self.state = 1288
            self.selection()
            self.state = 1289
            self.selection()
            self.state = 1290
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Csa_statementContext(ParserRuleContext):

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

        def csa_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_statement

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

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




    def csa_statement(self):

        localctx = XplorMRParser.Csa_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_csa_statement)
        try:
            self.state = 1319
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1292
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1293
                self.match(XplorMRParser.Classification)
                self.state = 1294
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1295
                self.match(XplorMRParser.Scale)
                self.state = 1296
                self.number_s()
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1297
                self.match(XplorMRParser.Type)
                self.state = 1298
                self.match(XplorMRParser.Csa_types)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1299
                self.match(XplorMRParser.Coefficients)
                self.state = 1300
                self.number_s()
                self.state = 1301
                self.number_s()
                self.state = 1302
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1304
                self.match(XplorMRParser.Sigma)
                self.state = 1305
                self.number_s()
                self.state = 1306
                self.number_s()
                self.state = 1307
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1309
                self.match(XplorMRParser.ForceConstant)
                self.state = 1310
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1311
                self.match(XplorMRParser.Nrestraints)
                self.state = 1312
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1313
                self.match(XplorMRParser.Potential)
                self.state = 1314
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1315
                self.match(XplorMRParser.Print)
                self.state = 1316
                self.match(XplorMRParser.Threshold)
                self.state = 1317
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1318
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Csa_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_assign

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

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




    def csa_assign(self):

        localctx = XplorMRParser.Csa_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_csa_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1321
            self.match(XplorMRParser.Assign)
            self.state = 1322
            self.selection()
            self.state = 1323
            self.selection()
            self.state = 1324
            self.selection()
            self.state = 1325
            self.selection()
            self.state = 1326
            self.selection()
            self.state = 1327
            self.selection()
            self.state = 1328
            self.selection()
            self.state = 1329
            self.number()
            self.state = 1330
            self.number()
            self.state = 1331
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcsa_statementContext(ParserRuleContext):

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

        def csa_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_pcsa_statement

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

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




    def pcsa_statement(self):

        localctx = XplorMRParser.Pcsa_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_pcsa_statement)
        try:
            self.state = 1359
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1333
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1334
                self.match(XplorMRParser.Classification)
                self.state = 1335
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1336
                self.match(XplorMRParser.Scale)
                self.state = 1337
                self.number_s()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1338
                self.match(XplorMRParser.Coefficients)
                self.state = 1339
                self.number_s()
                self.state = 1340
                self.number_s()
                self.state = 1341
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1343
                self.match(XplorMRParser.Sigma)
                self.state = 1344
                self.number_s()
                self.state = 1345
                self.number_s()
                self.state = 1346
                self.number_s()
                self.state = 1347
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1349
                self.match(XplorMRParser.ForceConstant)
                self.state = 1350
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1351
                self.match(XplorMRParser.Nrestraints)
                self.state = 1352
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1353
                self.match(XplorMRParser.Potential)
                self.state = 1354
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1355
                self.match(XplorMRParser.Print)
                self.state = 1356
                self.match(XplorMRParser.Threshold)
                self.state = 1357
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1358
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class One_bond_coupling_statementContext(ParserRuleContext):

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

        def one_bond_assign(self):
            return self.getTypedRuleContext(XplorMRParser.One_bond_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_coupling_statement

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

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




    def one_bond_coupling_statement(self):

        localctx = XplorMRParser.One_bond_coupling_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_one_bond_coupling_statement)
        try:
            self.state = 1383
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1361
                self.one_bond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1362
                self.match(XplorMRParser.Classification)
                self.state = 1363
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1364
                self.match(XplorMRParser.Coefficients)
                self.state = 1365
                self.number_s()
                self.state = 1366
                self.number_s()
                self.state = 1367
                self.number_s()
                self.state = 1368
                self.number_s()
                self.state = 1369
                self.number_s()
                self.state = 1370
                self.number_s()
                self.state = 1371
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1373
                self.match(XplorMRParser.ForceConstant)
                self.state = 1374
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1375
                self.match(XplorMRParser.Nrestraints)
                self.state = 1376
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1377
                self.match(XplorMRParser.Potential)
                self.state = 1378
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1379
                self.match(XplorMRParser.Print)
                self.state = 1380
                self.match(XplorMRParser.Threshold)
                self.state = 1381
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1382
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class One_bond_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_assign

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

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




    def one_bond_assign(self):

        localctx = XplorMRParser.One_bond_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_one_bond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1385
            self.match(XplorMRParser.Assign)
            self.state = 1386
            self.selection()
            self.state = 1387
            self.selection()
            self.state = 1388
            self.selection()
            self.state = 1389
            self.selection()
            self.state = 1390
            self.selection()
            self.state = 1391
            self.selection()
            self.state = 1392
            self.selection()
            self.state = 1393
            self.selection()
            self.state = 1394
            self.number()
            self.state = 1395
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angle_db_statementContext(ParserRuleContext):

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

        def angle_db_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Angle_db_assignContext,0)


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_statement

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

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




    def angle_db_statement(self):

        localctx = XplorMRParser.Angle_db_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_angle_db_statement)
        try:
            self.state = 1428
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1397
                self.angle_db_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1398
                self.match(XplorMRParser.Classification)
                self.state = 1399
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.DerivFlag]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1400
                self.match(XplorMRParser.DerivFlag)
                self.state = 1401
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1402
                self.match(XplorMRParser.Expectation)
                self.state = 1403
                self.match(XplorMRParser.Integer)
                self.state = 1404
                self.match(XplorMRParser.Integer)
                self.state = 1405
                self.number_s()
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1406
                self.match(XplorMRParser.Error)
                self.state = 1407
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1408
                self.match(XplorMRParser.ForceConstant)
                self.state = 1409
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1410
                self.match(XplorMRParser.Nrestraints)
                self.state = 1411
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1412
                self.match(XplorMRParser.Potential)
                self.state = 1413
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1414
                self.match(XplorMRParser.Print)
                self.state = 1415
                self.match(XplorMRParser.Threshold)
                self.state = 1416
                self.number_s()
                self.state = 1420
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1417
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1418
                    self.match(XplorMRParser.Classification)
                    self.state = 1419
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1422
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1423
                self.match(XplorMRParser.Size)
                self.state = 1424
                self.match(XplorMRParser.Angle_or_Dihedral)
                self.state = 1425
                self.match(XplorMRParser.Integer)
                self.state = 1426
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1427
                self.match(XplorMRParser.Zero)
                pass
            else:
                raise NoViableAltException(self)

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


    class Angle_db_assignContext(ParserRuleContext):

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

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

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAngle_db_assign" ):
                listener.enterAngle_db_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAngle_db_assign" ):
                listener.exitAngle_db_assign(self)




    def angle_db_assign(self):

        localctx = XplorMRParser.Angle_db_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_angle_db_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1430
            self.match(XplorMRParser.Assign)
            self.state = 1431
            self.selection()
            self.state = 1432
            self.selection()
            self.state = 1433
            self.selection()
            self.state = 1434
            self.selection()
            self.state = 1435
            self.selection()
            self.state = 1436
            self.selection()
            self.state = 1437
            self.selection()
            self.state = 1438
            self.selection()
            self.state = 1439
            self.selection()
            self.state = 1440
            self.selection()
            self.state = 1441
            self.selection()
            self.state = 1443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1442
                self.selection()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pre_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pre_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pre_assignContext,0)


        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Potential(self):
            return self.getToken(XplorMRParser.Potential, 0)

        def Simple_name_P(self):
            return self.getToken(XplorMRParser.Simple_name_P, 0)

        def Potential_types(self):
            return self.getToken(XplorMRParser.Potential_types, 0)

        def Equ_op_P(self):
            return self.getToken(XplorMRParser.Equ_op_P, 0)

        def Kconst(self):
            return self.getToken(XplorMRParser.Kconst, 0)

        def Omega(self):
            return self.getToken(XplorMRParser.Omega, 0)

        def Tauc(self):
            return self.getToken(XplorMRParser.Tauc, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Debug(self):
            return self.getToken(XplorMRParser.Debug, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPre_statement" ):
                listener.enterPre_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPre_statement" ):
                listener.exitPre_statement(self)




    def pre_statement(self):

        localctx = XplorMRParser.Pre_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_pre_statement)
        self._la = 0 # Token type
        try:
            self.state = 1498
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1445
                self.pre_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1446
                self.match(XplorMRParser.Classification)
                self.state = 1448
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1447
                    self.match(XplorMRParser.Equ_op)


                self.state = 1450
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1451
                self.match(XplorMRParser.ForceConstant)
                self.state = 1453
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1452
                    self.match(XplorMRParser.Equ_op)


                self.state = 1455
                self.match(XplorMRParser.Simple_name)
                self.state = 1456
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1457
                self.match(XplorMRParser.Nrestraints)
                self.state = 1459
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1458
                    self.match(XplorMRParser.Equ_op)


                self.state = 1461
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1462
                self.match(XplorMRParser.Potential)
                self.state = 1464
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op_P:
                    self.state = 1463
                    self.match(XplorMRParser.Equ_op_P)


                self.state = 1466
                self.match(XplorMRParser.Simple_name_P)
                self.state = 1467
                self.match(XplorMRParser.Potential_types)
                pass
            elif token in [XplorMRParser.Kconst]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1468
                self.match(XplorMRParser.Kconst)
                self.state = 1470
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1469
                    self.match(XplorMRParser.Equ_op)


                self.state = 1472
                self.match(XplorMRParser.Simple_name)
                self.state = 1473
                self.number_s()
                pass
            elif token in [XplorMRParser.Omega]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1474
                self.match(XplorMRParser.Omega)
                self.state = 1476
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1475
                    self.match(XplorMRParser.Equ_op)


                self.state = 1478
                self.match(XplorMRParser.Simple_name)
                self.state = 1479
                self.number_s()
                pass
            elif token in [XplorMRParser.Tauc]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1480
                self.match(XplorMRParser.Tauc)
                self.state = 1482
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1481
                    self.match(XplorMRParser.Equ_op)


                self.state = 1484
                self.match(XplorMRParser.Simple_name)
                self.state = 1485
                self.number_s()
                self.state = 1486
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1488
                self.match(XplorMRParser.Print)
                self.state = 1489
                self.match(XplorMRParser.Threshold)
                self.state = 1490
                self.number_s()
                self.state = 1494
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1491
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1492
                    self.match(XplorMRParser.Classification)
                    self.state = 1493
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1496
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Debug]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1497
                self.match(XplorMRParser.Debug)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pre_assignContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(XplorMRParser.Assign, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPre_assign" ):
                listener.enterPre_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPre_assign" ):
                listener.exitPre_assign(self)




    def pre_assign(self):

        localctx = XplorMRParser.Pre_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_pre_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1500
            self.match(XplorMRParser.Assign)
            self.state = 1501
            self.selection()
            self.state = 1502
            self.selection()
            self.state = 1503
            self.number()
            self.state = 1504
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcs_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pcs_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pcs_assignContext,0)


        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Tolerance(self):
            return self.getToken(XplorMRParser.Tolerance, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Save(self):
            return self.getToken(XplorMRParser.Save, 0)

        def Fmed(self):
            return self.getToken(XplorMRParser.Fmed, 0)

        def ErrOn(self):
            return self.getToken(XplorMRParser.ErrOn, 0)

        def ErrOff(self):
            return self.getToken(XplorMRParser.ErrOff, 0)

        def Fon(self):
            return self.getToken(XplorMRParser.Fon, 0)

        def Foff(self):
            return self.getToken(XplorMRParser.Foff, 0)

        def Son(self):
            return self.getToken(XplorMRParser.Son, 0)

        def Soff(self):
            return self.getToken(XplorMRParser.Soff, 0)

        def Frun(self):
            return self.getToken(XplorMRParser.Frun, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPcs_statement" ):
                listener.enterPcs_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPcs_statement" ):
                listener.exitPcs_statement(self)




    def pcs_statement(self):

        localctx = XplorMRParser.Pcs_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_pcs_statement)
        try:
            self.state = 1542
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1506
                self.pcs_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1507
                self.match(XplorMRParser.Classification)
                self.state = 1508
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1509
                self.match(XplorMRParser.Tolerance)
                self.state = 1510
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1511
                self.match(XplorMRParser.Coefficients)
                self.state = 1512
                self.number_s()
                self.state = 1513
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1515
                self.match(XplorMRParser.ForceConstant)
                self.state = 1516
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1517
                self.match(XplorMRParser.Nrestraints)
                self.state = 1518
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1519
                self.match(XplorMRParser.Print)
                self.state = 1520
                self.match(XplorMRParser.Threshold)
                self.state = 1521
                self.number_s()
                self.state = 1525
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1522
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1523
                    self.match(XplorMRParser.Classification)
                    self.state = 1524
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1527
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1528
                self.match(XplorMRParser.Save)
                self.state = 1529
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1530
                self.match(XplorMRParser.Fmed)
                self.state = 1531
                self.number_s()
                self.state = 1532
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1534
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1535
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1536
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1537
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1538
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1539
                self.match(XplorMRParser.Soff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1540
                self.match(XplorMRParser.Frun)
                self.state = 1541
                self.match(XplorMRParser.Integer)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcs_assignContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(XplorMRParser.Assign, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPcs_assign" ):
                listener.enterPcs_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPcs_assign" ):
                listener.exitPcs_assign(self)




    def pcs_assign(self):

        localctx = XplorMRParser.Pcs_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_pcs_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1544
            self.match(XplorMRParser.Assign)
            self.state = 1545
            self.selection()
            self.state = 1546
            self.selection()
            self.state = 1547
            self.selection()
            self.state = 1548
            self.selection()
            self.state = 1549
            self.selection()
            self.state = 1550
            self.number()
            self.state = 1551
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Prdc_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def prdc_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Prdc_assignContext,0)


        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Tolerance(self):
            return self.getToken(XplorMRParser.Tolerance, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_sContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_sContext,i)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def ErrOn(self):
            return self.getToken(XplorMRParser.ErrOn, 0)

        def ErrOff(self):
            return self.getToken(XplorMRParser.ErrOff, 0)

        def Fmed(self):
            return self.getToken(XplorMRParser.Fmed, 0)

        def Fon(self):
            return self.getToken(XplorMRParser.Fon, 0)

        def Foff(self):
            return self.getToken(XplorMRParser.Foff, 0)

        def Frun(self):
            return self.getToken(XplorMRParser.Frun, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Save(self):
            return self.getToken(XplorMRParser.Save, 0)

        def Son(self):
            return self.getToken(XplorMRParser.Son, 0)

        def Soff(self):
            return self.getToken(XplorMRParser.Soff, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrdc_statement" ):
                listener.enterPrdc_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrdc_statement" ):
                listener.exitPrdc_statement(self)




    def prdc_statement(self):

        localctx = XplorMRParser.Prdc_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_prdc_statement)
        try:
            self.state = 1579
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1553
                self.prdc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1554
                self.match(XplorMRParser.Classification)
                self.state = 1555
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1556
                self.match(XplorMRParser.Tolerance)
                self.state = 1557
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1558
                self.match(XplorMRParser.Coefficients)
                self.state = 1559
                self.number_s()
                self.state = 1560
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1562
                self.match(XplorMRParser.ForceConstant)
                self.state = 1563
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1564
                self.match(XplorMRParser.Nrestraints)
                self.state = 1565
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1566
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1567
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1568
                self.match(XplorMRParser.Fmed)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1569
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1570
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1571
                self.match(XplorMRParser.Frun)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1572
                self.match(XplorMRParser.Print)
                self.state = 1573
                self.match(XplorMRParser.Threshold)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1574
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1575
                self.match(XplorMRParser.Save)
                self.state = 1576
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1577
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1578
                self.match(XplorMRParser.Soff)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Prdc_assignContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(XplorMRParser.Assign, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrdc_assign" ):
                listener.enterPrdc_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrdc_assign" ):
                listener.exitPrdc_assign(self)




    def prdc_assign(self):

        localctx = XplorMRParser.Prdc_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_prdc_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1581
            self.match(XplorMRParser.Assign)
            self.state = 1582
            self.selection()
            self.state = 1583
            self.selection()
            self.state = 1584
            self.selection()
            self.state = 1585
            self.selection()
            self.state = 1586
            self.selection()
            self.state = 1587
            self.selection()
            self.state = 1588
            self.number()
            self.state = 1589
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Porientation_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def porientation_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Porientation_assignContext,0)


        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPorientation_statement" ):
                listener.enterPorientation_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPorientation_statement" ):
                listener.exitPorientation_statement(self)




    def porientation_statement(self):

        localctx = XplorMRParser.Porientation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_porientation_statement)
        try:
            self.state = 1602
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1591
                self.porientation_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1592
                self.match(XplorMRParser.Classification)
                self.state = 1593
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1594
                self.match(XplorMRParser.ForceConstant)
                self.state = 1595
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1596
                self.match(XplorMRParser.Nrestraints)
                self.state = 1597
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1598
                self.match(XplorMRParser.Print)
                self.state = 1599
                self.match(XplorMRParser.Threshold)
                self.state = 1600
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1601
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Porientation_assignContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(XplorMRParser.Assign, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPorientation_assign" ):
                listener.enterPorientation_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPorientation_assign" ):
                listener.exitPorientation_assign(self)




    def porientation_assign(self):

        localctx = XplorMRParser.Porientation_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_porientation_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1604
            self.match(XplorMRParser.Assign)
            self.state = 1605
            self.selection()
            self.state = 1606
            self.selection()
            self.state = 1607
            self.number()
            self.state = 1608
            self.number()
            self.state = 1609
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pccr_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def pccr_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pccr_assignContext,0)


        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def Weip(self):
            return self.getToken(XplorMRParser.Weip, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Coefficients(self):
            return self.getToken(XplorMRParser.Coefficients, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def Frun(self):
            return self.getToken(XplorMRParser.Frun, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPccr_statement" ):
                listener.enterPccr_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPccr_statement" ):
                listener.exitPccr_statement(self)




    def pccr_statement(self):

        localctx = XplorMRParser.Pccr_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_pccr_statement)
        try:
            self.state = 1628
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1611
                self.pccr_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1612
                self.match(XplorMRParser.Classification)
                self.state = 1613
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Weip]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1614
                self.match(XplorMRParser.Weip)
                self.state = 1615
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1616
                self.match(XplorMRParser.Coefficients)
                self.state = 1617
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1618
                self.match(XplorMRParser.ForceConstant)
                self.state = 1619
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1620
                self.match(XplorMRParser.Nrestraints)
                self.state = 1621
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1622
                self.match(XplorMRParser.Print)
                self.state = 1623
                self.match(XplorMRParser.Threshold)
                self.state = 1624
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1625
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1626
                self.match(XplorMRParser.Frun)
                self.state = 1627
                self.match(XplorMRParser.Integer)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pccr_assignContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(XplorMRParser.Assign, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPccr_assign" ):
                listener.enterPccr_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPccr_assign" ):
                listener.exitPccr_assign(self)




    def pccr_assign(self):

        localctx = XplorMRParser.Pccr_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_pccr_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1630
            self.match(XplorMRParser.Assign)
            self.state = 1631
            self.selection()
            self.state = 1632
            self.selection()
            self.state = 1633
            self.selection()
            self.state = 1634
            self.number()
            self.state = 1635
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def hbond_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_assignContext,0)


        def Classification(self):
            return self.getToken(XplorMRParser.Classification, 0)

        def Simple_name(self):
            return self.getToken(XplorMRParser.Simple_name, 0)

        def ForceConstant(self):
            return self.getToken(XplorMRParser.ForceConstant, 0)

        def number_s(self):
            return self.getTypedRuleContext(XplorMRParser.Number_sContext,0)


        def Nrestraints(self):
            return self.getToken(XplorMRParser.Nrestraints, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def Print(self):
            return self.getToken(XplorMRParser.Print, 0)

        def Threshold(self):
            return self.getToken(XplorMRParser.Threshold, 0)

        def Reset(self):
            return self.getToken(XplorMRParser.Reset, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHbond_statement" ):
                listener.enterHbond_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHbond_statement" ):
                listener.exitHbond_statement(self)




    def hbond_statement(self):

        localctx = XplorMRParser.Hbond_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_hbond_statement)
        try:
            self.state = 1648
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1637
                self.hbond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1638
                self.match(XplorMRParser.Classification)
                self.state = 1639
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1640
                self.match(XplorMRParser.ForceConstant)
                self.state = 1641
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1642
                self.match(XplorMRParser.Nrestraints)
                self.state = 1643
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1644
                self.match(XplorMRParser.Print)
                self.state = 1645
                self.match(XplorMRParser.Threshold)
                self.state = 1646
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1647
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_assignContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Assign(self):
            return self.getToken(XplorMRParser.Assign, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_assign

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterHbond_assign" ):
                listener.enterHbond_assign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitHbond_assign" ):
                listener.exitHbond_assign(self)




    def hbond_assign(self):

        localctx = XplorMRParser.Hbond_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_hbond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1650
            self.match(XplorMRParser.Assign)
            self.state = 1651
            self.selection()
            self.state = 1652
            self.selection()
            self.state = 1653
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_paren(self):
            return self.getToken(XplorMRParser.L_paren, 0)

        def selection_expression(self):
            return self.getTypedRuleContext(XplorMRParser.Selection_expressionContext,0)


        def R_paren(self):
            return self.getToken(XplorMRParser.R_paren, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_selection

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelection" ):
                listener.enterSelection(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelection" ):
                listener.exitSelection(self)




    def selection(self):

        localctx = XplorMRParser.SelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_selection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1655
            self.match(XplorMRParser.L_paren)
            self.state = 1656
            self.selection_expression()
            self.state = 1657
            self.match(XplorMRParser.R_paren)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Selection_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.TermContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.TermContext,i)


        def Or_op(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Or_op)
            else:
                return self.getToken(XplorMRParser.Or_op, i)

        def getRuleIndex(self):
            return XplorMRParser.RULE_selection_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelection_expression" ):
                listener.enterSelection_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelection_expression" ):
                listener.exitSelection_expression(self)




    def selection_expression(self):

        localctx = XplorMRParser.Selection_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_selection_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1659
            self.term()
            self.state = 1664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 1660
                self.match(XplorMRParser.Or_op)
                self.state = 1661
                self.term()
                self.state = 1666
                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):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.FactorContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.FactorContext,i)


        def And_op(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.And_op)
            else:
                return self.getToken(XplorMRParser.And_op, i)

        def getRuleIndex(self):
            return XplorMRParser.RULE_term

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTerm" ):
                listener.enterTerm(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTerm" ):
                listener.exitTerm(self)




    def term(self):

        localctx = XplorMRParser.TermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1667
            self.factor(0)
            self.state = 1672
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.And_op:
                self.state = 1668
                self.match(XplorMRParser.And_op)
                self.state = 1669
                self.factor(0)
                self.state = 1674
                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):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_paren(self):
            return self.getToken(XplorMRParser.L_paren, 0)

        def selection_expression(self):
            return self.getTypedRuleContext(XplorMRParser.Selection_expressionContext,0)


        def R_paren(self):
            return self.getToken(XplorMRParser.R_paren, 0)

        def All(self):
            return self.getToken(XplorMRParser.All, 0)

        def Atom(self):
            return self.getToken(XplorMRParser.Atom, 0)

        def Simple_names(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Simple_names)
            else:
                return self.getToken(XplorMRParser.Simple_names, i)

        def Simple_name(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Simple_name)
            else:
                return self.getToken(XplorMRParser.Simple_name, i)

        def Integers(self):
            return self.getToken(XplorMRParser.Integers, 0)

        def Integer(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Integer)
            else:
                return self.getToken(XplorMRParser.Integer, i)

        def Attribute(self):
            return self.getToken(XplorMRParser.Attribute, 0)

        def Attr_properties(self):
            return self.getToken(XplorMRParser.Attr_properties, 0)

        def Comparison_ops(self):
            return self.getToken(XplorMRParser.Comparison_ops, 0)

        def number_f(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Number_fContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Number_fContext,i)


        def Abs(self):
            return self.getToken(XplorMRParser.Abs, 0)

        def BondedTo(self):
            return self.getToken(XplorMRParser.BondedTo, 0)

        def factor(self):
            return self.getTypedRuleContext(XplorMRParser.FactorContext,0)


        def ByGroup(self):
            return self.getToken(XplorMRParser.ByGroup, 0)

        def ByRes(self):
            return self.getToken(XplorMRParser.ByRes, 0)

        def Chemical(self):
            return self.getToken(XplorMRParser.Chemical, 0)

        def Colon(self):
            return self.getToken(XplorMRParser.Colon, 0)

        def Hydrogen(self):
            return self.getToken(XplorMRParser.Hydrogen, 0)

        def Id(self):
            return self.getToken(XplorMRParser.Id, 0)

        def Known(self):
            return self.getToken(XplorMRParser.Known, 0)

        def Name(self):
            return self.getToken(XplorMRParser.Name, 0)

        def Not_op(self):
            return self.getToken(XplorMRParser.Not_op, 0)

        def Point(self):
            return self.getToken(XplorMRParser.Point, 0)

        def Cut(self):
            return self.getToken(XplorMRParser.Cut, 0)

        def Comma(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Comma)
            else:
                return self.getToken(XplorMRParser.Comma, i)

        def Tail(self):
            return self.getToken(XplorMRParser.Tail, 0)

        def selection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.SelectionContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.SelectionContext,i)


        def Equ_op(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Equ_op)
            else:
                return self.getToken(XplorMRParser.Equ_op, i)

        def Head(self):
            return self.getToken(XplorMRParser.Head, 0)

        def Previous(self):
            return self.getToken(XplorMRParser.Previous, 0)

        def Pseudo(self):
            return self.getToken(XplorMRParser.Pseudo, 0)

        def Residue(self):
            return self.getToken(XplorMRParser.Residue, 0)

        def Resname(self):
            return self.getToken(XplorMRParser.Resname, 0)

        def SegIdentifier(self):
            return self.getToken(XplorMRParser.SegIdentifier, 0)

        def Double_quote_string(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Double_quote_string)
            else:
                return self.getToken(XplorMRParser.Double_quote_string, i)

        def Store_1(self):
            return self.getToken(XplorMRParser.Store_1, 0)

        def Store_2(self):
            return self.getToken(XplorMRParser.Store_2, 0)

        def Store_3(self):
            return self.getToken(XplorMRParser.Store_3, 0)

        def Store_4(self):
            return self.getToken(XplorMRParser.Store_4, 0)

        def Store_5(self):
            return self.getToken(XplorMRParser.Store_5, 0)

        def Store_6(self):
            return self.getToken(XplorMRParser.Store_6, 0)

        def Store_7(self):
            return self.getToken(XplorMRParser.Store_7, 0)

        def Store_8(self):
            return self.getToken(XplorMRParser.Store_8, 0)

        def Store_9(self):
            return self.getToken(XplorMRParser.Store_9, 0)

        def Tag(self):
            return self.getToken(XplorMRParser.Tag, 0)

        def Around(self):
            return self.getToken(XplorMRParser.Around, 0)

        def Saround(self):
            return self.getToken(XplorMRParser.Saround, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_factor

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFactor" ):
                listener.enterFactor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFactor" ):
                listener.exitFactor(self)



    def factor(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = XplorMRParser.FactorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 176
        self.enterRecursionRule(localctx, 176, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1802
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1676
                self.match(XplorMRParser.L_paren)
                self.state = 1677
                self.selection_expression()
                self.state = 1678
                self.match(XplorMRParser.R_paren)
                pass

            elif la_ == 2:
                self.state = 1680
                self.match(XplorMRParser.All)
                pass

            elif la_ == 3:
                self.state = 1681
                self.match(XplorMRParser.Atom)
                self.state = 1682
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Simple_name or _la==XplorMRParser.Simple_names):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1683
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Integers):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1684
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Simple_name or _la==XplorMRParser.Simple_names):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 4:
                self.state = 1685
                self.match(XplorMRParser.Attribute)
                self.state = 1687
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Abs:
                    self.state = 1686
                    self.match(XplorMRParser.Abs)


                self.state = 1689
                self.match(XplorMRParser.Attr_properties)
                self.state = 1690
                self.match(XplorMRParser.Comparison_ops)
                self.state = 1691
                self.number_f()
                pass

            elif la_ == 5:
                self.state = 1692
                self.match(XplorMRParser.BondedTo)
                self.state = 1693
                self.factor(27)
                pass

            elif la_ == 6:
                self.state = 1694
                self.match(XplorMRParser.ByGroup)
                self.state = 1695
                self.factor(26)
                pass

            elif la_ == 7:
                self.state = 1696
                self.match(XplorMRParser.ByRes)
                self.state = 1697
                self.factor(25)
                pass

            elif la_ == 8:
                self.state = 1698
                self.match(XplorMRParser.Chemical)
                self.state = 1705
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1699
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1700
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1703
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
                    if la_ == 1:
                        self.state = 1701
                        self.match(XplorMRParser.Colon)
                        self.state = 1702
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                self.state = 1707
                self.match(XplorMRParser.Hydrogen)
                pass

            elif la_ == 10:
                self.state = 1708
                self.match(XplorMRParser.Id)
                self.state = 1709
                self.match(XplorMRParser.Integer)
                pass

            elif la_ == 11:
                self.state = 1710
                self.match(XplorMRParser.Known)
                pass

            elif la_ == 12:
                self.state = 1711
                self.match(XplorMRParser.Name)
                self.state = 1718
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1712
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1713
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1716
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                    if la_ == 1:
                        self.state = 1714
                        self.match(XplorMRParser.Colon)
                        self.state = 1715
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 13:
                self.state = 1720
                self.match(XplorMRParser.Not_op)
                self.state = 1721
                self.factor(19)
                pass

            elif la_ == 14:
                self.state = 1722
                self.match(XplorMRParser.Point)
                self.state = 1723
                self.match(XplorMRParser.L_paren)
                self.state = 1724
                self.number_f()
                self.state = 1726
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1725
                    self.match(XplorMRParser.Comma)


                self.state = 1728
                self.number_f()
                self.state = 1730
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1729
                    self.match(XplorMRParser.Comma)


                self.state = 1732
                self.number_f()
                self.state = 1733
                self.match(XplorMRParser.R_paren)
                self.state = 1734
                self.match(XplorMRParser.Cut)
                self.state = 1735
                self.number_f()
                pass

            elif la_ == 15:
                self.state = 1737
                self.match(XplorMRParser.Point)
                self.state = 1738
                self.match(XplorMRParser.L_paren)
                self.state = 1739
                self.match(XplorMRParser.Tail)
                self.state = 1741
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1740
                    self.match(XplorMRParser.Equ_op)


                self.state = 1743
                self.selection()
                self.state = 1745
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1744
                    self.match(XplorMRParser.Comma)


                self.state = 1752
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Head:
                    self.state = 1747
                    self.match(XplorMRParser.Head)
                    self.state = 1749
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==XplorMRParser.Equ_op:
                        self.state = 1748
                        self.match(XplorMRParser.Equ_op)


                    self.state = 1751
                    self.selection()


                self.state = 1754
                self.match(XplorMRParser.R_paren)
                self.state = 1755
                self.match(XplorMRParser.Cut)
                self.state = 1756
                self.number_f()
                pass

            elif la_ == 16:
                self.state = 1758
                self.match(XplorMRParser.Previous)
                pass

            elif la_ == 17:
                self.state = 1759
                self.match(XplorMRParser.Pseudo)
                pass

            elif la_ == 18:
                self.state = 1760
                self.match(XplorMRParser.Residue)
                self.state = 1767
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Integers]:
                    self.state = 1761
                    self.match(XplorMRParser.Integers)
                    pass
                elif token in [XplorMRParser.Integer]:
                    self.state = 1762
                    self.match(XplorMRParser.Integer)
                    self.state = 1765
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
                    if la_ == 1:
                        self.state = 1763
                        self.match(XplorMRParser.Colon)
                        self.state = 1764
                        self.match(XplorMRParser.Integer)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 19:
                self.state = 1769
                self.match(XplorMRParser.Resname)
                self.state = 1776
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1770
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1771
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1774
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
                    if la_ == 1:
                        self.state = 1772
                        self.match(XplorMRParser.Colon)
                        self.state = 1773
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 20:
                self.state = 1778
                self.match(XplorMRParser.SegIdentifier)
                self.state = 1790
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1779
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1780
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1783
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                    if la_ == 1:
                        self.state = 1781
                        self.match(XplorMRParser.Colon)
                        self.state = 1782
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Double_quote_string]:
                    self.state = 1785
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 1788
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
                    if la_ == 1:
                        self.state = 1786
                        self.match(XplorMRParser.Colon)
                        self.state = 1787
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 21:
                self.state = 1792
                self.match(XplorMRParser.Store_1)
                pass

            elif la_ == 22:
                self.state = 1793
                self.match(XplorMRParser.Store_2)
                pass

            elif la_ == 23:
                self.state = 1794
                self.match(XplorMRParser.Store_3)
                pass

            elif la_ == 24:
                self.state = 1795
                self.match(XplorMRParser.Store_4)
                pass

            elif la_ == 25:
                self.state = 1796
                self.match(XplorMRParser.Store_5)
                pass

            elif la_ == 26:
                self.state = 1797
                self.match(XplorMRParser.Store_6)
                pass

            elif la_ == 27:
                self.state = 1798
                self.match(XplorMRParser.Store_7)
                pass

            elif la_ == 28:
                self.state = 1799
                self.match(XplorMRParser.Store_8)
                pass

            elif la_ == 29:
                self.state = 1800
                self.match(XplorMRParser.Store_9)
                pass

            elif la_ == 30:
                self.state = 1801
                self.match(XplorMRParser.Tag)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1812
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,146,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 = 1810
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                    if la_ == 1:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1804
                        if not self.precpred(self._ctx, 30):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 30)")
                        self.state = 1805
                        self.match(XplorMRParser.Around)
                        self.state = 1806
                        self.number_f()
                        pass

                    elif la_ == 2:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1807
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1808
                        self.match(XplorMRParser.Saround)
                        self.state = 1809
                        self.number_f()
                        pass

             
                self.state = 1814
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,146,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):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber" ):
                listener.enterNumber(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber" ):
                listener.exitNumber(self)




    def number(self):

        localctx = XplorMRParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1815
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_fContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_f

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber_f" ):
                listener.enterNumber_f(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber_f" ):
                listener.exitNumber_f(self)




    def number_f(self):

        localctx = XplorMRParser.Number_fContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_number_f)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1817
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_sContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_s

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber_s" ):
                listener.enterNumber_s(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber_s" ):
                listener.exitNumber_s(self)




    def number_s(self):

        localctx = XplorMRParser.Number_sContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_number_s)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1819
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_aContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_a

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber_a" ):
                listener.enterNumber_a(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber_a" ):
                listener.exitNumber_a(self)




    def number_a(self):

        localctx = XplorMRParser.Number_aContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_number_a)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1821
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Flag_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Flags(self):
            return self.getToken(XplorMRParser.Flags, 0)

        def Include(self):
            return self.getToken(XplorMRParser.Include, 0)

        def End_F(self):
            return self.getToken(XplorMRParser.End_F, 0)

        def Exclude(self):
            return self.getToken(XplorMRParser.Exclude, 0)

        def Class_name(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Class_name)
            else:
                return self.getToken(XplorMRParser.Class_name, i)

        def Any_class(self):
            return self.getToken(XplorMRParser.Any_class, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_flag_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFlag_statement" ):
                listener.enterFlag_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFlag_statement" ):
                listener.exitFlag_statement(self)




    def flag_statement(self):

        localctx = XplorMRParser.Flag_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_flag_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1823
            self.match(XplorMRParser.Flags)
            self.state = 1834
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Exclude:
                self.state = 1824
                self.match(XplorMRParser.Exclude)
                self.state = 1832
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Include, XplorMRParser.Class_name]:
                    self.state = 1828
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==XplorMRParser.Class_name:
                        self.state = 1825
                        self.match(XplorMRParser.Class_name)
                        self.state = 1830
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [XplorMRParser.Any_class]:
                    self.state = 1831
                    self.match(XplorMRParser.Any_class)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 1836
            self.match(XplorMRParser.Include)
            self.state = 1840
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Class_name:
                self.state = 1837
                self.match(XplorMRParser.Class_name)
                self.state = 1842
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1843
            self.match(XplorMRParser.End_F)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Vector(self):
            return self.getToken(XplorMRParser.Vector, 0)

        def vector_mode(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_modeContext,0)


        def selection(self):
            return self.getTypedRuleContext(XplorMRParser.SelectionContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector_statement" ):
                listener.enterVector_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector_statement" ):
                listener.exitVector_statement(self)




    def vector_statement(self):

        localctx = XplorMRParser.Vector_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_vector_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1845
            self.match(XplorMRParser.Vector)
            self.state = 1846
            self.vector_mode()
            self.state = 1847
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_modeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def vector_expression(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_expressionContext,0)


        def R_paren_VE(self):
            return self.getToken(XplorMRParser.R_paren_VE, 0)

        def Do_Lp(self):
            return self.getToken(XplorMRParser.Do_Lp, 0)

        def Identify_Lp(self):
            return self.getToken(XplorMRParser.Identify_Lp, 0)

        def Show(self):
            return self.getToken(XplorMRParser.Show, 0)

        def vector_show_property(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_show_propertyContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_mode

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector_mode" ):
                listener.enterVector_mode(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector_mode" ):
                listener.exitVector_mode(self)




    def vector_mode(self):

        localctx = XplorMRParser.Vector_modeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_vector_mode)
        self._la = 0 # Token type
        try:
            self.state = 1855
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Do_Lp, XplorMRParser.Identify_Lp]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1849
                _la = self._input.LA(1)
                if not(_la==XplorMRParser.Do_Lp or _la==XplorMRParser.Identify_Lp):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1850
                self.vector_expression()
                self.state = 1851
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Show]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1853
                self.match(XplorMRParser.Show)
                self.state = 1854
                self.vector_show_property()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Atom_properties_VE(self):
            return self.getToken(XplorMRParser.Atom_properties_VE, 0)

        def Equ_op_VE(self):
            return self.getToken(XplorMRParser.Equ_op_VE, 0)

        def vector_operation(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_operationContext,0)


        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector_expression" ):
                listener.enterVector_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector_expression" ):
                listener.exitVector_expression(self)




    def vector_expression(self):

        localctx = XplorMRParser.Vector_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_vector_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1857
            self.match(XplorMRParser.Atom_properties_VE)
            self.state = 1860
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Equ_op_VE:
                self.state = 1858
                self.match(XplorMRParser.Equ_op_VE)
                self.state = 1859
                self.vector_operation()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_operationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def vflc(self):
            return self.getTypedRuleContext(XplorMRParser.VflcContext,0)


        def vector_operation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Vector_operationContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Vector_operationContext,i)


        def Add_op_VE(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Add_op_VE)
            else:
                return self.getToken(XplorMRParser.Add_op_VE, i)

        def Sub_op_VE(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Sub_op_VE)
            else:
                return self.getToken(XplorMRParser.Sub_op_VE, i)

        def Mul_op_VE(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Mul_op_VE)
            else:
                return self.getToken(XplorMRParser.Mul_op_VE, i)

        def Div_op_VE(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Div_op_VE)
            else:
                return self.getToken(XplorMRParser.Div_op_VE, i)

        def Exp_op_VE(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Exp_op_VE)
            else:
                return self.getToken(XplorMRParser.Exp_op_VE, i)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_operation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector_operation" ):
                listener.enterVector_operation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector_operation" ):
                listener.exitVector_operation(self)




    def vector_operation(self):

        localctx = XplorMRParser.Vector_operationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_vector_operation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1862
            self.vflc()
            self.state = 1867
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1863
                    _la = self._input.LA(1)
                    if not(((((_la - 204)) & ~0x3f) == 0 and ((1 << (_la - 204)) & ((1 << (XplorMRParser.Add_op_VE - 204)) | (1 << (XplorMRParser.Sub_op_VE - 204)) | (1 << (XplorMRParser.Mul_op_VE - 204)) | (1 << (XplorMRParser.Div_op_VE - 204)) | (1 << (XplorMRParser.Exp_op_VE - 204)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1864
                    self.vector_operation() 
                self.state = 1869
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VflcContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Atom_properties_VE(self):
            return self.getToken(XplorMRParser.Atom_properties_VE, 0)

        def vector_func_call(self):
            return self.getTypedRuleContext(XplorMRParser.Vector_func_callContext,0)


        def Integer_VE(self):
            return self.getToken(XplorMRParser.Integer_VE, 0)

        def Real_VE(self):
            return self.getToken(XplorMRParser.Real_VE, 0)

        def Simple_name_VE(self):
            return self.getToken(XplorMRParser.Simple_name_VE, 0)

        def Double_quote_string_VE(self):
            return self.getToken(XplorMRParser.Double_quote_string_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vflc

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVflc" ):
                listener.enterVflc(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVflc" ):
                listener.exitVflc(self)




    def vflc(self):

        localctx = XplorMRParser.VflcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_vflc)
        try:
            self.state = 1876
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Atom_properties_VE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1870
                self.match(XplorMRParser.Atom_properties_VE)
                pass
            elif token in [XplorMRParser.Abs_VE, XplorMRParser.Acos_VE, XplorMRParser.Cos_VE, XplorMRParser.Decode_VE, XplorMRParser.Encode_VE, XplorMRParser.Exp_VE, XplorMRParser.Gauss_VE, XplorMRParser.Heavy_VE, XplorMRParser.Int_VE, XplorMRParser.Log10_VE, XplorMRParser.Log_VE, XplorMRParser.Max_VE, XplorMRParser.Maxw_VE, XplorMRParser.Min_VE, XplorMRParser.Mod_VE, XplorMRParser.Norm_VE, XplorMRParser.Random_VE, XplorMRParser.Sign_VE, XplorMRParser.Sin_VE, XplorMRParser.Sqrt_VE, XplorMRParser.Tan_VE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1871
                self.vector_func_call()
                pass
            elif token in [XplorMRParser.Integer_VE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1872
                self.match(XplorMRParser.Integer_VE)
                pass
            elif token in [XplorMRParser.Real_VE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1873
                self.match(XplorMRParser.Real_VE)
                pass
            elif token in [XplorMRParser.Simple_name_VE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1874
                self.match(XplorMRParser.Simple_name_VE)
                pass
            elif token in [XplorMRParser.Double_quote_string_VE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1875
                self.match(XplorMRParser.Double_quote_string_VE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_func_callContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Abs_VE(self):
            return self.getToken(XplorMRParser.Abs_VE, 0)

        def L_paren_VF(self):
            return self.getToken(XplorMRParser.L_paren_VF, 0)

        def vflc(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.VflcContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.VflcContext,i)


        def R_paren_VE(self):
            return self.getToken(XplorMRParser.R_paren_VE, 0)

        def Acos_VE(self):
            return self.getToken(XplorMRParser.Acos_VE, 0)

        def Cos_VE(self):
            return self.getToken(XplorMRParser.Cos_VE, 0)

        def Decode_VE(self):
            return self.getToken(XplorMRParser.Decode_VE, 0)

        def Encode_VE(self):
            return self.getToken(XplorMRParser.Encode_VE, 0)

        def Exp_VE(self):
            return self.getToken(XplorMRParser.Exp_VE, 0)

        def Gauss_VE(self):
            return self.getToken(XplorMRParser.Gauss_VE, 0)

        def Heavy_VE(self):
            return self.getToken(XplorMRParser.Heavy_VE, 0)

        def Int_VE(self):
            return self.getToken(XplorMRParser.Int_VE, 0)

        def Log10_VE(self):
            return self.getToken(XplorMRParser.Log10_VE, 0)

        def Log_VE(self):
            return self.getToken(XplorMRParser.Log_VE, 0)

        def Max_VE(self):
            return self.getToken(XplorMRParser.Max_VE, 0)

        def Comma_VE(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Comma_VE)
            else:
                return self.getToken(XplorMRParser.Comma_VE, i)

        def Maxw_VE(self):
            return self.getToken(XplorMRParser.Maxw_VE, 0)

        def Min_VE(self):
            return self.getToken(XplorMRParser.Min_VE, 0)

        def Mod_VE(self):
            return self.getToken(XplorMRParser.Mod_VE, 0)

        def Norm_VE(self):
            return self.getToken(XplorMRParser.Norm_VE, 0)

        def Random_VE(self):
            return self.getToken(XplorMRParser.Random_VE, 0)

        def Sign_VE(self):
            return self.getToken(XplorMRParser.Sign_VE, 0)

        def Sin_VE(self):
            return self.getToken(XplorMRParser.Sin_VE, 0)

        def Sqrt_VE(self):
            return self.getToken(XplorMRParser.Sqrt_VE, 0)

        def Tan_VE(self):
            return self.getToken(XplorMRParser.Tan_VE, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_func_call

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector_func_call" ):
                listener.enterVector_func_call(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector_func_call" ):
                listener.exitVector_func_call(self)




    def vector_func_call(self):

        localctx = XplorMRParser.Vector_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_vector_func_call)
        self._la = 0 # Token type
        try:
            self.state = 1997
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Abs_VE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1878
                self.match(XplorMRParser.Abs_VE)
                self.state = 1879
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1880
                self.vflc()
                self.state = 1881
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Acos_VE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1883
                self.match(XplorMRParser.Acos_VE)
                self.state = 1884
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1885
                self.vflc()
                self.state = 1886
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Cos_VE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1888
                self.match(XplorMRParser.Cos_VE)
                self.state = 1889
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1890
                self.vflc()
                self.state = 1891
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Decode_VE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1893
                self.match(XplorMRParser.Decode_VE)
                self.state = 1894
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1895
                self.vflc()
                self.state = 1896
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Encode_VE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1898
                self.match(XplorMRParser.Encode_VE)
                self.state = 1899
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1900
                self.vflc()
                self.state = 1901
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Exp_VE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1903
                self.match(XplorMRParser.Exp_VE)
                self.state = 1904
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1905
                self.vflc()
                self.state = 1906
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Gauss_VE]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1908
                self.match(XplorMRParser.Gauss_VE)
                self.state = 1909
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1910
                self.vflc()
                self.state = 1911
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Heavy_VE]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1913
                self.match(XplorMRParser.Heavy_VE)
                self.state = 1914
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1915
                self.vflc()
                self.state = 1916
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Int_VE]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1918
                self.match(XplorMRParser.Int_VE)
                self.state = 1919
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1920
                self.vflc()
                self.state = 1921
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Log10_VE]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1923
                self.match(XplorMRParser.Log10_VE)
                self.state = 1924
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1925
                self.vflc()
                self.state = 1926
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Log_VE]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1928
                self.match(XplorMRParser.Log_VE)
                self.state = 1929
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1930
                self.vflc()
                self.state = 1931
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Max_VE]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1933
                self.match(XplorMRParser.Max_VE)
                self.state = 1934
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1935
                self.vflc()
                self.state = 1940
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Comma_VE:
                    self.state = 1936
                    self.match(XplorMRParser.Comma_VE)
                    self.state = 1937
                    self.vflc()
                    self.state = 1942
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1943
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Maxw_VE]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1945
                self.match(XplorMRParser.Maxw_VE)
                self.state = 1946
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1947
                self.vflc()
                self.state = 1948
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Min_VE]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1950
                self.match(XplorMRParser.Min_VE)
                self.state = 1951
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1952
                self.vflc()
                self.state = 1957
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Comma_VE:
                    self.state = 1953
                    self.match(XplorMRParser.Comma_VE)
                    self.state = 1954
                    self.vflc()
                    self.state = 1959
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1960
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Mod_VE]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1962
                self.match(XplorMRParser.Mod_VE)
                self.state = 1963
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1964
                self.vflc()
                self.state = 1965
                self.match(XplorMRParser.Comma_VE)
                self.state = 1966
                self.vflc()
                self.state = 1967
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Norm_VE]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1969
                self.match(XplorMRParser.Norm_VE)
                self.state = 1970
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1971
                self.vflc()
                self.state = 1972
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Random_VE]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1974
                self.match(XplorMRParser.Random_VE)
                self.state = 1975
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1976
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Sign_VE]:
                self.enterOuterAlt(localctx, 18)
                self.state = 1977
                self.match(XplorMRParser.Sign_VE)
                self.state = 1978
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1979
                self.vflc()
                self.state = 1980
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Sin_VE]:
                self.enterOuterAlt(localctx, 19)
                self.state = 1982
                self.match(XplorMRParser.Sin_VE)
                self.state = 1983
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1984
                self.vflc()
                self.state = 1985
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Sqrt_VE]:
                self.enterOuterAlt(localctx, 20)
                self.state = 1987
                self.match(XplorMRParser.Sqrt_VE)
                self.state = 1988
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1989
                self.vflc()
                self.state = 1990
                self.match(XplorMRParser.R_paren_VE)
                pass
            elif token in [XplorMRParser.Tan_VE]:
                self.enterOuterAlt(localctx, 21)
                self.state = 1992
                self.match(XplorMRParser.Tan_VE)
                self.state = 1993
                self.match(XplorMRParser.L_paren_VF)
                self.state = 1994
                self.vflc()
                self.state = 1995
                self.match(XplorMRParser.R_paren_VE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vector_show_propertyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_paren_VS(self):
            return self.getToken(XplorMRParser.L_paren_VS, 0)

        def Atom_properties_VS(self):
            return self.getToken(XplorMRParser.Atom_properties_VS, 0)

        def R_paren_VS(self):
            return self.getToken(XplorMRParser.R_paren_VS, 0)

        def Average_VS(self):
            return self.getToken(XplorMRParser.Average_VS, 0)

        def Element_VS(self):
            return self.getToken(XplorMRParser.Element_VS, 0)

        def Max_VS(self):
            return self.getToken(XplorMRParser.Max_VS, 0)

        def Min_VS(self):
            return self.getToken(XplorMRParser.Min_VS, 0)

        def Norm_VS(self):
            return self.getToken(XplorMRParser.Norm_VS, 0)

        def Rms_VS(self):
            return self.getToken(XplorMRParser.Rms_VS, 0)

        def Sum_VS(self):
            return self.getToken(XplorMRParser.Sum_VS, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_vector_show_property

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector_show_property" ):
                listener.enterVector_show_property(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector_show_property" ):
                listener.exitVector_show_property(self)




    def vector_show_property(self):

        localctx = XplorMRParser.Vector_show_propertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_vector_show_property)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1999
            _la = self._input.LA(1)
            if not(((((_la - 240)) & ~0x3f) == 0 and ((1 << (_la - 240)) & ((1 << (XplorMRParser.Average_VS - 240)) | (1 << (XplorMRParser.Element_VS - 240)) | (1 << (XplorMRParser.Max_VS - 240)) | (1 << (XplorMRParser.Min_VS - 240)) | (1 << (XplorMRParser.Norm_VS - 240)) | (1 << (XplorMRParser.Rms_VS - 240)) | (1 << (XplorMRParser.Sum_VS - 240)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 2000
            self.match(XplorMRParser.L_paren_VS)
            self.state = 2001
            self.match(XplorMRParser.Atom_properties_VS)
            self.state = 2002
            self.match(XplorMRParser.R_paren_VS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[88] = 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, 30)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 12)
         




