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

    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", "Noe_avr_methods", "Noe_potential", 
                      "Cutoff", "Cuton", "From", "To", "Restraints", "Dihedral", 
                      "Nassign", "Sanisotropy", "Coefficients", "ForceConstant", 
                      "Rdc_potential", "Xdipolar", "Dipolar", "Type", "Sign", 
                      "Average", "Rdc_dist_fix_types", "Rdc_avr_methods", 
                      "VectorAngle", "Cv", "Partition", "Tensor", "Anisotropy", 
                      "Rdc_anis_types", "Planar", "Group", "Initialize", 
                      "Selection", "Weight", "Xadc", "Expectation", "Size", 
                      "Zero", "Coupling", "DegEnergy", "Coupling_potential", 
                      "Carbon", "PhiStep", "PsiStep", "Rcoil", "Proton", 
                      "Observed", "Amides", "Carbons", "Nitrogens", "Oxygens", 
                      "RingAtoms", "AlphasAndAmides", "Error", "Rmsd_or_Not", 
                      "Ramachandran", "Gaussian", "Phase", "Quartic", "Shape", 
                      "Sort", "Gauss_or_Quart", "Dimensions", "Collapse", 
                      "Danisotropy", "Diff_anis_types", "Orient", "Height", 
                      "MaxGaussians", "NewGaussian", "Dcsa", "Sigma", "Csa_types", 
                      "Pcsa", "OneBond", "AngleDb", "DerivFlag", "Angle_dihedral", 
                      "Paramagnetic", "Kconst", "Omega", "Tauc", "Debug", 
                      "Xpcs", "Tolerance", "Save", "Fmed", "ErrOn", "ErrOff", 
                      "Fon", "Foff", "Son", "Soff", "Frun", "Xrdcoupling", 
                      "Xangle", "Xccr", "Weip", "Hbda", "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", "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", "Lt_op", "Gt_op", "Leq_op", "Geq_op", 
                      "Neq_op", "SPACE", "COMMENT", "LINE_COMMENT", "SET_VARIABLE", 
                      "Abs", "Attr_properties", "Comparison_ops", "SPACE_ATTR" ]

    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_dihedral_statement = 26
    RULE_dihedral_assign = 27
    RULE_sani_statement = 28
    RULE_sani_assign = 29
    RULE_xdip_statement = 30
    RULE_xdip_assign = 31
    RULE_vean_statement = 32
    RULE_vean_assign = 33
    RULE_tenso_statement = 34
    RULE_tenso_assign = 35
    RULE_anis_statement = 36
    RULE_anis_assign = 37
    RULE_planar_statement = 38
    RULE_group_statement = 39
    RULE_antidistance_statement = 40
    RULE_xadc_assign = 41
    RULE_coupling_statement = 42
    RULE_coup_assign = 43
    RULE_carbon_shift_statement = 44
    RULE_carbon_shift_assign = 45
    RULE_carbon_shift_rcoil = 46
    RULE_proton_shift_statement = 47
    RULE_observed = 48
    RULE_proton_shift_rcoil = 49
    RULE_proton_shift_anisotropy = 50
    RULE_proton_shift_amides = 51
    RULE_proton_shift_carbons = 52
    RULE_proton_shift_nitrogens = 53
    RULE_proton_shift_oxygens = 54
    RULE_proton_shift_ring_atoms = 55
    RULE_proton_shift_alphas_and_amides = 56
    RULE_ramachandran_statement = 57
    RULE_rama_assign = 58
    RULE_collapse_statement = 59
    RULE_coll_assign = 60
    RULE_diffusion_statement = 61
    RULE_dani_assign = 62
    RULE_orientation_statement = 63
    RULE_orie_assign = 64
    RULE_csa_statement = 65
    RULE_csa_assign = 66
    RULE_pcsa_statement = 67
    RULE_one_bond_coupling_statement = 68
    RULE_one_bond_assign = 69
    RULE_angle_db_statement = 70
    RULE_angle_db_assign = 71
    RULE_pre_statement = 72
    RULE_pre_assign = 73
    RULE_pcs_statement = 74
    RULE_pcs_assign = 75
    RULE_prdc_statement = 76
    RULE_prdc_assign = 77
    RULE_porientation_statement = 78
    RULE_porientation_assign = 79
    RULE_pccr_statement = 80
    RULE_pccr_assign = 81
    RULE_hbond_statement = 82
    RULE_hbond_assign = 83
    RULE_selection = 84
    RULE_selection_expression = 85
    RULE_term = 86
    RULE_factor = 87

    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", 
                   "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" ]

    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
    Noe_avr_methods=27
    Noe_potential=28
    Cutoff=29
    Cuton=30
    From=31
    To=32
    Restraints=33
    Dihedral=34
    Nassign=35
    Sanisotropy=36
    Coefficients=37
    ForceConstant=38
    Rdc_potential=39
    Xdipolar=40
    Dipolar=41
    Type=42
    Sign=43
    Average=44
    Rdc_dist_fix_types=45
    Rdc_avr_methods=46
    VectorAngle=47
    Cv=48
    Partition=49
    Tensor=50
    Anisotropy=51
    Rdc_anis_types=52
    Planar=53
    Group=54
    Initialize=55
    Selection=56
    Weight=57
    Xadc=58
    Expectation=59
    Size=60
    Zero=61
    Coupling=62
    DegEnergy=63
    Coupling_potential=64
    Carbon=65
    PhiStep=66
    PsiStep=67
    Rcoil=68
    Proton=69
    Observed=70
    Amides=71
    Carbons=72
    Nitrogens=73
    Oxygens=74
    RingAtoms=75
    AlphasAndAmides=76
    Error=77
    Rmsd_or_Not=78
    Ramachandran=79
    Gaussian=80
    Phase=81
    Quartic=82
    Shape=83
    Sort=84
    Gauss_or_Quart=85
    Dimensions=86
    Collapse=87
    Danisotropy=88
    Diff_anis_types=89
    Orient=90
    Height=91
    MaxGaussians=92
    NewGaussian=93
    Dcsa=94
    Sigma=95
    Csa_types=96
    Pcsa=97
    OneBond=98
    AngleDb=99
    DerivFlag=100
    Angle_dihedral=101
    Paramagnetic=102
    Kconst=103
    Omega=104
    Tauc=105
    Debug=106
    Xpcs=107
    Tolerance=108
    Save=109
    Fmed=110
    ErrOn=111
    ErrOff=112
    Fon=113
    Foff=114
    Son=115
    Soff=116
    Frun=117
    Xrdcoupling=118
    Xangle=119
    Xccr=120
    Weip=121
    Hbda=122
    All=123
    Around=124
    Atom=125
    Attribute=126
    BondedTo=127
    ByGroup=128
    ByRes=129
    Chemical=130
    Hydrogen=131
    Id=132
    Known=133
    Name=134
    Point=135
    Cut=136
    Previous=137
    Pseudo=138
    Residue=139
    Resname=140
    Saround=141
    SegIdentifier=142
    Store_1=143
    Store_2=144
    Store_3=145
    Store_4=146
    Store_5=147
    Store_6=148
    Store_7=149
    Store_8=150
    Store_9=151
    Tag=152
    Tail=153
    Head=154
    Or_op=155
    And_op=156
    Not_op=157
    Comma=158
    Complex=159
    Integer=160
    Logical=161
    Real=162
    Double_quote_string=163
    Simple_name=164
    Simple_names=165
    Integers=166
    L_paren=167
    R_paren=168
    Colon=169
    Equ_op=170
    Lt_op=171
    Gt_op=172
    Leq_op=173
    Geq_op=174
    Neq_op=175
    SPACE=176
    COMMENT=177
    LINE_COMMENT=178
    SET_VARIABLE=179
    Abs=180
    Attr_properties=181
    Comparison_ops=182
    SPACE_ATTR=183

    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 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 = 200
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Noe) | (1 << XplorMRParser.Restraints) | (1 << XplorMRParser.Sanisotropy) | (1 << XplorMRParser.Xdipolar) | (1 << XplorMRParser.Dipolar) | (1 << XplorMRParser.VectorAngle) | (1 << XplorMRParser.Tensor) | (1 << XplorMRParser.Anisotropy) | (1 << XplorMRParser.Xadc) | (1 << XplorMRParser.Coupling))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (XplorMRParser.Carbon - 65)) | (1 << (XplorMRParser.Proton - 65)) | (1 << (XplorMRParser.Ramachandran - 65)) | (1 << (XplorMRParser.Collapse - 65)) | (1 << (XplorMRParser.Danisotropy - 65)) | (1 << (XplorMRParser.Orient - 65)) | (1 << (XplorMRParser.Dcsa - 65)) | (1 << (XplorMRParser.Pcsa - 65)) | (1 << (XplorMRParser.OneBond - 65)) | (1 << (XplorMRParser.AngleDb - 65)) | (1 << (XplorMRParser.Paramagnetic - 65)) | (1 << (XplorMRParser.Xpcs - 65)) | (1 << (XplorMRParser.Xrdcoupling - 65)) | (1 << (XplorMRParser.Xangle - 65)) | (1 << (XplorMRParser.Xccr - 65)) | (1 << (XplorMRParser.Hbda - 65)))) != 0):
                self.state = 198
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 176
                    self.distance_restraint()
                    pass

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

            self.state = 206
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 203
                    self.noe_assign() 
                self.state = 208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

            self.state = 212
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 209
                    self.dihedral_assign() 
                self.state = 214
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

            self.state = 218
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 215
                    self.sani_assign() 
                self.state = 220
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)

            self.state = 224
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Group or _la==XplorMRParser.Initialize:
                self.state = 221
                self.planar_statement()
                self.state = 226
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 230
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 227
                    self.hbond_assign() 
                self.state = 232
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)

            self.state = 236
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 233
                    self.coup_assign() 
                self.state = 238
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

            self.state = 242
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 239
                    self.xadc_assign() 
                self.state = 244
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

            self.state = 248
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 245
                    self.coll_assign() 
                self.state = 250
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

            self.state = 254
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 251
                    self.csa_assign() 
                self.state = 256
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

            self.state = 260
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 257
                    self.pre_assign() 
                self.state = 262
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

            self.state = 266
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign:
                self.state = 263
                self.pcs_assign()
                self.state = 268
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 269
            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 noe_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Noe_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 271
            self.match(XplorMRParser.Noe)
            self.state = 272
            self.noe_statement()
            self.state = 273
            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 Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

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

        def dihedral_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Dihedral_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 275
            self.match(XplorMRParser.Restraints)
            self.state = 276
            self.match(XplorMRParser.Dihedral)
            self.state = 277
            self.dihedral_statement()
            self.state = 278
            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 sani_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Sani_statementContext,0)


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

        def xdip_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Xdip_statementContext,0)


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

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

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

        def vean_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Vean_statementContext,0)


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

        def tenso_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Tenso_statementContext,0)


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

        def anis_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Anis_statementContext,0)


        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 = 300
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Sanisotropy]:
                self.enterOuterAlt(localctx, 1)
                self.state = 280
                self.match(XplorMRParser.Sanisotropy)
                self.state = 281
                self.sani_statement()
                self.state = 282
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Xdipolar, XplorMRParser.Dipolar]:
                self.enterOuterAlt(localctx, 2)
                self.state = 284
                _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 = 285
                self.xdip_statement()
                self.state = 286
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.VectorAngle]:
                self.enterOuterAlt(localctx, 3)
                self.state = 288
                self.match(XplorMRParser.VectorAngle)
                self.state = 289
                self.vean_statement()
                self.state = 290
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Tensor]:
                self.enterOuterAlt(localctx, 4)
                self.state = 292
                self.match(XplorMRParser.Tensor)
                self.state = 293
                self.tenso_statement()
                self.state = 294
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Anisotropy]:
                self.enterOuterAlt(localctx, 5)
                self.state = 296
                self.match(XplorMRParser.Anisotropy)
                self.state = 297
                self.anis_statement()
                self.state = 298
                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 Restraints(self):
            return self.getToken(XplorMRParser.Restraints, 0)

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

        def planar_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Planar_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 302
            self.match(XplorMRParser.Restraints)
            self.state = 303
            self.match(XplorMRParser.Planar)
            self.state = 304
            self.planar_statement()
            self.state = 305
            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 antidistance_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Antidistance_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 307
            self.match(XplorMRParser.Xadc)
            self.state = 308
            self.antidistance_statement()
            self.state = 309
            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 coupling_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Coupling_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 311
            self.match(XplorMRParser.Coupling)
            self.state = 312
            self.coupling_statement()
            self.state = 313
            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 carbon_shift_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Carbon_shift_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 315
            self.match(XplorMRParser.Carbon)
            self.state = 316
            self.carbon_shift_statement()
            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 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 proton_shift_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319
            self.match(XplorMRParser.Proton)
            self.state = 320
            self.proton_shift_statement()
            self.state = 321
            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 ramachandran_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Ramachandran_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 323
            self.match(XplorMRParser.Ramachandran)
            self.state = 324
            self.ramachandran_statement()
            self.state = 325
            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 collapse_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Collapse_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(XplorMRParser.Collapse)
            self.state = 328
            self.collapse_statement()
            self.state = 329
            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 diffusion_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Diffusion_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 331
            self.match(XplorMRParser.Danisotropy)
            self.state = 332
            self.diffusion_statement()
            self.state = 333
            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 orientation_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Orientation_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 335
            self.match(XplorMRParser.Orient)
            self.state = 336
            self.orientation_statement()
            self.state = 337
            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 csa_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.match(XplorMRParser.Dcsa)
            self.state = 340
            self.csa_statement()
            self.state = 341
            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 pcsa_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Pcsa_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 343
            self.match(XplorMRParser.Pcsa)
            self.state = 344
            self.pcsa_statement()
            self.state = 345
            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 one_bond_coupling_statement(self):
            return self.getTypedRuleContext(XplorMRParser.One_bond_coupling_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 347
            self.match(XplorMRParser.OneBond)
            self.state = 348
            self.one_bond_coupling_statement()
            self.state = 349
            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 angle_db_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Angle_db_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 351
            self.match(XplorMRParser.AngleDb)
            self.state = 352
            self.angle_db_statement()
            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 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 pre_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Pre_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 355
            self.match(XplorMRParser.Paramagnetic)
            self.state = 356
            self.pre_statement()
            self.state = 357
            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 pcs_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Pcs_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 359
            self.match(XplorMRParser.Xpcs)
            self.state = 360
            self.pcs_statement()
            self.state = 361
            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 prdc_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Prdc_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 363
            self.match(XplorMRParser.Xrdcoupling)
            self.state = 364
            self.prdc_statement()
            self.state = 365
            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 porientation_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Porientation_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 367
            self.match(XplorMRParser.Xangle)
            self.state = 368
            self.porientation_statement()
            self.state = 369
            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 pccr_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Pccr_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self.match(XplorMRParser.Xccr)
            self.state = 372
            self.pccr_statement()
            self.state = 373
            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 hbond_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_statementContext,0)


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

        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)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 375
            self.match(XplorMRParser.Hbda)
            self.state = 376
            self.hbond_statement()
            self.state = 377
            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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Noe_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Noe_assignContext,i)


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

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

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

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

        def Noe_avr_methods(self):
            return self.getToken(XplorMRParser.Noe_avr_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 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 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 Noe_potential(self):
            return self.getToken(XplorMRParser.Noe_potential, 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 = 449
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 382
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 379
                    self.noe_assign()
                    self.state = 384
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Asymptote]:
                self.enterOuterAlt(localctx, 2)
                self.state = 385
                self.match(XplorMRParser.Asymptote)
                self.state = 386
                self.match(XplorMRParser.Simple_names)
                self.state = 387
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Averaging]:
                self.enterOuterAlt(localctx, 3)
                self.state = 388
                self.match(XplorMRParser.Averaging)
                self.state = 389
                self.match(XplorMRParser.Simple_names)
                self.state = 390
                self.match(XplorMRParser.Noe_avr_methods)
                pass
            elif token in [XplorMRParser.Bhig]:
                self.enterOuterAlt(localctx, 4)
                self.state = 391
                self.match(XplorMRParser.Bhig)
                self.state = 392
                self.match(XplorMRParser.Simple_names)
                self.state = 393
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Ceiling]:
                self.enterOuterAlt(localctx, 5)
                self.state = 394
                self.match(XplorMRParser.Ceiling)
                self.state = 395
                self.match(XplorMRParser.Equ_op)
                self.state = 396
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 6)
                self.state = 397
                self.match(XplorMRParser.Classification)
                self.state = 398
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.CountViol]:
                self.enterOuterAlt(localctx, 7)
                self.state = 399
                self.match(XplorMRParser.CountViol)
                self.state = 400
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Distribute]:
                self.enterOuterAlt(localctx, 8)
                self.state = 401
                self.match(XplorMRParser.Distribute)
                self.state = 402
                self.match(XplorMRParser.Simple_name)
                self.state = 403
                self.match(XplorMRParser.Simple_name)
                self.state = 404
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Monomers]:
                self.enterOuterAlt(localctx, 9)
                self.state = 405
                self.match(XplorMRParser.Monomers)
                self.state = 406
                self.match(XplorMRParser.Simple_names)
                self.state = 407
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Ncount]:
                self.enterOuterAlt(localctx, 10)
                self.state = 408
                self.match(XplorMRParser.Ncount)
                self.state = 409
                self.match(XplorMRParser.Simple_names)
                self.state = 410
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 11)
                self.state = 411
                self.match(XplorMRParser.Nrestraints)
                self.state = 412
                self.match(XplorMRParser.Equ_op)
                self.state = 413
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 12)
                self.state = 414
                self.match(XplorMRParser.Potential)
                self.state = 415
                self.match(XplorMRParser.Simple_names)
                self.state = 416
                self.match(XplorMRParser.Noe_potential)
                pass
            elif token in [XplorMRParser.Predict]:
                self.enterOuterAlt(localctx, 13)
                self.state = 417
                self.match(XplorMRParser.Predict)
                self.state = 418
                self.predict_statement()
                self.state = 419
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 14)
                self.state = 421
                self.match(XplorMRParser.Print)
                self.state = 422
                self.match(XplorMRParser.Threshold)
                self.state = 424
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 423
                    self.match(XplorMRParser.Equ_op)


                self.state = 426
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 15)
                self.state = 427
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Rswitch]:
                self.enterOuterAlt(localctx, 16)
                self.state = 428
                self.match(XplorMRParser.Rswitch)
                self.state = 429
                self.match(XplorMRParser.Simple_names)
                self.state = 430
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 17)
                self.state = 431
                self.match(XplorMRParser.Scale)
                self.state = 432
                self.match(XplorMRParser.Simple_names)
                self.state = 433
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.SoExponent]:
                self.enterOuterAlt(localctx, 18)
                self.state = 434
                self.match(XplorMRParser.SoExponent)
                self.state = 435
                self.match(XplorMRParser.Simple_names)
                self.state = 436
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.SqConstant]:
                self.enterOuterAlt(localctx, 19)
                self.state = 437
                self.match(XplorMRParser.SqConstant)
                self.state = 438
                self.match(XplorMRParser.Simple_names)
                self.state = 439
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.SqExponent]:
                self.enterOuterAlt(localctx, 20)
                self.state = 440
                self.match(XplorMRParser.SqExponent)
                self.state = 441
                self.match(XplorMRParser.Simple_names)
                self.state = 442
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.SqOffset]:
                self.enterOuterAlt(localctx, 21)
                self.state = 443
                self.match(XplorMRParser.SqOffset)
                self.state = 444
                self.match(XplorMRParser.Simple_names)
                self.state = 445
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Temperature]:
                self.enterOuterAlt(localctx, 22)
                self.state = 446
                self.match(XplorMRParser.Temperature)
                self.state = 447
                self.match(XplorMRParser.Equ_op)
                self.state = 448
                self.match(XplorMRParser.Real)
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, i)

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

        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 = 451
            self.match(XplorMRParser.Assign)
            self.state = 452
            self.selection()
            self.state = 453
            self.selection()
            self.state = 454
            _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()
            self.state = 455
            self.match(XplorMRParser.Real)
            self.state = 456
            self.match(XplorMRParser.Real)
            self.state = 463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 457
                self.match(XplorMRParser.Or_op)
                self.state = 458
                self.selection()
                self.state = 459
                self.selection()
                self.state = 465
                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 Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

        def Real(self):
            return self.getToken(XplorMRParser.Real, 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)
        try:
            self.state = 476
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 1)
                self.state = 466
                self.match(XplorMRParser.Cutoff)
                self.state = 467
                self.match(XplorMRParser.Equ_op)
                self.state = 468
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Cuton]:
                self.enterOuterAlt(localctx, 2)
                self.state = 469
                self.match(XplorMRParser.Cuton)
                self.state = 470
                self.match(XplorMRParser.Equ_op)
                self.state = 471
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.From]:
                self.enterOuterAlt(localctx, 3)
                self.state = 472
                self.match(XplorMRParser.From)
                self.state = 473
                self.selection()
                pass
            elif token in [XplorMRParser.To]:
                self.enterOuterAlt(localctx, 4)
                self.state = 474
                self.match(XplorMRParser.To)
                self.state = 475
                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 Dihedral_statementContext(ParserRuleContext):

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

        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 Nassign(self):
            return self.getToken(XplorMRParser.Nassign, 0)

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

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

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

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

        def Real(self):
            return self.getToken(XplorMRParser.Real, 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, 52, self.RULE_dihedral_statement)
        self._la = 0 # Token type
        try:
            self.state = 490
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 481
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 478
                    self.dihedral_assign()
                    self.state = 483
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Nassign]:
                self.enterOuterAlt(localctx, 2)
                self.state = 484
                self.match(XplorMRParser.Nassign)
                self.state = 485
                self.match(XplorMRParser.Equ_op)
                self.state = 486
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 3)
                self.state = 487
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 488
                self.match(XplorMRParser.Scale)
                self.state = 489
                self.match(XplorMRParser.Real)
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, i)

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

        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, 54, self.RULE_dihedral_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self.match(XplorMRParser.Assign)
            self.state = 493
            self.selection()
            self.state = 494
            self.selection()
            self.state = 495
            self.selection()
            self.state = 496
            self.selection()
            self.state = 497
            _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()
            self.state = 498
            self.match(XplorMRParser.Real)
            self.state = 499
            self.match(XplorMRParser.Real)
            self.state = 500
            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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Sani_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Sani_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 56, self.RULE_sani_statement)
        self._la = 0 # Token type
        try:
            self.state = 524
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 505
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 502
                    self.sani_assign()
                    self.state = 507
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 508
                self.match(XplorMRParser.Classification)
                self.state = 509
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 510
                self.match(XplorMRParser.Coefficients)
                self.state = 511
                self.match(XplorMRParser.Real)
                self.state = 512
                self.match(XplorMRParser.Real)
                self.state = 513
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 514
                self.match(XplorMRParser.ForceConstant)
                self.state = 515
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 516
                self.match(XplorMRParser.Nrestraints)
                self.state = 517
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 518
                self.match(XplorMRParser.Potential)
                self.state = 519
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 520
                self.match(XplorMRParser.Print)
                self.state = 521
                self.match(XplorMRParser.Threshold)
                self.state = 522
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 523
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, i)

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

        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, 58, self.RULE_sani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 526
            self.match(XplorMRParser.Assign)
            self.state = 527
            self.selection()
            self.state = 528
            self.selection()
            self.state = 529
            self.selection()
            self.state = 530
            self.selection()
            self.state = 531
            self.selection()
            self.state = 532
            self.selection()
            self.state = 533
            _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()
            self.state = 534
            self.match(XplorMRParser.Real)
            self.state = 536
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Real:
                self.state = 535
                self.match(XplorMRParser.Real)


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


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_avr_methods(self):
            return self.getToken(XplorMRParser.Rdc_avr_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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 60, self.RULE_xdip_statement)
        self._la = 0 # Token type
        try:
            self.state = 568
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 541
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 538
                    self.xdip_assign()
                    self.state = 543
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 544
                self.match(XplorMRParser.Classification)
                self.state = 545
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 3)
                self.state = 546
                self.match(XplorMRParser.Type)
                self.state = 547
                self.match(XplorMRParser.Rdc_dist_fix_types)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 548
                self.match(XplorMRParser.Scale)
                self.state = 549
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Sign]:
                self.enterOuterAlt(localctx, 5)
                self.state = 550
                self.match(XplorMRParser.Sign)
                self.state = 551
                self.match(XplorMRParser.Logical)
                pass
            elif token in [XplorMRParser.Average]:
                self.enterOuterAlt(localctx, 6)
                self.state = 552
                self.match(XplorMRParser.Average)
                self.state = 553
                self.match(XplorMRParser.Rdc_avr_methods)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 7)
                self.state = 554
                self.match(XplorMRParser.Coefficients)
                self.state = 555
                self.match(XplorMRParser.Real)
                self.state = 556
                self.match(XplorMRParser.Real)
                self.state = 557
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 8)
                self.state = 558
                self.match(XplorMRParser.ForceConstant)
                self.state = 559
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 560
                self.match(XplorMRParser.Nrestraints)
                self.state = 561
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 10)
                self.state = 562
                self.match(XplorMRParser.Potential)
                self.state = 563
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 11)
                self.state = 564
                self.match(XplorMRParser.Print)
                self.state = 565
                self.match(XplorMRParser.Threshold)
                self.state = 566
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 567
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 62, self.RULE_xdip_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 570
            self.match(XplorMRParser.Assign)
            self.state = 571
            self.selection()
            self.state = 572
            self.selection()
            self.state = 573
            self.selection()
            self.state = 574
            self.selection()
            self.state = 575
            self.selection()
            self.state = 576
            self.selection()
            self.state = 577
            self.match(XplorMRParser.Real)
            self.state = 578
            self.match(XplorMRParser.Real)
            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.state = 579
                self.match(XplorMRParser.Real)

            elif la_ == 2:
                self.state = 580
                self.match(XplorMRParser.Real)
                self.state = 581
                self.match(XplorMRParser.Real)
                self.state = 582
                self.match(XplorMRParser.Real)
                self.state = 583
                self.match(XplorMRParser.Real)


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


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

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

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 64, self.RULE_vean_statement)
        self._la = 0 # Token type
        try:
            self.state = 609
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 586
                    self.vean_assign()
                    self.state = 591
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 2)
                self.state = 592
                self.match(XplorMRParser.Cv)
                self.state = 593
                self.match(XplorMRParser.Equ_op)
                self.state = 594
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 595
                self.match(XplorMRParser.Classification)
                self.state = 596
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 597
                self.match(XplorMRParser.ForceConstant)
                self.state = 598
                self.match(XplorMRParser.Real)
                self.state = 599
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 600
                self.match(XplorMRParser.Nrestraints)
                self.state = 601
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 6)
                self.state = 602
                self.match(XplorMRParser.Partition)
                self.state = 603
                self.match(XplorMRParser.Equ_op)
                self.state = 604
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 605
                self.match(XplorMRParser.Print)
                self.state = 606
                self.match(XplorMRParser.Threshold)
                self.state = 607
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 608
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 66, self.RULE_vean_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 611
            self.match(XplorMRParser.Assign)
            self.state = 612
            self.selection()
            self.state = 613
            self.selection()
            self.state = 614
            self.selection()
            self.state = 615
            self.selection()
            self.state = 616
            self.match(XplorMRParser.Real)
            self.state = 617
            self.match(XplorMRParser.Real)
            self.state = 618
            self.match(XplorMRParser.Real)
            self.state = 619
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Tenso_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Tenso_assignContext,i)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 68, self.RULE_tenso_statement)
        self._la = 0 # Token type
        try:
            self.state = 639
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 624
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 621
                    self.tenso_assign()
                    self.state = 626
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 627
                self.match(XplorMRParser.Classification)
                self.state = 628
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 629
                self.match(XplorMRParser.Coefficients)
                self.state = 630
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 631
                self.match(XplorMRParser.Nrestraints)
                self.state = 632
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 633
                self.match(XplorMRParser.Potential)
                self.state = 634
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 635
                self.match(XplorMRParser.Print)
                self.state = 636
                self.match(XplorMRParser.Threshold)
                self.state = 637
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 638
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 70, self.RULE_tenso_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 641
            self.match(XplorMRParser.Assign)
            self.state = 642
            self.selection()
            self.state = 643
            self.selection()
            self.state = 644
            self.match(XplorMRParser.Real)
            self.state = 645
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Anis_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Anis_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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_anis_types(self):
            return self.getToken(XplorMRParser.Rdc_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, 72, self.RULE_anis_statement)
        self._la = 0 # Token type
        try:
            self.state = 672
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 650
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 647
                    self.anis_assign()
                    self.state = 652
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 653
                self.match(XplorMRParser.Classification)
                self.state = 654
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 655
                self.match(XplorMRParser.Coefficients)
                self.state = 656
                self.match(XplorMRParser.Real)
                self.state = 657
                self.match(XplorMRParser.Real)
                self.state = 658
                self.match(XplorMRParser.Real)
                self.state = 659
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 660
                self.match(XplorMRParser.ForceConstant)
                self.state = 661
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 662
                self.match(XplorMRParser.Nrestraints)
                self.state = 663
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 664
                self.match(XplorMRParser.Potential)
                self.state = 665
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 666
                self.match(XplorMRParser.Print)
                self.state = 667
                self.match(XplorMRParser.Threshold)
                self.state = 668
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 669
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 670
                self.match(XplorMRParser.Type)
                self.state = 671
                self.match(XplorMRParser.Rdc_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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 74, self.RULE_anis_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 674
            self.match(XplorMRParser.Assign)
            self.state = 675
            self.selection()
            self.state = 676
            self.selection()
            self.state = 677
            self.selection()
            self.state = 678
            self.selection()
            self.state = 679
            self.match(XplorMRParser.Real)
            self.state = 680
            self.match(XplorMRParser.Real)
        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 group_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Group_statementContext,0)


        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, 76, self.RULE_planar_statement)
        try:
            self.state = 685
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Group]:
                self.enterOuterAlt(localctx, 1)
                self.state = 682
                self.match(XplorMRParser.Group)
                self.state = 683
                self.group_statement()
                pass
            elif token in [XplorMRParser.Initialize]:
                self.enterOuterAlt(localctx, 2)
                self.state = 684
                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 Equ_op(self):
            return self.getToken(XplorMRParser.Equ_op, 0)

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


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

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

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 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, 78, self.RULE_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 693
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Selection]:
                self.enterOuterAlt(localctx, 1)
                self.state = 687
                self.match(XplorMRParser.Selection)
                self.state = 688
                self.match(XplorMRParser.Equ_op)
                self.state = 689
                self.selection()
                pass
            elif token in [XplorMRParser.Weight]:
                self.enterOuterAlt(localctx, 2)
                self.state = 690
                self.match(XplorMRParser.Weight)
                self.state = 691
                self.match(XplorMRParser.Equ_op)
                self.state = 692
                _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()
                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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Xadc_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Xadc_assignContext,i)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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, 80, self.RULE_antidistance_statement)
        self._la = 0 # Token type
        try:
            self.state = 723
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 698
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 695
                    self.xadc_assign()
                    self.state = 700
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 701
                self.match(XplorMRParser.Classification)
                self.state = 702
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 703
                self.match(XplorMRParser.Expectation)
                self.state = 704
                self.match(XplorMRParser.Integer)
                self.state = 705
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 706
                self.match(XplorMRParser.ForceConstant)
                self.state = 707
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 708
                self.match(XplorMRParser.Nrestraints)
                self.state = 709
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 710
                self.match(XplorMRParser.Print)
                self.state = 711
                self.match(XplorMRParser.Threshold)
                self.state = 712
                self.match(XplorMRParser.Real)
                self.state = 716
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 713
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 714
                    self.match(XplorMRParser.Classification)
                    self.state = 715
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 718
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 8)
                self.state = 719
                self.match(XplorMRParser.Size)
                self.state = 720
                self.match(XplorMRParser.Real)
                self.state = 721
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 9)
                self.state = 722
                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, 82, self.RULE_xadc_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 725
            self.match(XplorMRParser.Assign)
            self.state = 726
            self.selection()
            self.state = 727
            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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coup_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coup_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, i)

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

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

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 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 Coupling_potential(self):
            return self.getToken(XplorMRParser.Coupling_potential, 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, 84, self.RULE_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 768
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 732
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 729
                    self.coup_assign()
                    self.state = 734
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 735
                self.match(XplorMRParser.Classification)
                self.state = 736
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 737
                self.match(XplorMRParser.Coefficients)
                self.state = 738
                self.match(XplorMRParser.Real)
                self.state = 739
                self.match(XplorMRParser.Real)
                self.state = 740
                self.match(XplorMRParser.Real)
                self.state = 741
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 4)
                self.state = 742
                self.match(XplorMRParser.Cv)
                self.state = 743
                self.match(XplorMRParser.Equ_op)
                self.state = 744
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 5)
                self.state = 745
                self.match(XplorMRParser.DegEnergy)
                self.state = 746
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 747
                self.match(XplorMRParser.ForceConstant)
                self.state = 748
                self.match(XplorMRParser.Real)
                self.state = 750
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Real:
                    self.state = 749
                    self.match(XplorMRParser.Real)


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 752
                self.match(XplorMRParser.Nrestraints)
                self.state = 753
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 8)
                self.state = 754
                self.match(XplorMRParser.Partition)
                self.state = 755
                self.match(XplorMRParser.Equ_op)
                self.state = 756
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 757
                self.match(XplorMRParser.Potential)
                self.state = 758
                self.match(XplorMRParser.Coupling_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 759
                self.match(XplorMRParser.Print)
                self.state = 760
                self.match(XplorMRParser.Threshold)
                self.state = 761
                self.match(XplorMRParser.Real)
                self.state = 765
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 762
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 763
                    self.match(XplorMRParser.Classification)
                    self.state = 764
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 767
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 86, self.RULE_coup_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 770
            self.match(XplorMRParser.Assign)
            self.state = 771
            self.selection()
            self.state = 772
            self.selection()
            self.state = 773
            self.selection()
            self.state = 774
            self.selection()
            self.state = 780
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 775
                self.selection()
                self.state = 776
                self.selection()
                self.state = 777
                self.selection()
                self.state = 778
                self.selection()


            self.state = 782
            self.match(XplorMRParser.Real)
            self.state = 783
            self.match(XplorMRParser.Real)
            self.state = 786
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Real:
                self.state = 784
                self.match(XplorMRParser.Real)
                self.state = 785
                self.match(XplorMRParser.Real)


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


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 0)

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

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

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


        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, 88, self.RULE_carbon_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 823
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 791
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 788
                    self.carbon_shift_assign()
                    self.state = 793
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 794
                self.match(XplorMRParser.Classification)
                self.state = 795
                self.match(XplorMRParser.Simple_name)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 796
                self.match(XplorMRParser.Expectation)
                self.state = 797
                self.match(XplorMRParser.Integer)
                self.state = 798
                self.match(XplorMRParser.Integer)
                self.state = 799
                self.match(XplorMRParser.Real)
                self.state = 800
                self.match(XplorMRParser.Real)
                self.state = 801
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 802
                self.match(XplorMRParser.ForceConstant)
                self.state = 803
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 804
                self.match(XplorMRParser.Nrestraints)
                self.state = 805
                self.match(XplorMRParser.Integer)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 806
                self.match(XplorMRParser.PhiStep)
                self.state = 807
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 808
                self.match(XplorMRParser.PsiStep)
                self.state = 809
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 810
                self.match(XplorMRParser.Potential)
                self.state = 811
                self.match(XplorMRParser.Rdc_potential)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 812
                self.match(XplorMRParser.Print)
                self.state = 813
                self.match(XplorMRParser.Threshold)
                self.state = 814
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 818
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Rcoil:
                    self.state = 815
                    self.carbon_shift_rcoil()
                    self.state = 820
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 821
                self.match(XplorMRParser.Reset)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 822
                self.match(XplorMRParser.Zero)
                pass


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 90, self.RULE_carbon_shift_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 825
            self.match(XplorMRParser.Assign)
            self.state = 826
            self.selection()
            self.state = 827
            self.selection()
            self.state = 828
            self.selection()
            self.state = 829
            self.selection()
            self.state = 830
            self.selection()
            self.state = 831
            self.match(XplorMRParser.Real)
            self.state = 832
            self.match(XplorMRParser.Real)
        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 92, self.RULE_carbon_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 834
            self.match(XplorMRParser.Rcoil)
            self.state = 835
            self.selection()
            self.state = 836
            self.match(XplorMRParser.Real)
            self.state = 837
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.ObservedContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.ObservedContext,i)


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


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


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


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


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


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


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


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


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Coupling_potential(self):
            return self.getToken(XplorMRParser.Coupling_potential, 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, 94, self.RULE_proton_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 916
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 842
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Observed:
                    self.state = 839
                    self.observed()
                    self.state = 844
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Rcoil:
                    self.state = 845
                    self.proton_shift_rcoil()
                    self.state = 850
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 854
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Anisotropy:
                    self.state = 851
                    self.proton_shift_anisotropy()
                    self.state = 856
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 860
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Amides:
                    self.state = 857
                    self.proton_shift_amides()
                    self.state = 862
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 866
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Carbons:
                    self.state = 863
                    self.proton_shift_carbons()
                    self.state = 868
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 872
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Nitrogens:
                    self.state = 869
                    self.proton_shift_nitrogens()
                    self.state = 874
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 878
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Oxygens:
                    self.state = 875
                    self.proton_shift_oxygens()
                    self.state = 880
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 884
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.RingAtoms:
                    self.state = 881
                    self.proton_shift_ring_atoms()
                    self.state = 886
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 890
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.AlphasAndAmides:
                    self.state = 887
                    self.proton_shift_alphas_and_amides()
                    self.state = 892
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 893
                self.match(XplorMRParser.Classification)
                self.state = 894
                self.match(XplorMRParser.Simple_name)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 895
                self.match(XplorMRParser.Error)
                self.state = 896
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 897
                self.match(XplorMRParser.DegEnergy)
                self.state = 898
                self.match(XplorMRParser.Integer)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 899
                self.match(XplorMRParser.ForceConstant)
                self.state = 900
                self.match(XplorMRParser.Real)
                self.state = 902
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Real:
                    self.state = 901
                    self.match(XplorMRParser.Real)


                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 904
                self.match(XplorMRParser.Potential)
                self.state = 905
                self.match(XplorMRParser.Coupling_potential)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 906
                self.match(XplorMRParser.Print)
                self.state = 907
                self.match(XplorMRParser.Threshold)
                self.state = 908
                self.match(XplorMRParser.Real)
                self.state = 912
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 909
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 910
                    self.match(XplorMRParser.Classification)
                    self.state = 911
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 914
                self.match(XplorMRParser.Simple_name)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 915
                self.match(XplorMRParser.Reset)
                pass


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 96, self.RULE_observed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 918
            self.match(XplorMRParser.Observed)
            self.state = 919
            self.selection()
            self.state = 921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 920
                self.selection()


            self.state = 923
            self.match(XplorMRParser.Real)
            self.state = 925
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Real:
                self.state = 924
                self.match(XplorMRParser.Real)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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, 98, self.RULE_proton_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 927
            self.match(XplorMRParser.Rcoil)
            self.state = 928
            self.selection()
            self.state = 929
            self.match(XplorMRParser.Real)
        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, 100, self.RULE_proton_shift_anisotropy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 931
            self.match(XplorMRParser.Anisotropy)
            self.state = 932
            self.selection()
            self.state = 933
            self.selection()
            self.state = 934
            self.selection()
            self.state = 935
            self.match(XplorMRParser.Simple_name)
            self.state = 937
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Logical:
                self.state = 936
                self.match(XplorMRParser.Logical)


            self.state = 939
            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, 102, self.RULE_proton_shift_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 941
            self.match(XplorMRParser.Amides)
            self.state = 942
            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 Carbons(self):
            return self.getToken(XplorMRParser.Carbons, 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, 104, self.RULE_proton_shift_carbons)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 944
            self.match(XplorMRParser.Carbons)
            self.state = 945
            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, 106, self.RULE_proton_shift_nitrogens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 947
            self.match(XplorMRParser.Nitrogens)
            self.state = 948
            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, 108, self.RULE_proton_shift_oxygens)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 950
            self.match(XplorMRParser.Oxygens)
            self.state = 951
            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, 110, self.RULE_proton_shift_ring_atoms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 953
            self.match(XplorMRParser.RingAtoms)
            self.state = 954
            self.match(XplorMRParser.Simple_name)
            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 = 961
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 960
                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, 112, self.RULE_proton_shift_alphas_and_amides)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 963
            self.match(XplorMRParser.AlphasAndAmides)
            self.state = 964
            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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Rama_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Rama_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 114, self.RULE_ramachandran_statement)
        self._la = 0 # Token type
        try:
            self.state = 1064
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 969
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 966
                    self.rama_assign()
                    self.state = 971
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 972
                self.match(XplorMRParser.Classification)
                self.state = 973
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 974
                self.match(XplorMRParser.Cutoff)
                self.state = 975
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 976
                self.match(XplorMRParser.ForceConstant)
                self.state = 977
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 5)
                self.state = 978
                self.match(XplorMRParser.Gaussian)
                self.state = 979
                self.match(XplorMRParser.Real)
                self.state = 980
                self.match(XplorMRParser.Real)
                self.state = 981
                self.match(XplorMRParser.Real)
                self.state = 985
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
                if la_ == 1:
                    self.state = 982
                    self.match(XplorMRParser.Real)
                    self.state = 983
                    self.match(XplorMRParser.Real)
                    self.state = 984
                    self.match(XplorMRParser.Real)


                self.state = 990
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
                if la_ == 1:
                    self.state = 987
                    self.match(XplorMRParser.Real)
                    self.state = 988
                    self.match(XplorMRParser.Real)
                    self.state = 989
                    self.match(XplorMRParser.Real)


                self.state = 995
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Real:
                    self.state = 992
                    self.match(XplorMRParser.Real)
                    self.state = 993
                    self.match(XplorMRParser.Real)
                    self.state = 994
                    self.match(XplorMRParser.Real)


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 997
                self.match(XplorMRParser.Nrestraints)
                self.state = 998
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Phase]:
                self.enterOuterAlt(localctx, 7)
                self.state = 999
                self.match(XplorMRParser.Phase)
                self.state = 1000
                self.match(XplorMRParser.Real)
                self.state = 1001
                self.match(XplorMRParser.Real)
                self.state = 1002
                self.match(XplorMRParser.Real)
                self.state = 1006
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
                if la_ == 1:
                    self.state = 1003
                    self.match(XplorMRParser.Real)
                    self.state = 1004
                    self.match(XplorMRParser.Real)
                    self.state = 1005
                    self.match(XplorMRParser.Real)


                self.state = 1011
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 1008
                    self.match(XplorMRParser.Real)
                    self.state = 1009
                    self.match(XplorMRParser.Real)
                    self.state = 1010
                    self.match(XplorMRParser.Real)


                self.state = 1016
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Real:
                    self.state = 1013
                    self.match(XplorMRParser.Real)
                    self.state = 1014
                    self.match(XplorMRParser.Real)
                    self.state = 1015
                    self.match(XplorMRParser.Real)


                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1018
                self.match(XplorMRParser.Print)
                self.state = 1019
                self.match(XplorMRParser.Threshold)
                self.state = 1020
                self.match(XplorMRParser.Real)
                self.state = 1024
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1021
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1022
                    self.match(XplorMRParser.Classification)
                    self.state = 1023
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1026
                self.match(XplorMRParser.Quartic)
                self.state = 1027
                self.match(XplorMRParser.Real)
                self.state = 1028
                self.match(XplorMRParser.Real)
                self.state = 1029
                self.match(XplorMRParser.Real)
                self.state = 1033
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
                if la_ == 1:
                    self.state = 1030
                    self.match(XplorMRParser.Real)
                    self.state = 1031
                    self.match(XplorMRParser.Real)
                    self.state = 1032
                    self.match(XplorMRParser.Real)


                self.state = 1038
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
                if la_ == 1:
                    self.state = 1035
                    self.match(XplorMRParser.Real)
                    self.state = 1036
                    self.match(XplorMRParser.Real)
                    self.state = 1037
                    self.match(XplorMRParser.Real)


                self.state = 1043
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Real:
                    self.state = 1040
                    self.match(XplorMRParser.Real)
                    self.state = 1041
                    self.match(XplorMRParser.Real)
                    self.state = 1042
                    self.match(XplorMRParser.Real)


                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1045
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1046
                self.match(XplorMRParser.Scale)
                self.state = 1047
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Shape]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1048
                self.match(XplorMRParser.Shape)
                self.state = 1049
                self.match(XplorMRParser.Gauss_or_Quart)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1050
                self.match(XplorMRParser.Size)
                self.state = 1051
                self.match(XplorMRParser.Dimensions)
                self.state = 1052
                self.match(XplorMRParser.Real)
                self.state = 1054
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                if la_ == 1:
                    self.state = 1053
                    self.match(XplorMRParser.Real)


                self.state = 1057
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
                if la_ == 1:
                    self.state = 1056
                    self.match(XplorMRParser.Real)


                self.state = 1060
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Real:
                    self.state = 1059
                    self.match(XplorMRParser.Real)


                pass
            elif token in [XplorMRParser.Sort]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1062
                self.match(XplorMRParser.Sort)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1063
                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, 116, self.RULE_rama_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1066
            self.match(XplorMRParser.Assign)
            self.state = 1067
            self.selection()
            self.state = 1068
            self.selection()
            self.state = 1069
            self.selection()
            self.state = 1070
            self.selection()
            self.state = 1076
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.state = 1071
                self.selection()
                self.state = 1072
                self.selection()
                self.state = 1073
                self.selection()
                self.state = 1074
                self.selection()


            self.state = 1083
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 1078
                self.selection()
                self.state = 1079
                self.selection()
                self.state = 1080
                self.selection()
                self.state = 1081
                self.selection()


            self.state = 1090
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1085
                self.selection()
                self.state = 1086
                self.selection()
                self.state = 1087
                self.selection()
                self.state = 1088
                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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Coll_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Coll_assignContext,i)


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

        def Real(self):
            return self.getToken(XplorMRParser.Real, 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, 118, self.RULE_collapse_statement)
        self._la = 0 # Token type
        try:
            self.state = 1102
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1095
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1092
                    self.coll_assign()
                    self.state = 1097
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1098
                self.match(XplorMRParser.Scale)
                self.state = 1099
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1100
                self.match(XplorMRParser.Print)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1101
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 120, self.RULE_coll_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1104
            self.match(XplorMRParser.Assign)
            self.state = 1105
            self.selection()
            self.state = 1106
            self.match(XplorMRParser.Real)
            self.state = 1107
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Dani_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Dani_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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 Diff_anis_types(self):
            return self.getToken(XplorMRParser.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, 122, self.RULE_diffusion_statement)
        self._la = 0 # Token type
        try:
            self.state = 1135
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1112
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1109
                    self.dani_assign()
                    self.state = 1114
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1115
                self.match(XplorMRParser.Classification)
                self.state = 1116
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1117
                self.match(XplorMRParser.Coefficients)
                self.state = 1118
                self.match(XplorMRParser.Real)
                self.state = 1119
                self.match(XplorMRParser.Real)
                self.state = 1120
                self.match(XplorMRParser.Real)
                self.state = 1121
                self.match(XplorMRParser.Real)
                self.state = 1122
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1123
                self.match(XplorMRParser.ForceConstant)
                self.state = 1124
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1125
                self.match(XplorMRParser.Nrestraints)
                self.state = 1126
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1127
                self.match(XplorMRParser.Potential)
                self.state = 1128
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1129
                self.match(XplorMRParser.Print)
                self.state = 1130
                self.match(XplorMRParser.Threshold)
                self.state = 1131
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1132
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1133
                self.match(XplorMRParser.Type)
                self.state = 1134
                self.match(XplorMRParser.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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 124, self.RULE_dani_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1137
            self.match(XplorMRParser.Assign)
            self.state = 1138
            self.selection()
            self.state = 1139
            self.selection()
            self.state = 1140
            self.selection()
            self.state = 1141
            self.selection()
            self.state = 1142
            self.selection()
            self.state = 1143
            self.selection()
            self.state = 1144
            self.match(XplorMRParser.Real)
            self.state = 1145
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Orie_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Orie_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 126, self.RULE_orientation_statement)
        self._la = 0 # Token type
        try:
            self.state = 1205
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1150
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1147
                    self.orie_assign()
                    self.state = 1152
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1153
                self.match(XplorMRParser.Classification)
                self.state = 1154
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1155
                self.match(XplorMRParser.Cutoff)
                self.state = 1156
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Height]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1157
                self.match(XplorMRParser.Height)
                self.state = 1158
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1159
                self.match(XplorMRParser.ForceConstant)
                self.state = 1160
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1161
                self.match(XplorMRParser.Gaussian)
                self.state = 1162
                self.match(XplorMRParser.Real)
                self.state = 1163
                self.match(XplorMRParser.Real)
                self.state = 1164
                self.match(XplorMRParser.Real)
                self.state = 1165
                self.match(XplorMRParser.Real)
                self.state = 1166
                self.match(XplorMRParser.Real)
                self.state = 1167
                self.match(XplorMRParser.Real)
                self.state = 1168
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.MaxGaussians]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1169
                self.match(XplorMRParser.MaxGaussians)
                self.state = 1170
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.NewGaussian]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1171
                self.match(XplorMRParser.NewGaussian)
                self.state = 1172
                self.match(XplorMRParser.Real)
                self.state = 1173
                self.match(XplorMRParser.Real)
                self.state = 1174
                self.match(XplorMRParser.Real)
                self.state = 1175
                self.match(XplorMRParser.Real)
                self.state = 1176
                self.match(XplorMRParser.Real)
                self.state = 1177
                self.match(XplorMRParser.Real)
                self.state = 1178
                self.match(XplorMRParser.Real)
                self.state = 1179
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1180
                self.match(XplorMRParser.Nrestraints)
                self.state = 1181
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1182
                self.match(XplorMRParser.Print)
                self.state = 1183
                self.match(XplorMRParser.Threshold)
                self.state = 1184
                self.match(XplorMRParser.Real)
                self.state = 1188
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1185
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1186
                    self.match(XplorMRParser.Classification)
                    self.state = 1187
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1190
                self.match(XplorMRParser.Quartic)
                self.state = 1191
                self.match(XplorMRParser.Real)
                self.state = 1192
                self.match(XplorMRParser.Real)
                self.state = 1193
                self.match(XplorMRParser.Real)
                self.state = 1194
                self.match(XplorMRParser.Real)
                self.state = 1195
                self.match(XplorMRParser.Real)
                self.state = 1196
                self.match(XplorMRParser.Real)
                self.state = 1197
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1198
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Residue]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1199
                self.match(XplorMRParser.Residue)
                self.state = 1200
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1201
                self.match(XplorMRParser.Size)
                self.state = 1202
                self.match(XplorMRParser.Real)
                self.state = 1203
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1204
                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, 128, self.RULE_orie_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1207
            self.match(XplorMRParser.Assign)
            self.state = 1208
            self.selection()
            self.state = 1209
            self.selection()
            self.state = 1210
            self.selection()
            self.state = 1211
            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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 130, self.RULE_csa_statement)
        self._la = 0 # Token type
        try:
            self.state = 1243
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1216
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1213
                    self.csa_assign()
                    self.state = 1218
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1219
                self.match(XplorMRParser.Classification)
                self.state = 1220
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1221
                self.match(XplorMRParser.Scale)
                self.state = 1222
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1223
                self.match(XplorMRParser.Type)
                self.state = 1224
                self.match(XplorMRParser.Csa_types)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1225
                self.match(XplorMRParser.Coefficients)
                self.state = 1226
                self.match(XplorMRParser.Real)
                self.state = 1227
                self.match(XplorMRParser.Real)
                self.state = 1228
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1229
                self.match(XplorMRParser.Sigma)
                self.state = 1230
                self.match(XplorMRParser.Real)
                self.state = 1231
                self.match(XplorMRParser.Real)
                self.state = 1232
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1233
                self.match(XplorMRParser.ForceConstant)
                self.state = 1234
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1235
                self.match(XplorMRParser.Nrestraints)
                self.state = 1236
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1237
                self.match(XplorMRParser.Potential)
                self.state = 1238
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1239
                self.match(XplorMRParser.Print)
                self.state = 1240
                self.match(XplorMRParser.Threshold)
                self.state = 1241
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1242
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 132, self.RULE_csa_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1245
            self.match(XplorMRParser.Assign)
            self.state = 1246
            self.selection()
            self.state = 1247
            self.selection()
            self.state = 1248
            self.selection()
            self.state = 1249
            self.selection()
            self.state = 1250
            self.selection()
            self.state = 1251
            self.selection()
            self.state = 1252
            self.selection()
            self.state = 1253
            self.match(XplorMRParser.Real)
            self.state = 1254
            self.match(XplorMRParser.Real)
            self.state = 1255
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Csa_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 134, self.RULE_pcsa_statement)
        self._la = 0 # Token type
        try:
            self.state = 1286
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1260
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1257
                    self.csa_assign()
                    self.state = 1262
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1263
                self.match(XplorMRParser.Classification)
                self.state = 1264
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1265
                self.match(XplorMRParser.Scale)
                self.state = 1266
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1267
                self.match(XplorMRParser.Coefficients)
                self.state = 1268
                self.match(XplorMRParser.Real)
                self.state = 1269
                self.match(XplorMRParser.Real)
                self.state = 1270
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1271
                self.match(XplorMRParser.Sigma)
                self.state = 1272
                self.match(XplorMRParser.Real)
                self.state = 1273
                self.match(XplorMRParser.Real)
                self.state = 1274
                self.match(XplorMRParser.Real)
                self.state = 1275
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1276
                self.match(XplorMRParser.ForceConstant)
                self.state = 1277
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1278
                self.match(XplorMRParser.Nrestraints)
                self.state = 1279
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1280
                self.match(XplorMRParser.Potential)
                self.state = 1281
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1282
                self.match(XplorMRParser.Print)
                self.state = 1283
                self.match(XplorMRParser.Threshold)
                self.state = 1284
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1285
                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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.One_bond_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.One_bond_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 136, self.RULE_one_bond_coupling_statement)
        self._la = 0 # Token type
        try:
            self.state = 1314
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1291
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1288
                    self.one_bond_assign()
                    self.state = 1293
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1294
                self.match(XplorMRParser.Classification)
                self.state = 1295
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1296
                self.match(XplorMRParser.Coefficients)
                self.state = 1297
                self.match(XplorMRParser.Real)
                self.state = 1298
                self.match(XplorMRParser.Real)
                self.state = 1299
                self.match(XplorMRParser.Real)
                self.state = 1300
                self.match(XplorMRParser.Real)
                self.state = 1301
                self.match(XplorMRParser.Real)
                self.state = 1302
                self.match(XplorMRParser.Real)
                self.state = 1303
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1304
                self.match(XplorMRParser.ForceConstant)
                self.state = 1305
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1306
                self.match(XplorMRParser.Nrestraints)
                self.state = 1307
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1308
                self.match(XplorMRParser.Potential)
                self.state = 1309
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1310
                self.match(XplorMRParser.Print)
                self.state = 1311
                self.match(XplorMRParser.Threshold)
                self.state = 1312
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1313
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 138, self.RULE_one_bond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1316
            self.match(XplorMRParser.Assign)
            self.state = 1317
            self.selection()
            self.state = 1318
            self.selection()
            self.state = 1319
            self.selection()
            self.state = 1320
            self.selection()
            self.state = 1321
            self.selection()
            self.state = 1322
            self.selection()
            self.state = 1323
            self.selection()
            self.state = 1324
            self.selection()
            self.state = 1325
            self.match(XplorMRParser.Real)
            self.state = 1326
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Angle_db_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Angle_db_assignContext,i)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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_dihedral(self):
            return self.getToken(XplorMRParser.Angle_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, 140, self.RULE_angle_db_statement)
        self._la = 0 # Token type
        try:
            self.state = 1364
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1331
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1328
                    self.angle_db_assign()
                    self.state = 1333
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                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.DerivFlag]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1336
                self.match(XplorMRParser.DerivFlag)
                self.state = 1337
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1338
                self.match(XplorMRParser.Expectation)
                self.state = 1339
                self.match(XplorMRParser.Integer)
                self.state = 1340
                self.match(XplorMRParser.Integer)
                self.state = 1341
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1342
                self.match(XplorMRParser.Error)
                self.state = 1343
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1344
                self.match(XplorMRParser.ForceConstant)
                self.state = 1345
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1346
                self.match(XplorMRParser.Nrestraints)
                self.state = 1347
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1348
                self.match(XplorMRParser.Potential)
                self.state = 1349
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1350
                self.match(XplorMRParser.Print)
                self.state = 1351
                self.match(XplorMRParser.Threshold)
                self.state = 1352
                self.match(XplorMRParser.Real)
                self.state = 1356
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1353
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1354
                    self.match(XplorMRParser.Classification)
                    self.state = 1355
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1358
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1359
                self.match(XplorMRParser.Size)
                self.state = 1360
                self.match(XplorMRParser.Angle_dihedral)
                self.state = 1361
                self.match(XplorMRParser.Integer)
                self.state = 1362
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1363
                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, 142, self.RULE_angle_db_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1366
            self.match(XplorMRParser.Assign)
            self.state = 1367
            self.selection()
            self.state = 1368
            self.selection()
            self.state = 1369
            self.selection()
            self.state = 1370
            self.selection()
            self.state = 1371
            self.selection()
            self.state = 1372
            self.selection()
            self.state = 1373
            self.selection()
            self.state = 1374
            self.selection()
            self.state = 1375
            self.selection()
            self.state = 1376
            self.selection()
            self.state = 1377
            self.selection()
            self.state = 1379
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1378
                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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pre_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pre_assignContext,i)


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

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

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

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

        def Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Rdc_potential(self):
            return self.getToken(XplorMRParser.Rdc_potential, 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, 144, self.RULE_pre_statement)
        self._la = 0 # Token type
        try:
            self.state = 1424
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1384
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1381
                    self.pre_assign()
                    self.state = 1386
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1387
                self.match(XplorMRParser.Classification)
                self.state = 1388
                self.match(XplorMRParser.Equ_op)
                self.state = 1389
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1390
                self.match(XplorMRParser.ForceConstant)
                self.state = 1391
                self.match(XplorMRParser.Equ_op)
                self.state = 1392
                self.match(XplorMRParser.Simple_name)
                self.state = 1393
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1394
                self.match(XplorMRParser.Nrestraints)
                self.state = 1395
                self.match(XplorMRParser.Equ_op)
                self.state = 1396
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1397
                self.match(XplorMRParser.Potential)
                self.state = 1398
                self.match(XplorMRParser.Equ_op)
                self.state = 1399
                self.match(XplorMRParser.Simple_name)
                self.state = 1400
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Kconst]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1401
                self.match(XplorMRParser.Kconst)
                self.state = 1402
                self.match(XplorMRParser.Equ_op)
                self.state = 1403
                self.match(XplorMRParser.Simple_name)
                self.state = 1404
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Omega]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1405
                self.match(XplorMRParser.Omega)
                self.state = 1406
                self.match(XplorMRParser.Equ_op)
                self.state = 1407
                self.match(XplorMRParser.Simple_name)
                self.state = 1408
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Tauc]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1409
                self.match(XplorMRParser.Tauc)
                self.state = 1410
                self.match(XplorMRParser.Equ_op)
                self.state = 1411
                self.match(XplorMRParser.Simple_name)
                self.state = 1412
                self.match(XplorMRParser.Real)
                self.state = 1413
                self.match(XplorMRParser.Real)
                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.match(XplorMRParser.Real)
                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.Debug]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1423
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 146, self.RULE_pre_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1426
            self.match(XplorMRParser.Assign)
            self.state = 1427
            self.selection()
            self.state = 1428
            self.selection()
            self.state = 1429
            self.match(XplorMRParser.Real)
            self.state = 1430
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pcs_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pcs_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 148, self.RULE_pcs_statement)
        self._la = 0 # Token type
        try:
            self.state = 1471
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1435
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1432
                    self.pcs_assign()
                    self.state = 1437
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1438
                self.match(XplorMRParser.Classification)
                self.state = 1439
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1440
                self.match(XplorMRParser.Tolerance)
                self.state = 1441
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1442
                self.match(XplorMRParser.Coefficients)
                self.state = 1443
                self.match(XplorMRParser.Real)
                self.state = 1444
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1445
                self.match(XplorMRParser.ForceConstant)
                self.state = 1446
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1447
                self.match(XplorMRParser.Nrestraints)
                self.state = 1448
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1449
                self.match(XplorMRParser.Print)
                self.state = 1450
                self.match(XplorMRParser.Threshold)
                self.state = 1451
                self.match(XplorMRParser.Real)
                self.state = 1455
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1452
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1453
                    self.match(XplorMRParser.Classification)
                    self.state = 1454
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1457
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1458
                self.match(XplorMRParser.Save)
                self.state = 1459
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1460
                self.match(XplorMRParser.Fmed)
                self.state = 1461
                self.match(XplorMRParser.Real)
                self.state = 1462
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1463
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1464
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1465
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1466
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1467
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1468
                self.match(XplorMRParser.Soff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1469
                self.match(XplorMRParser.Frun)
                self.state = 1470
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 150, self.RULE_pcs_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1473
            self.match(XplorMRParser.Assign)
            self.state = 1474
            self.selection()
            self.state = 1475
            self.selection()
            self.state = 1476
            self.selection()
            self.state = 1477
            self.selection()
            self.state = 1478
            self.selection()
            self.state = 1479
            self.match(XplorMRParser.Real)
            self.state = 1480
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Prdc_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Prdc_assignContext,i)


        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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 152, self.RULE_prdc_statement)
        self._la = 0 # Token type
        try:
            self.state = 1512
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1485
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1482
                    self.prdc_assign()
                    self.state = 1487
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1488
                self.match(XplorMRParser.Classification)
                self.state = 1489
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1490
                self.match(XplorMRParser.Tolerance)
                self.state = 1491
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1492
                self.match(XplorMRParser.Coefficients)
                self.state = 1493
                self.match(XplorMRParser.Real)
                self.state = 1494
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1495
                self.match(XplorMRParser.ForceConstant)
                self.state = 1496
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1497
                self.match(XplorMRParser.Nrestraints)
                self.state = 1498
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1499
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1500
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1501
                self.match(XplorMRParser.Fmed)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1502
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1503
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1504
                self.match(XplorMRParser.Frun)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1505
                self.match(XplorMRParser.Print)
                self.state = 1506
                self.match(XplorMRParser.Threshold)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1507
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1508
                self.match(XplorMRParser.Save)
                self.state = 1509
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1510
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1511
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 154, self.RULE_prdc_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1514
            self.match(XplorMRParser.Assign)
            self.state = 1515
            self.selection()
            self.state = 1516
            self.selection()
            self.state = 1517
            self.selection()
            self.state = 1518
            self.selection()
            self.state = 1519
            self.selection()
            self.state = 1520
            self.selection()
            self.state = 1521
            self.match(XplorMRParser.Real)
            self.state = 1522
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Porientation_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Porientation_assignContext,i)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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, 156, self.RULE_porientation_statement)
        self._la = 0 # Token type
        try:
            self.state = 1540
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1527
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1524
                    self.porientation_assign()
                    self.state = 1529
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1530
                self.match(XplorMRParser.Classification)
                self.state = 1531
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1532
                self.match(XplorMRParser.ForceConstant)
                self.state = 1533
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1534
                self.match(XplorMRParser.Nrestraints)
                self.state = 1535
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1536
                self.match(XplorMRParser.Print)
                self.state = 1537
                self.match(XplorMRParser.Threshold)
                self.state = 1538
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1539
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 158, self.RULE_porientation_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1542
            self.match(XplorMRParser.Assign)
            self.state = 1543
            self.selection()
            self.state = 1544
            self.selection()
            self.state = 1545
            self.match(XplorMRParser.Real)
            self.state = 1546
            self.match(XplorMRParser.Real)
            self.state = 1547
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Pccr_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Pccr_assignContext,i)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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, 160, self.RULE_pccr_statement)
        self._la = 0 # Token type
        try:
            self.state = 1571
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1552
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1549
                    self.pccr_assign()
                    self.state = 1554
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1555
                self.match(XplorMRParser.Classification)
                self.state = 1556
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Weip]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1557
                self.match(XplorMRParser.Weip)
                self.state = 1558
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1559
                self.match(XplorMRParser.Coefficients)
                self.state = 1560
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1561
                self.match(XplorMRParser.ForceConstant)
                self.state = 1562
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1563
                self.match(XplorMRParser.Nrestraints)
                self.state = 1564
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1565
                self.match(XplorMRParser.Print)
                self.state = 1566
                self.match(XplorMRParser.Threshold)
                self.state = 1567
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1568
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1569
                self.match(XplorMRParser.Frun)
                self.state = 1570
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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, 162, self.RULE_pccr_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1573
            self.match(XplorMRParser.Assign)
            self.state = 1574
            self.selection()
            self.state = 1575
            self.selection()
            self.state = 1576
            self.selection()
            self.state = 1577
            self.match(XplorMRParser.Real)
            self.state = 1578
            self.match(XplorMRParser.Real)
        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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Hbond_assignContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Hbond_assignContext,i)


        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 Real(self):
            return self.getToken(XplorMRParser.Real, 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, 164, self.RULE_hbond_statement)
        self._la = 0 # Token type
        try:
            self.state = 1596
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.End, XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1583
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Assign:
                    self.state = 1580
                    self.hbond_assign()
                    self.state = 1585
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1586
                self.match(XplorMRParser.Classification)
                self.state = 1587
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1588
                self.match(XplorMRParser.ForceConstant)
                self.state = 1589
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1590
                self.match(XplorMRParser.Nrestraints)
                self.state = 1591
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1592
                self.match(XplorMRParser.Print)
                self.state = 1593
                self.match(XplorMRParser.Threshold)
                self.state = 1594
                self.match(XplorMRParser.Real)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1595
                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, 166, self.RULE_hbond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1598
            self.match(XplorMRParser.Assign)
            self.state = 1599
            self.selection()
            self.state = 1600
            self.selection()
            self.state = 1601
            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, 168, self.RULE_selection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1603
            self.match(XplorMRParser.L_paren)
            self.state = 1604
            self.selection_expression()
            self.state = 1605
            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, 170, self.RULE_selection_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1607
            self.term()
            self.state = 1612
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 1608
                self.match(XplorMRParser.Or_op)
                self.state = 1609
                self.term()
                self.state = 1614
                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, 172, self.RULE_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1615
            self.factor(0)
            self.state = 1620
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.And_op:
                self.state = 1616
                self.match(XplorMRParser.And_op)
                self.state = 1617
                self.factor(0)
                self.state = 1622
                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 Real(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Real)
            else:
                return self.getToken(XplorMRParser.Real, 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 Equ_op(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Equ_op)
            else:
                return self.getToken(XplorMRParser.Equ_op, i)

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


        def 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 = 174
        self.enterRecursionRule(localctx, 174, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1745
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
            if la_ == 1:
                self.state = 1624
                self.match(XplorMRParser.L_paren)
                self.state = 1625
                self.selection_expression()
                self.state = 1626
                self.match(XplorMRParser.R_paren)
                pass

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

            elif la_ == 3:
                self.state = 1629
                self.match(XplorMRParser.Atom)
                self.state = 1630
                _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 = 1631
                _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 = 1632
                _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 = 1633
                self.match(XplorMRParser.Attribute)
                self.state = 1635
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Abs:
                    self.state = 1634
                    self.match(XplorMRParser.Abs)


                self.state = 1637
                self.match(XplorMRParser.Attr_properties)
                self.state = 1638
                self.match(XplorMRParser.Comparison_ops)
                self.state = 1639
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 5:
                self.state = 1640
                self.match(XplorMRParser.BondedTo)
                self.state = 1641
                self.factor(27)
                pass

            elif la_ == 6:
                self.state = 1642
                self.match(XplorMRParser.ByGroup)
                self.state = 1643
                self.factor(26)
                pass

            elif la_ == 7:
                self.state = 1644
                self.match(XplorMRParser.ByRes)
                self.state = 1645
                self.factor(25)
                pass

            elif la_ == 8:
                self.state = 1646
                self.match(XplorMRParser.Chemical)
                self.state = 1653
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1647
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1648
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1651
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
                    if la_ == 1:
                        self.state = 1649
                        self.match(XplorMRParser.Colon)
                        self.state = 1650
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

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

            elif la_ == 10:
                self.state = 1656
                self.match(XplorMRParser.Id)
                self.state = 1657
                self.match(XplorMRParser.Integer)
                pass

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

            elif la_ == 12:
                self.state = 1659
                self.match(XplorMRParser.Name)
                self.state = 1666
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1660
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1661
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1664
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
                    if la_ == 1:
                        self.state = 1662
                        self.match(XplorMRParser.Colon)
                        self.state = 1663
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 13:
                self.state = 1668
                self.match(XplorMRParser.Not_op)
                self.state = 1669
                self.factor(19)
                pass

            elif la_ == 14:
                self.state = 1670
                self.match(XplorMRParser.Point)
                self.state = 1671
                self.match(XplorMRParser.L_paren)
                self.state = 1672
                self.match(XplorMRParser.Real)
                self.state = 1674
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1673
                    self.match(XplorMRParser.Comma)


                self.state = 1676
                self.match(XplorMRParser.Real)
                self.state = 1678
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1677
                    self.match(XplorMRParser.Comma)


                self.state = 1680
                self.match(XplorMRParser.Real)
                self.state = 1681
                self.match(XplorMRParser.R_paren)
                self.state = 1682
                self.match(XplorMRParser.Cut)
                self.state = 1683
                self.match(XplorMRParser.Real)
                pass

            elif la_ == 15:
                self.state = 1684
                self.match(XplorMRParser.Point)
                self.state = 1685
                self.match(XplorMRParser.L_paren)
                self.state = 1686
                self.match(XplorMRParser.Tail)
                self.state = 1687
                self.match(XplorMRParser.Equ_op)
                self.state = 1688
                self.selection()
                self.state = 1690
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1689
                    self.match(XplorMRParser.Comma)


                self.state = 1695
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Head:
                    self.state = 1692
                    self.match(XplorMRParser.Head)
                    self.state = 1693
                    self.match(XplorMRParser.Equ_op)
                    self.state = 1694
                    self.selection()


                self.state = 1697
                self.match(XplorMRParser.R_paren)
                self.state = 1698
                self.match(XplorMRParser.Cut)
                self.state = 1699
                self.match(XplorMRParser.Real)
                pass

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

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

            elif la_ == 18:
                self.state = 1703
                self.match(XplorMRParser.Residue)
                self.state = 1710
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Integers]:
                    self.state = 1704
                    self.match(XplorMRParser.Integers)
                    pass
                elif token in [XplorMRParser.Integer]:
                    self.state = 1705
                    self.match(XplorMRParser.Integer)
                    self.state = 1708
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
                    if la_ == 1:
                        self.state = 1706
                        self.match(XplorMRParser.Colon)
                        self.state = 1707
                        self.match(XplorMRParser.Integer)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 19:
                self.state = 1712
                self.match(XplorMRParser.Resname)
                self.state = 1719
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1713
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1714
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1717
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
                    if la_ == 1:
                        self.state = 1715
                        self.match(XplorMRParser.Colon)
                        self.state = 1716
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 20:
                self.state = 1721
                self.match(XplorMRParser.SegIdentifier)
                self.state = 1733
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1722
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1723
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1726
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
                    if la_ == 1:
                        self.state = 1724
                        self.match(XplorMRParser.Colon)
                        self.state = 1725
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Double_quote_string]:
                    self.state = 1728
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 1731
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
                    if la_ == 1:
                        self.state = 1729
                        self.match(XplorMRParser.Colon)
                        self.state = 1730
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 21:
                self.state = 1735
                self.match(XplorMRParser.Store_1)
                pass

            elif la_ == 22:
                self.state = 1736
                self.match(XplorMRParser.Store_2)
                pass

            elif la_ == 23:
                self.state = 1737
                self.match(XplorMRParser.Store_3)
                pass

            elif la_ == 24:
                self.state = 1738
                self.match(XplorMRParser.Store_4)
                pass

            elif la_ == 25:
                self.state = 1739
                self.match(XplorMRParser.Store_5)
                pass

            elif la_ == 26:
                self.state = 1740
                self.match(XplorMRParser.Store_6)
                pass

            elif la_ == 27:
                self.state = 1741
                self.match(XplorMRParser.Store_7)
                pass

            elif la_ == 28:
                self.state = 1742
                self.match(XplorMRParser.Store_8)
                pass

            elif la_ == 29:
                self.state = 1743
                self.match(XplorMRParser.Store_9)
                pass

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


            self._ctx.stop = self._input.LT(-1)
            self.state = 1755
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,132,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 = 1753
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
                    if la_ == 1:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1747
                        if not self.precpred(self._ctx, 30):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 30)")
                        self.state = 1748
                        self.match(XplorMRParser.Around)
                        self.state = 1749
                        self.match(XplorMRParser.Real)
                        pass

                    elif la_ == 2:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1750
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1751
                        self.match(XplorMRParser.Saround)
                        self.state = 1752
                        self.match(XplorMRParser.Real)
                        pass

             
                self.state = 1757
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,132,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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[87] = 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)
         




