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


class XplorMRParser ( Parser ):

    grammarFileName = "XplorMRParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "','", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'('", "')'", 
                     "':'", "'='", "'<'", "'>'", "'<='", "'>='", "'#'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'*'" ]

    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", "Flags", "All", 
                      "Around", "Atom", "Attribute", "BondedTo", "ByGroup", 
                      "ByRes", "Chemical", "Hydrogen", "Id", "Known", "Name", 
                      "Point", "Cut", "Previous", "Pseudo", "Residue", "Resname", 
                      "Saround", "SegIdentifier", "Store_1", "Store_2", 
                      "Store_3", "Store_4", "Store_5", "Store_6", "Store_7", 
                      "Store_8", "Store_9", "Tag", "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", 
                      "Exclude", "Include", "End_flag", "Class_name", "Any_class", 
                      "SPACE_FLAG" ]

    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
    RULE_number = 88
    RULE_number_f = 89
    RULE_number_s = 90
    RULE_flag_statement = 91

    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", "number", "number_f", "number_s", "flag_statement" ]

    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
    Flags=123
    All=124
    Around=125
    Atom=126
    Attribute=127
    BondedTo=128
    ByGroup=129
    ByRes=130
    Chemical=131
    Hydrogen=132
    Id=133
    Known=134
    Name=135
    Point=136
    Cut=137
    Previous=138
    Pseudo=139
    Residue=140
    Resname=141
    Saround=142
    SegIdentifier=143
    Store_1=144
    Store_2=145
    Store_3=146
    Store_4=147
    Store_5=148
    Store_6=149
    Store_7=150
    Store_8=151
    Store_9=152
    Tag=153
    Tail=154
    Head=155
    Or_op=156
    And_op=157
    Not_op=158
    Comma=159
    Complex=160
    Integer=161
    Logical=162
    Real=163
    Double_quote_string=164
    Simple_name=165
    Simple_names=166
    Integers=167
    L_paren=168
    R_paren=169
    Colon=170
    Equ_op=171
    Lt_op=172
    Gt_op=173
    Leq_op=174
    Geq_op=175
    Neq_op=176
    SPACE=177
    COMMENT=178
    LINE_COMMENT=179
    SET_VARIABLE=180
    Abs=181
    Attr_properties=182
    Comparison_ops=183
    SPACE_ATTR=184
    Exclude=185
    Include=186
    End_flag=187
    Class_name=188
    Any_class=189
    SPACE_FLAG=190

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




    class Xplor_nih_mrContext(ParserRuleContext):

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

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


        def 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 = 209
            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)) | (1 << (XplorMRParser.Flags - 65)))) != 0):
                self.state = 207
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 184
                    self.distance_restraint()
                    pass

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

            self.state = 215
            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 = 212
                    self.noe_assign() 
                self.state = 217
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

            self.state = 221
            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 = 218
                    self.dihedral_assign() 
                self.state = 223
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

            self.state = 227
            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 = 224
                    self.sani_assign() 
                self.state = 229
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)

            self.state = 233
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Group or _la==XplorMRParser.Initialize:
                self.state = 230
                self.planar_statement()
                self.state = 235
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 239
            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 = 236
                    self.hbond_assign() 
                self.state = 241
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)

            self.state = 245
            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 = 242
                    self.coup_assign() 
                self.state = 247
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

            self.state = 251
            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 = 248
                    self.xadc_assign() 
                self.state = 253
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

            self.state = 257
            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 = 254
                    self.coll_assign() 
                self.state = 259
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

            self.state = 263
            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 = 260
                    self.csa_assign() 
                self.state = 265
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

            self.state = 269
            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 = 266
                    self.pre_assign() 
                self.state = 271
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

            self.state = 275
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Assign:
                self.state = 272
                self.pcs_assign()
                self.state = 277
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Distance_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_distance_restraint

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

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




    def distance_restraint(self):

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

            self.state = 287
            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 End(self):
            return self.getToken(XplorMRParser.End, 0)

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_angle_restraint

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

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




    def dihedral_angle_restraint(self):

        localctx = XplorMRParser.Dihedral_angle_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_dihedral_angle_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 289
            self.match(XplorMRParser.Restraints)
            self.state = 290
            self.match(XplorMRParser.Dihedral)
            self.state = 294
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Nassign))) != 0):
                self.state = 291
                self.dihedral_statement()
                self.state = 296
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Rdc_restraintContext(ParserRuleContext):

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

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

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

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


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

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

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


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

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


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

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


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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_rdc_restraint

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

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




    def rdc_restraint(self):

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

                self.state = 306
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Xdipolar, XplorMRParser.Dipolar]:
                self.enterOuterAlt(localctx, 2)
                self.state = 307
                _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 = 311
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << XplorMRParser.Assign) | (1 << XplorMRParser.Classification) | (1 << XplorMRParser.Nrestraints) | (1 << XplorMRParser.Potential) | (1 << XplorMRParser.Print) | (1 << XplorMRParser.Reset) | (1 << XplorMRParser.Scale) | (1 << XplorMRParser.Coefficients) | (1 << XplorMRParser.ForceConstant) | (1 << XplorMRParser.Type) | (1 << XplorMRParser.Sign) | (1 << XplorMRParser.Average))) != 0):
                    self.state = 308
                    self.xdip_statement()
                    self.state = 313
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

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

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

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

                self.state = 338
                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 End(self):
            return self.getToken(XplorMRParser.End, 0)

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_restraint

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

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




    def planar_restraint(self):

        localctx = XplorMRParser.Planar_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_planar_restraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 341
            self.match(XplorMRParser.Restraints)
            self.state = 342
            self.match(XplorMRParser.Planar)
            self.state = 346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Group or _la==XplorMRParser.Initialize:
                self.state = 343
                self.planar_statement()
                self.state = 348
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            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 Antidistance_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_antidistance_restraint

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

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




    def antidistance_restraint(self):

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

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


    class Coupling_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_coupling_restraint

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

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




    def coupling_restraint(self):

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

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


    class Carbon_shift_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_restraint

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

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




    def carbon_shift_restraint(self):

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

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


    class Proton_shift_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_restraint

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

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




    def proton_shift_restraint(self):

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

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


    class Dihedral_angle_db_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_angle_db_restraint

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

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




    def dihedral_angle_db_restraint(self):

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

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


    class Radius_of_gyration_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_radius_of_gyration_restraint

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

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




    def radius_of_gyration_restraint(self):

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

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


    class Diffusion_anisotropy_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_diffusion_anisotropy_restraint

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

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




    def diffusion_anisotropy_restraint(self):

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

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


    class Orientation_db_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_orientation_db_restraint

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

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




    def orientation_db_restraint(self):

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

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


    class Csa_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_restraint

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

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




    def csa_restraint(self):

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

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


    class Pcsa_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcsa_restraint

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

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




    def pcsa_restraint(self):

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

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


    class One_bond_coupling_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_coupling_restraint

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

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




    def one_bond_coupling_restraint(self):

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

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


    class Angle_db_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_angle_db_restraint

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

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




    def angle_db_restraint(self):

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

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


    class Pre_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_restraint

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

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




    def pre_restraint(self):

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

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


    class Pcs_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_restraint

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

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




    def pcs_restraint(self):

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

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


    class Prdc_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_restraint

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

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




    def prdc_restraint(self):

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

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


    class Porientation_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_restraint

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

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




    def porientation_restraint(self):

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

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


    class Pccr_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_restraint

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

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




    def pccr_restraint(self):

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

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


    class Hbond_restraintContext(ParserRuleContext):

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_restraint

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

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




    def hbond_restraint(self):

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

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


    class Noe_statementContext(ParserRuleContext):

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

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


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

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

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


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

        def 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 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 = 584
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 513
                self.noe_assign()
                pass
            elif token in [XplorMRParser.Asymptote]:
                self.enterOuterAlt(localctx, 2)
                self.state = 514
                self.match(XplorMRParser.Asymptote)
                self.state = 515
                self.match(XplorMRParser.Simple_name)
                self.state = 516
                self.number_s()
                pass
            elif token in [XplorMRParser.Averaging]:
                self.enterOuterAlt(localctx, 3)
                self.state = 517
                self.match(XplorMRParser.Averaging)
                self.state = 518
                self.match(XplorMRParser.Simple_name)
                self.state = 519
                self.match(XplorMRParser.Noe_avr_methods)
                pass
            elif token in [XplorMRParser.Bhig]:
                self.enterOuterAlt(localctx, 4)
                self.state = 520
                self.match(XplorMRParser.Bhig)
                self.state = 521
                self.match(XplorMRParser.Simple_name)
                self.state = 522
                self.number_s()
                pass
            elif token in [XplorMRParser.Ceiling]:
                self.enterOuterAlt(localctx, 5)
                self.state = 523
                self.match(XplorMRParser.Ceiling)
                self.state = 525
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 524
                    self.match(XplorMRParser.Equ_op)


                self.state = 527
                self.number_s()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 6)
                self.state = 528
                self.match(XplorMRParser.Classification)
                self.state = 529
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.CountViol]:
                self.enterOuterAlt(localctx, 7)
                self.state = 530
                self.match(XplorMRParser.CountViol)
                self.state = 531
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Distribute]:
                self.enterOuterAlt(localctx, 8)
                self.state = 532
                self.match(XplorMRParser.Distribute)
                self.state = 533
                self.match(XplorMRParser.Simple_name)
                self.state = 534
                self.match(XplorMRParser.Simple_name)
                self.state = 535
                self.number_s()
                pass
            elif token in [XplorMRParser.Monomers]:
                self.enterOuterAlt(localctx, 9)
                self.state = 536
                self.match(XplorMRParser.Monomers)
                self.state = 537
                self.match(XplorMRParser.Simple_name)
                self.state = 538
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Ncount]:
                self.enterOuterAlt(localctx, 10)
                self.state = 539
                self.match(XplorMRParser.Ncount)
                self.state = 540
                self.match(XplorMRParser.Simple_name)
                self.state = 541
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 11)
                self.state = 542
                self.match(XplorMRParser.Nrestraints)
                self.state = 544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 543
                    self.match(XplorMRParser.Equ_op)


                self.state = 546
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 12)
                self.state = 547
                self.match(XplorMRParser.Potential)
                self.state = 548
                self.match(XplorMRParser.Simple_name)
                self.state = 549
                self.match(XplorMRParser.Noe_potential)
                pass
            elif token in [XplorMRParser.Predict]:
                self.enterOuterAlt(localctx, 13)
                self.state = 550
                self.match(XplorMRParser.Predict)
                self.state = 551
                self.predict_statement()
                self.state = 552
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 14)
                self.state = 554
                self.match(XplorMRParser.Print)
                self.state = 555
                self.match(XplorMRParser.Threshold)
                self.state = 557
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 556
                    self.match(XplorMRParser.Equ_op)


                self.state = 559
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 15)
                self.state = 560
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Rswitch]:
                self.enterOuterAlt(localctx, 16)
                self.state = 561
                self.match(XplorMRParser.Rswitch)
                self.state = 562
                self.match(XplorMRParser.Simple_name)
                self.state = 563
                self.number_s()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 17)
                self.state = 564
                self.match(XplorMRParser.Scale)
                self.state = 565
                self.match(XplorMRParser.Simple_name)
                self.state = 566
                self.number_s()
                pass
            elif token in [XplorMRParser.SoExponent]:
                self.enterOuterAlt(localctx, 18)
                self.state = 567
                self.match(XplorMRParser.SoExponent)
                self.state = 568
                self.match(XplorMRParser.Simple_name)
                self.state = 569
                self.number_s()
                pass
            elif token in [XplorMRParser.SqConstant]:
                self.enterOuterAlt(localctx, 19)
                self.state = 570
                self.match(XplorMRParser.SqConstant)
                self.state = 571
                self.match(XplorMRParser.Simple_name)
                self.state = 572
                self.number_s()
                pass
            elif token in [XplorMRParser.SqExponent]:
                self.enterOuterAlt(localctx, 20)
                self.state = 573
                self.match(XplorMRParser.SqExponent)
                self.state = 574
                self.match(XplorMRParser.Simple_name)
                self.state = 575
                self.number_s()
                pass
            elif token in [XplorMRParser.SqOffset]:
                self.enterOuterAlt(localctx, 21)
                self.state = 576
                self.match(XplorMRParser.SqOffset)
                self.state = 577
                self.match(XplorMRParser.Simple_name)
                self.state = 578
                self.number_s()
                pass
            elif token in [XplorMRParser.Temperature]:
                self.enterOuterAlt(localctx, 22)
                self.state = 579
                self.match(XplorMRParser.Temperature)
                self.state = 581
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 580
                    self.match(XplorMRParser.Equ_op)


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

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


    class Noe_assignContext(ParserRuleContext):

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

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

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


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


        def 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 = 586
            self.match(XplorMRParser.Assign)
            self.state = 587
            self.selection()
            self.state = 588
            self.selection()
            self.state = 589
            self.number()
            self.state = 590
            self.number()
            self.state = 591
            self.number()
            self.state = 598
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 592
                self.match(XplorMRParser.Or_op)
                self.state = 593
                self.selection()
                self.state = 594
                self.selection()
                self.state = 600
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Predict_statementContext(ParserRuleContext):

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

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

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


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

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

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

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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_predict_statement

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

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




    def predict_statement(self):

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


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


                self.state = 610
                self.number_s()
                pass
            elif token in [XplorMRParser.From]:
                self.enterOuterAlt(localctx, 3)
                self.state = 611
                self.match(XplorMRParser.From)
                self.state = 612
                self.selection()
                pass
            elif token in [XplorMRParser.To]:
                self.enterOuterAlt(localctx, 4)
                self.state = 613
                self.match(XplorMRParser.To)
                self.state = 614
                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):
            return self.getTypedRuleContext(XplorMRParser.Dihedral_assignContext,0)


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

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

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

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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_statement

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

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




    def dihedral_statement(self):

        localctx = XplorMRParser.Dihedral_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_dihedral_statement)
        self._la = 0 # Token type
        try:
            self.state = 626
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 617
                self.dihedral_assign()
                pass
            elif token in [XplorMRParser.Nassign]:
                self.enterOuterAlt(localctx, 2)
                self.state = 618
                self.match(XplorMRParser.Nassign)
                self.state = 620
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 619
                    self.match(XplorMRParser.Equ_op)


                self.state = 622
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 3)
                self.state = 623
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 624
                self.match(XplorMRParser.Scale)
                self.state = 625
                self.number_s()
                pass
            else:
                raise NoViableAltException(self)

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


    class Dihedral_assignContext(ParserRuleContext):

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

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

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


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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_dihedral_assign

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

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




    def dihedral_assign(self):

        localctx = XplorMRParser.Dihedral_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_dihedral_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 628
            self.match(XplorMRParser.Assign)
            self.state = 629
            self.selection()
            self.state = 630
            self.selection()
            self.state = 631
            self.selection()
            self.state = 632
            self.selection()
            self.state = 633
            self.number()
            self.state = 634
            self.number()
            self.state = 635
            self.number()
            self.state = 636
            self.match(XplorMRParser.Integer)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sani_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

        def 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)
        try:
            self.state = 656
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 638
                self.sani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 639
                self.match(XplorMRParser.Classification)
                self.state = 640
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 641
                self.match(XplorMRParser.Coefficients)
                self.state = 642
                self.number_s()
                self.state = 643
                self.number_s()
                self.state = 644
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 646
                self.match(XplorMRParser.ForceConstant)
                self.state = 647
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 648
                self.match(XplorMRParser.Nrestraints)
                self.state = 649
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 650
                self.match(XplorMRParser.Potential)
                self.state = 651
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 652
                self.match(XplorMRParser.Print)
                self.state = 653
                self.match(XplorMRParser.Threshold)
                self.state = 654
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 655
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Sani_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_sani_assign

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

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




    def sani_assign(self):

        localctx = XplorMRParser.Sani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_sani_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 658
            self.match(XplorMRParser.Assign)
            self.state = 659
            self.selection()
            self.state = 660
            self.selection()
            self.state = 661
            self.selection()
            self.state = 662
            self.selection()
            self.state = 663
            self.selection()
            self.state = 664
            self.selection()
            self.state = 665
            self.number()
            self.state = 666
            self.number()
            self.state = 668
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 667
                self.number()


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


    class Xdip_statementContext(ParserRuleContext):

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

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


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

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

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

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

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

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


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

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

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

        def 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)
        try:
            self.state = 696
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 670
                self.xdip_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 671
                self.match(XplorMRParser.Classification)
                self.state = 672
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 3)
                self.state = 673
                self.match(XplorMRParser.Type)
                self.state = 674
                self.match(XplorMRParser.Rdc_dist_fix_types)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 675
                self.match(XplorMRParser.Scale)
                self.state = 676
                self.number_s()
                pass
            elif token in [XplorMRParser.Sign]:
                self.enterOuterAlt(localctx, 5)
                self.state = 677
                self.match(XplorMRParser.Sign)
                self.state = 678
                self.match(XplorMRParser.Logical)
                pass
            elif token in [XplorMRParser.Average]:
                self.enterOuterAlt(localctx, 6)
                self.state = 679
                self.match(XplorMRParser.Average)
                self.state = 680
                self.match(XplorMRParser.Rdc_avr_methods)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 7)
                self.state = 681
                self.match(XplorMRParser.Coefficients)
                self.state = 682
                self.number_s()
                self.state = 683
                self.number_s()
                self.state = 684
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 8)
                self.state = 686
                self.match(XplorMRParser.ForceConstant)
                self.state = 687
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 688
                self.match(XplorMRParser.Nrestraints)
                self.state = 689
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 10)
                self.state = 690
                self.match(XplorMRParser.Potential)
                self.state = 691
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 11)
                self.state = 692
                self.match(XplorMRParser.Print)
                self.state = 693
                self.match(XplorMRParser.Threshold)
                self.state = 694
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 695
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Xdip_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_xdip_assign

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

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




    def xdip_assign(self):

        localctx = XplorMRParser.Xdip_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_xdip_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 698
            self.match(XplorMRParser.Assign)
            self.state = 699
            self.selection()
            self.state = 700
            self.selection()
            self.state = 701
            self.selection()
            self.state = 702
            self.selection()
            self.state = 703
            self.selection()
            self.state = 704
            self.selection()
            self.state = 705
            self.number()
            self.state = 706
            self.number()
            self.state = 713
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.state = 707
                self.number()

            elif la_ == 2:
                self.state = 708
                self.number()
                self.state = 709
                self.number()
                self.state = 710
                self.number()
                self.state = 711
                self.number()


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


    class Vean_statementContext(ParserRuleContext):

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

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


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

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

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

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

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

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_vean_statement

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

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




    def vean_statement(self):

        localctx = XplorMRParser.Vean_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_vean_statement)
        self._la = 0 # Token type
        try:
            self.state = 738
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 715
                self.vean_assign()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 2)
                self.state = 716
                self.match(XplorMRParser.Cv)
                self.state = 718
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 717
                    self.match(XplorMRParser.Equ_op)


                self.state = 720
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 721
                self.match(XplorMRParser.Classification)
                self.state = 722
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 723
                self.match(XplorMRParser.ForceConstant)
                self.state = 724
                self.number_s()
                self.state = 725
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 727
                self.match(XplorMRParser.Nrestraints)
                self.state = 728
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 6)
                self.state = 729
                self.match(XplorMRParser.Partition)
                self.state = 731
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 730
                    self.match(XplorMRParser.Equ_op)


                self.state = 733
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 734
                self.match(XplorMRParser.Print)
                self.state = 735
                self.match(XplorMRParser.Threshold)
                self.state = 736
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 737
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Vean_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_vean_assign

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

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




    def vean_assign(self):

        localctx = XplorMRParser.Vean_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_vean_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 740
            self.match(XplorMRParser.Assign)
            self.state = 741
            self.selection()
            self.state = 742
            self.selection()
            self.state = 743
            self.selection()
            self.state = 744
            self.selection()
            self.state = 745
            self.number()
            self.state = 746
            self.number()
            self.state = 747
            self.number()
            self.state = 748
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Tenso_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

        def 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)
        try:
            self.state = 763
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 750
                self.tenso_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 751
                self.match(XplorMRParser.Classification)
                self.state = 752
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 753
                self.match(XplorMRParser.Coefficients)
                self.state = 754
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 755
                self.match(XplorMRParser.Nrestraints)
                self.state = 756
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 757
                self.match(XplorMRParser.Potential)
                self.state = 758
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 759
                self.match(XplorMRParser.Print)
                self.state = 760
                self.match(XplorMRParser.Threshold)
                self.state = 761
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 762
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Tenso_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_tenso_assign

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

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




    def tenso_assign(self):

        localctx = XplorMRParser.Tenso_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_tenso_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 765
            self.match(XplorMRParser.Assign)
            self.state = 766
            self.selection()
            self.state = 767
            self.selection()
            self.state = 768
            self.number()
            self.state = 769
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Anis_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

        def 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)
        try:
            self.state = 792
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 771
                self.anis_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 772
                self.match(XplorMRParser.Classification)
                self.state = 773
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 774
                self.match(XplorMRParser.Coefficients)
                self.state = 775
                self.number_s()
                self.state = 776
                self.number_s()
                self.state = 777
                self.number_s()
                self.state = 778
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 780
                self.match(XplorMRParser.ForceConstant)
                self.state = 781
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 782
                self.match(XplorMRParser.Nrestraints)
                self.state = 783
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 784
                self.match(XplorMRParser.Potential)
                self.state = 785
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 786
                self.match(XplorMRParser.Print)
                self.state = 787
                self.match(XplorMRParser.Threshold)
                self.state = 788
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 789
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 790
                self.match(XplorMRParser.Type)
                self.state = 791
                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 number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_anis_assign

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

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




    def anis_assign(self):

        localctx = XplorMRParser.Anis_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_anis_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 794
            self.match(XplorMRParser.Assign)
            self.state = 795
            self.selection()
            self.state = 796
            self.selection()
            self.state = 797
            self.selection()
            self.state = 798
            self.selection()
            self.state = 799
            self.number()
            self.state = 800
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Planar_statementContext(ParserRuleContext):

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

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

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

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


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_statement

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

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




    def planar_statement(self):

        localctx = XplorMRParser.Planar_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_planar_statement)
        self._la = 0 # Token type
        try:
            self.state = 811
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Group]:
                self.enterOuterAlt(localctx, 1)
                self.state = 802
                self.match(XplorMRParser.Group)
                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Selection or _la==XplorMRParser.Weight:
                    self.state = 803
                    self.group_statement()
                    self.state = 808
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

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

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


    class Group_statementContext(ParserRuleContext):

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

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

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


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

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

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


        def getRuleIndex(self):
            return XplorMRParser.RULE_group_statement

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

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




    def group_statement(self):

        localctx = XplorMRParser.Group_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_group_statement)
        self._la = 0 # Token type
        try:
            self.state = 823
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Selection]:
                self.enterOuterAlt(localctx, 1)
                self.state = 813
                self.match(XplorMRParser.Selection)
                self.state = 815
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 814
                    self.match(XplorMRParser.Equ_op)


                self.state = 817
                self.selection()
                pass
            elif token in [XplorMRParser.Weight]:
                self.enterOuterAlt(localctx, 2)
                self.state = 818
                self.match(XplorMRParser.Weight)
                self.state = 820
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 819
                    self.match(XplorMRParser.Equ_op)


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

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


    class Antidistance_statementContext(ParserRuleContext):

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_antidistance_statement

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

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




    def antidistance_statement(self):

        localctx = XplorMRParser.Antidistance_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_antidistance_statement)
        try:
            self.state = 849
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 825
                self.xadc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 826
                self.match(XplorMRParser.Classification)
                self.state = 827
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 828
                self.match(XplorMRParser.Expectation)
                self.state = 829
                self.match(XplorMRParser.Integer)
                self.state = 830
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 831
                self.match(XplorMRParser.ForceConstant)
                self.state = 832
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 833
                self.match(XplorMRParser.Nrestraints)
                self.state = 834
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 835
                self.match(XplorMRParser.Print)
                self.state = 836
                self.match(XplorMRParser.Threshold)
                self.state = 837
                self.number_s()
                self.state = 841
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 838
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 839
                    self.match(XplorMRParser.Classification)
                    self.state = 840
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 843
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 8)
                self.state = 844
                self.match(XplorMRParser.Size)
                self.state = 845
                self.number_s()
                self.state = 846
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 9)
                self.state = 848
                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 = 851
            self.match(XplorMRParser.Assign)
            self.state = 852
            self.selection()
            self.state = 853
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Coupling_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

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

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

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

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

        def 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 = 894
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 855
                self.coup_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 856
                self.match(XplorMRParser.Classification)
                self.state = 857
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 858
                self.match(XplorMRParser.Coefficients)
                self.state = 859
                self.number_s()
                self.state = 860
                self.number_s()
                self.state = 861
                self.number_s()
                self.state = 862
                self.number_s()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 4)
                self.state = 864
                self.match(XplorMRParser.Cv)
                self.state = 866
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 865
                    self.match(XplorMRParser.Equ_op)


                self.state = 868
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 5)
                self.state = 869
                self.match(XplorMRParser.DegEnergy)
                self.state = 870
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 871
                self.match(XplorMRParser.ForceConstant)
                self.state = 872
                self.number_s()
                self.state = 874
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 873
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 876
                self.match(XplorMRParser.Nrestraints)
                self.state = 877
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 8)
                self.state = 878
                self.match(XplorMRParser.Partition)
                self.state = 880
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 879
                    self.match(XplorMRParser.Equ_op)


                self.state = 882
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 883
                self.match(XplorMRParser.Potential)
                self.state = 884
                self.match(XplorMRParser.Coupling_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 885
                self.match(XplorMRParser.Print)
                self.state = 886
                self.match(XplorMRParser.Threshold)
                self.state = 887
                self.number_s()
                self.state = 891
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 888
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 889
                    self.match(XplorMRParser.Classification)
                    self.state = 890
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

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

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


    class Coup_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_coup_assign

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

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




    def coup_assign(self):

        localctx = XplorMRParser.Coup_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_coup_assign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 896
            self.match(XplorMRParser.Assign)
            self.state = 897
            self.selection()
            self.state = 898
            self.selection()
            self.state = 899
            self.selection()
            self.state = 900
            self.selection()
            self.state = 906
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 901
                self.selection()
                self.state = 902
                self.selection()
                self.state = 903
                self.selection()
                self.state = 904
                self.selection()


            self.state = 908
            self.number()
            self.state = 909
            self.number()
            self.state = 913
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 910
                self.number()
                self.state = 911
                self.number()


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


    class Carbon_shift_statementContext(ParserRuleContext):

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

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


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

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

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

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

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


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

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

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

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

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

        def 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):
            return self.getTypedRuleContext(XplorMRParser.Carbon_shift_rcoilContext,0)


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_statement

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

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




    def carbon_shift_statement(self):

        localctx = XplorMRParser.Carbon_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_carbon_shift_statement)
        try:
            self.state = 941
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 915
                self.carbon_shift_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 916
                self.match(XplorMRParser.Classification)
                self.state = 917
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 918
                self.match(XplorMRParser.Expectation)
                self.state = 919
                self.match(XplorMRParser.Integer)
                self.state = 920
                self.match(XplorMRParser.Integer)
                self.state = 921
                self.number_s()
                self.state = 922
                self.number_s()
                self.state = 923
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 925
                self.match(XplorMRParser.ForceConstant)
                self.state = 926
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 927
                self.match(XplorMRParser.Nrestraints)
                self.state = 928
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.PhiStep]:
                self.enterOuterAlt(localctx, 6)
                self.state = 929
                self.match(XplorMRParser.PhiStep)
                self.state = 930
                self.number_s()
                pass
            elif token in [XplorMRParser.PsiStep]:
                self.enterOuterAlt(localctx, 7)
                self.state = 931
                self.match(XplorMRParser.PsiStep)
                self.state = 932
                self.number_s()
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 933
                self.match(XplorMRParser.Potential)
                self.state = 934
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 935
                self.match(XplorMRParser.Print)
                self.state = 936
                self.match(XplorMRParser.Threshold)
                self.state = 937
                self.number_s()
                pass
            elif token in [XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 10)
                self.state = 938
                self.carbon_shift_rcoil()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 939
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 940
                self.match(XplorMRParser.Zero)
                pass
            else:
                raise NoViableAltException(self)

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


    class Carbon_shift_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_assign

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

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




    def carbon_shift_assign(self):

        localctx = XplorMRParser.Carbon_shift_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_carbon_shift_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 943
            self.match(XplorMRParser.Assign)
            self.state = 944
            self.selection()
            self.state = 945
            self.selection()
            self.state = 946
            self.selection()
            self.state = 947
            self.selection()
            self.state = 948
            self.selection()
            self.state = 949
            self.number()
            self.state = 950
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Carbon_shift_rcoilContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_rcoil

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

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




    def carbon_shift_rcoil(self):

        localctx = XplorMRParser.Carbon_shift_rcoilContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_carbon_shift_rcoil)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 952
            self.match(XplorMRParser.Rcoil)
            self.state = 953
            self.selection()
            self.state = 954
            self.number_s()
            self.state = 955
            self.number_s()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_statementContext(ParserRuleContext):

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

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


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


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


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


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


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


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


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


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


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

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

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

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


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

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

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

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

        def 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 = 990
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Observed]:
                self.enterOuterAlt(localctx, 1)
                self.state = 957
                self.observed()
                pass
            elif token in [XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 2)
                self.state = 958
                self.proton_shift_rcoil()
                pass
            elif token in [XplorMRParser.Anisotropy]:
                self.enterOuterAlt(localctx, 3)
                self.state = 959
                self.proton_shift_anisotropy()
                pass
            elif token in [XplorMRParser.Amides]:
                self.enterOuterAlt(localctx, 4)
                self.state = 960
                self.proton_shift_amides()
                pass
            elif token in [XplorMRParser.Carbons]:
                self.enterOuterAlt(localctx, 5)
                self.state = 961
                self.proton_shift_carbons()
                pass
            elif token in [XplorMRParser.Nitrogens]:
                self.enterOuterAlt(localctx, 6)
                self.state = 962
                self.proton_shift_nitrogens()
                pass
            elif token in [XplorMRParser.Oxygens]:
                self.enterOuterAlt(localctx, 7)
                self.state = 963
                self.proton_shift_oxygens()
                pass
            elif token in [XplorMRParser.RingAtoms]:
                self.enterOuterAlt(localctx, 8)
                self.state = 964
                self.proton_shift_ring_atoms()
                pass
            elif token in [XplorMRParser.AlphasAndAmides]:
                self.enterOuterAlt(localctx, 9)
                self.state = 965
                self.proton_shift_alphas_and_amides()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 10)
                self.state = 966
                self.match(XplorMRParser.Classification)
                self.state = 967
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 11)
                self.state = 968
                self.match(XplorMRParser.Error)
                self.state = 969
                self.number_s()
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 12)
                self.state = 970
                self.match(XplorMRParser.DegEnergy)
                self.state = 971
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 13)
                self.state = 972
                self.match(XplorMRParser.ForceConstant)
                self.state = 973
                self.number_s()
                self.state = 975
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 974
                    self.number_s()


                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 14)
                self.state = 977
                self.match(XplorMRParser.Potential)
                self.state = 978
                self.match(XplorMRParser.Coupling_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 15)
                self.state = 979
                self.match(XplorMRParser.Print)
                self.state = 980
                self.match(XplorMRParser.Threshold)
                self.state = 981
                self.number_s()
                self.state = 985
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 982
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 983
                    self.match(XplorMRParser.Classification)
                    self.state = 984
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

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

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


    class ObservedContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_observed

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

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




    def observed(self):

        localctx = XplorMRParser.ObservedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_observed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 992
            self.match(XplorMRParser.Observed)
            self.state = 993
            self.selection()
            self.state = 995
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 994
                self.selection()


            self.state = 997
            self.number_s()
            self.state = 999
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 998
                self.number_s()


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


    class Proton_shift_rcoilContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_rcoil

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

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




    def proton_shift_rcoil(self):

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


    class Proton_shift_anisotropyContext(ParserRuleContext):

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

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

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


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_anisotropy

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

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




    def proton_shift_anisotropy(self):

        localctx = XplorMRParser.Proton_shift_anisotropyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_proton_shift_anisotropy)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1005
            self.match(XplorMRParser.Anisotropy)
            self.state = 1006
            self.selection()
            self.state = 1007
            self.selection()
            self.state = 1008
            self.selection()
            self.state = 1009
            self.match(XplorMRParser.Simple_name)
            self.state = 1011
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Logical:
                self.state = 1010
                self.match(XplorMRParser.Logical)


            self.state = 1013
            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 = 1015
            self.match(XplorMRParser.Amides)
            self.state = 1016
            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 = 1018
            self.match(XplorMRParser.Carbons)
            self.state = 1019
            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 = 1021
            self.match(XplorMRParser.Nitrogens)
            self.state = 1022
            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 = 1024
            self.match(XplorMRParser.Oxygens)
            self.state = 1025
            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 = 1027
            self.match(XplorMRParser.RingAtoms)
            self.state = 1028
            self.match(XplorMRParser.Simple_name)
            self.state = 1029
            self.selection()
            self.state = 1030
            self.selection()
            self.state = 1031
            self.selection()
            self.state = 1032
            self.selection()
            self.state = 1033
            self.selection()
            self.state = 1035
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1034
                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 = 1037
            self.match(XplorMRParser.AlphasAndAmides)
            self.state = 1038
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ramachandran_statementContext(ParserRuleContext):

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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_ramachandran_statement

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

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




    def ramachandran_statement(self):

        localctx = XplorMRParser.Ramachandran_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_ramachandran_statement)
        self._la = 0 # Token type
        try:
            self.state = 1142
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1040
                self.rama_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1041
                self.match(XplorMRParser.Classification)
                self.state = 1042
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1043
                self.match(XplorMRParser.Cutoff)
                self.state = 1044
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1045
                self.match(XplorMRParser.ForceConstant)
                self.state = 1046
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1047
                self.match(XplorMRParser.Gaussian)
                self.state = 1048
                self.number_s()
                self.state = 1049
                self.number_s()
                self.state = 1050
                self.number_s()
                self.state = 1055
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
                if la_ == 1:
                    self.state = 1051
                    self.number_s()
                    self.state = 1052
                    self.number_s()
                    self.state = 1053
                    self.number_s()


                self.state = 1061
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
                if la_ == 1:
                    self.state = 1057
                    self.number_s()
                    self.state = 1058
                    self.number_s()
                    self.state = 1059
                    self.number_s()


                self.state = 1067
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1063
                    self.number_s()
                    self.state = 1064
                    self.number_s()
                    self.state = 1065
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1069
                self.match(XplorMRParser.Nrestraints)
                self.state = 1070
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Phase]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1071
                self.match(XplorMRParser.Phase)
                self.state = 1072
                self.number_s()
                self.state = 1073
                self.number_s()
                self.state = 1074
                self.number_s()
                self.state = 1079
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
                if la_ == 1:
                    self.state = 1075
                    self.number_s()
                    self.state = 1076
                    self.number_s()
                    self.state = 1077
                    self.number_s()


                self.state = 1085
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                if la_ == 1:
                    self.state = 1081
                    self.number_s()
                    self.state = 1082
                    self.number_s()
                    self.state = 1083
                    self.number_s()


                self.state = 1091
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1087
                    self.number_s()
                    self.state = 1088
                    self.number_s()
                    self.state = 1089
                    self.number_s()


                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1093
                self.match(XplorMRParser.Print)
                self.state = 1094
                self.match(XplorMRParser.Threshold)
                self.state = 1095
                self.number_s()
                self.state = 1099
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1096
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1097
                    self.match(XplorMRParser.Classification)
                    self.state = 1098
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1101
                self.match(XplorMRParser.Quartic)
                self.state = 1102
                self.number_s()
                self.state = 1103
                self.number_s()
                self.state = 1104
                self.number_s()
                self.state = 1109
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
                if la_ == 1:
                    self.state = 1105
                    self.number_s()
                    self.state = 1106
                    self.number_s()
                    self.state = 1107
                    self.number_s()


                self.state = 1115
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
                if la_ == 1:
                    self.state = 1111
                    self.number_s()
                    self.state = 1112
                    self.number_s()
                    self.state = 1113
                    self.number_s()


                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1117
                    self.number_s()
                    self.state = 1118
                    self.number_s()
                    self.state = 1119
                    self.number_s()


                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1123
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1124
                self.match(XplorMRParser.Scale)
                self.state = 1125
                self.number_s()
                pass
            elif token in [XplorMRParser.Shape]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1126
                self.match(XplorMRParser.Shape)
                self.state = 1127
                self.match(XplorMRParser.Gauss_or_Quart)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1128
                self.match(XplorMRParser.Size)
                self.state = 1129
                self.match(XplorMRParser.Dimensions)
                self.state = 1130
                self.number_s()
                self.state = 1132
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                if la_ == 1:
                    self.state = 1131
                    self.number_s()


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


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


                pass
            elif token in [XplorMRParser.Sort]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1140
                self.match(XplorMRParser.Sort)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1141
                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 = 1144
            self.match(XplorMRParser.Assign)
            self.state = 1145
            self.selection()
            self.state = 1146
            self.selection()
            self.state = 1147
            self.selection()
            self.state = 1148
            self.selection()
            self.state = 1154
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.state = 1149
                self.selection()
                self.state = 1150
                self.selection()
                self.state = 1151
                self.selection()
                self.state = 1152
                self.selection()


            self.state = 1161
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.state = 1156
                self.selection()
                self.state = 1157
                self.selection()
                self.state = 1158
                self.selection()
                self.state = 1159
                self.selection()


            self.state = 1168
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1163
                self.selection()
                self.state = 1164
                self.selection()
                self.state = 1165
                self.selection()
                self.state = 1166
                self.selection()


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


    class Collapse_statementContext(ParserRuleContext):

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

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


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

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


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_collapse_statement

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

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




    def collapse_statement(self):

        localctx = XplorMRParser.Collapse_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_collapse_statement)
        try:
            self.state = 1175
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1170
                self.coll_assign()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1171
                self.match(XplorMRParser.Scale)
                self.state = 1172
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1173
                self.match(XplorMRParser.Print)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1174
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Coll_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_coll_assign

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

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




    def coll_assign(self):

        localctx = XplorMRParser.Coll_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_coll_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1177
            self.match(XplorMRParser.Assign)
            self.state = 1178
            self.selection()
            self.state = 1179
            self.number()
            self.state = 1180
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Diffusion_statementContext(ParserRuleContext):

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

        def dani_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Dani_assignContext,0)


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

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

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

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


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

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

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

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

        def 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)
        try:
            self.state = 1204
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1182
                self.dani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1183
                self.match(XplorMRParser.Classification)
                self.state = 1184
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1185
                self.match(XplorMRParser.Coefficients)
                self.state = 1186
                self.number_s()
                self.state = 1187
                self.number_s()
                self.state = 1188
                self.number_s()
                self.state = 1189
                self.number_s()
                self.state = 1190
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1192
                self.match(XplorMRParser.ForceConstant)
                self.state = 1193
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1194
                self.match(XplorMRParser.Nrestraints)
                self.state = 1195
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1196
                self.match(XplorMRParser.Potential)
                self.state = 1197
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1198
                self.match(XplorMRParser.Print)
                self.state = 1199
                self.match(XplorMRParser.Threshold)
                self.state = 1200
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1201
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1202
                self.match(XplorMRParser.Type)
                self.state = 1203
                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 number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.NumberContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.NumberContext,i)


        def getRuleIndex(self):
            return XplorMRParser.RULE_dani_assign

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

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




    def dani_assign(self):

        localctx = XplorMRParser.Dani_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_dani_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1206
            self.match(XplorMRParser.Assign)
            self.state = 1207
            self.selection()
            self.state = 1208
            self.selection()
            self.state = 1209
            self.selection()
            self.state = 1210
            self.selection()
            self.state = 1211
            self.selection()
            self.state = 1212
            self.selection()
            self.state = 1213
            self.number()
            self.state = 1214
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Orientation_statementContext(ParserRuleContext):

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

        def orie_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Orie_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_orientation_statement

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

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




    def orientation_statement(self):

        localctx = XplorMRParser.Orientation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_orientation_statement)
        try:
            self.state = 1273
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1216
                self.orie_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1217
                self.match(XplorMRParser.Classification)
                self.state = 1218
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1219
                self.match(XplorMRParser.Cutoff)
                self.state = 1220
                self.number_s()
                pass
            elif token in [XplorMRParser.Height]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1221
                self.match(XplorMRParser.Height)
                self.state = 1222
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1223
                self.match(XplorMRParser.ForceConstant)
                self.state = 1224
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1225
                self.match(XplorMRParser.Gaussian)
                self.state = 1226
                self.number_s()
                self.state = 1227
                self.number_s()
                self.state = 1228
                self.number_s()
                self.state = 1229
                self.number_s()
                self.state = 1230
                self.number_s()
                self.state = 1231
                self.number_s()
                self.state = 1232
                self.number_s()
                pass
            elif token in [XplorMRParser.MaxGaussians]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1234
                self.match(XplorMRParser.MaxGaussians)
                self.state = 1235
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.NewGaussian]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1236
                self.match(XplorMRParser.NewGaussian)
                self.state = 1237
                self.number_s()
                self.state = 1238
                self.number_s()
                self.state = 1239
                self.number_s()
                self.state = 1240
                self.number_s()
                self.state = 1241
                self.number_s()
                self.state = 1242
                self.number_s()
                self.state = 1243
                self.number_s()
                self.state = 1244
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1246
                self.match(XplorMRParser.Nrestraints)
                self.state = 1247
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1248
                self.match(XplorMRParser.Print)
                self.state = 1249
                self.match(XplorMRParser.Threshold)
                self.state = 1250
                self.number_s()
                self.state = 1254
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1251
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1252
                    self.match(XplorMRParser.Classification)
                    self.state = 1253
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1256
                self.match(XplorMRParser.Quartic)
                self.state = 1257
                self.number_s()
                self.state = 1258
                self.number_s()
                self.state = 1259
                self.number_s()
                self.state = 1260
                self.number_s()
                self.state = 1261
                self.number_s()
                self.state = 1262
                self.number_s()
                self.state = 1263
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1265
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Residue]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1266
                self.match(XplorMRParser.Residue)
                self.state = 1267
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1268
                self.match(XplorMRParser.Size)
                self.state = 1269
                self.number_s()
                self.state = 1270
                self.number_s()
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1272
                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 = 1275
            self.match(XplorMRParser.Assign)
            self.state = 1276
            self.selection()
            self.state = 1277
            self.selection()
            self.state = 1278
            self.selection()
            self.state = 1279
            self.selection()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Csa_statementContext(ParserRuleContext):

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

        def csa_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,0)


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

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

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

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


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

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

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

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

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

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

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

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

        def 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)
        try:
            self.state = 1308
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1281
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1282
                self.match(XplorMRParser.Classification)
                self.state = 1283
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1284
                self.match(XplorMRParser.Scale)
                self.state = 1285
                self.number_s()
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1286
                self.match(XplorMRParser.Type)
                self.state = 1287
                self.match(XplorMRParser.Csa_types)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1288
                self.match(XplorMRParser.Coefficients)
                self.state = 1289
                self.number_s()
                self.state = 1290
                self.number_s()
                self.state = 1291
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1293
                self.match(XplorMRParser.Sigma)
                self.state = 1294
                self.number_s()
                self.state = 1295
                self.number_s()
                self.state = 1296
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1298
                self.match(XplorMRParser.ForceConstant)
                self.state = 1299
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1300
                self.match(XplorMRParser.Nrestraints)
                self.state = 1301
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1302
                self.match(XplorMRParser.Potential)
                self.state = 1303
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1304
                self.match(XplorMRParser.Print)
                self.state = 1305
                self.match(XplorMRParser.Threshold)
                self.state = 1306
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1307
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Csa_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_csa_assign

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

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




    def csa_assign(self):

        localctx = XplorMRParser.Csa_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_csa_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1310
            self.match(XplorMRParser.Assign)
            self.state = 1311
            self.selection()
            self.state = 1312
            self.selection()
            self.state = 1313
            self.selection()
            self.state = 1314
            self.selection()
            self.state = 1315
            self.selection()
            self.state = 1316
            self.selection()
            self.state = 1317
            self.selection()
            self.state = 1318
            self.number()
            self.state = 1319
            self.number()
            self.state = 1320
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcsa_statementContext(ParserRuleContext):

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

        def csa_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Csa_assignContext,0)


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

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

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

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


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

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

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

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

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

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

        def 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)
        try:
            self.state = 1348
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1322
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1323
                self.match(XplorMRParser.Classification)
                self.state = 1324
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1325
                self.match(XplorMRParser.Scale)
                self.state = 1326
                self.number_s()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1327
                self.match(XplorMRParser.Coefficients)
                self.state = 1328
                self.number_s()
                self.state = 1329
                self.number_s()
                self.state = 1330
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1332
                self.match(XplorMRParser.Sigma)
                self.state = 1333
                self.number_s()
                self.state = 1334
                self.number_s()
                self.state = 1335
                self.number_s()
                self.state = 1336
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1338
                self.match(XplorMRParser.ForceConstant)
                self.state = 1339
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1340
                self.match(XplorMRParser.Nrestraints)
                self.state = 1341
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1342
                self.match(XplorMRParser.Potential)
                self.state = 1343
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1344
                self.match(XplorMRParser.Print)
                self.state = 1345
                self.match(XplorMRParser.Threshold)
                self.state = 1346
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1347
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class One_bond_coupling_statementContext(ParserRuleContext):

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

        def one_bond_assign(self):
            return self.getTypedRuleContext(XplorMRParser.One_bond_assignContext,0)


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

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

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

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


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

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

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

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

        def 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)
        try:
            self.state = 1372
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1350
                self.one_bond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1351
                self.match(XplorMRParser.Classification)
                self.state = 1352
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1353
                self.match(XplorMRParser.Coefficients)
                self.state = 1354
                self.number_s()
                self.state = 1355
                self.number_s()
                self.state = 1356
                self.number_s()
                self.state = 1357
                self.number_s()
                self.state = 1358
                self.number_s()
                self.state = 1359
                self.number_s()
                self.state = 1360
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1362
                self.match(XplorMRParser.ForceConstant)
                self.state = 1363
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1364
                self.match(XplorMRParser.Nrestraints)
                self.state = 1365
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1366
                self.match(XplorMRParser.Potential)
                self.state = 1367
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1368
                self.match(XplorMRParser.Print)
                self.state = 1369
                self.match(XplorMRParser.Threshold)
                self.state = 1370
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1371
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class One_bond_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_one_bond_assign

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

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




    def one_bond_assign(self):

        localctx = XplorMRParser.One_bond_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_one_bond_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1374
            self.match(XplorMRParser.Assign)
            self.state = 1375
            self.selection()
            self.state = 1376
            self.selection()
            self.state = 1377
            self.selection()
            self.state = 1378
            self.selection()
            self.state = 1379
            self.selection()
            self.state = 1380
            self.selection()
            self.state = 1381
            self.selection()
            self.state = 1382
            self.selection()
            self.state = 1383
            self.number()
            self.state = 1384
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angle_db_statementContext(ParserRuleContext):

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

        def angle_db_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Angle_db_assignContext,0)


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

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

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

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

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

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


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

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

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

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

        def 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)
        try:
            self.state = 1417
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1386
                self.angle_db_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1387
                self.match(XplorMRParser.Classification)
                self.state = 1388
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.DerivFlag]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1389
                self.match(XplorMRParser.DerivFlag)
                self.state = 1390
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1391
                self.match(XplorMRParser.Expectation)
                self.state = 1392
                self.match(XplorMRParser.Integer)
                self.state = 1393
                self.match(XplorMRParser.Integer)
                self.state = 1394
                self.number_s()
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1395
                self.match(XplorMRParser.Error)
                self.state = 1396
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1397
                self.match(XplorMRParser.ForceConstant)
                self.state = 1398
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1399
                self.match(XplorMRParser.Nrestraints)
                self.state = 1400
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1401
                self.match(XplorMRParser.Potential)
                self.state = 1402
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1403
                self.match(XplorMRParser.Print)
                self.state = 1404
                self.match(XplorMRParser.Threshold)
                self.state = 1405
                self.number_s()
                self.state = 1409
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1406
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1407
                    self.match(XplorMRParser.Classification)
                    self.state = 1408
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1411
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1412
                self.match(XplorMRParser.Size)
                self.state = 1413
                self.match(XplorMRParser.Angle_dihedral)
                self.state = 1414
                self.match(XplorMRParser.Integer)
                self.state = 1415
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1416
                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 = 1419
            self.match(XplorMRParser.Assign)
            self.state = 1420
            self.selection()
            self.state = 1421
            self.selection()
            self.state = 1422
            self.selection()
            self.state = 1423
            self.selection()
            self.state = 1424
            self.selection()
            self.state = 1425
            self.selection()
            self.state = 1426
            self.selection()
            self.state = 1427
            self.selection()
            self.state = 1428
            self.selection()
            self.state = 1429
            self.selection()
            self.state = 1430
            self.selection()
            self.state = 1432
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1431
                self.selection()


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


    class Pre_statementContext(ParserRuleContext):

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

        def pre_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pre_assignContext,0)


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

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

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

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

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


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

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

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

        def 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 = 1487
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1434
                self.pre_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1435
                self.match(XplorMRParser.Classification)
                self.state = 1437
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1436
                    self.match(XplorMRParser.Equ_op)


                self.state = 1439
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1440
                self.match(XplorMRParser.ForceConstant)
                self.state = 1442
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1441
                    self.match(XplorMRParser.Equ_op)


                self.state = 1444
                self.match(XplorMRParser.Simple_name)
                self.state = 1445
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1446
                self.match(XplorMRParser.Nrestraints)
                self.state = 1448
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1447
                    self.match(XplorMRParser.Equ_op)


                self.state = 1450
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1451
                self.match(XplorMRParser.Potential)
                self.state = 1453
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1452
                    self.match(XplorMRParser.Equ_op)


                self.state = 1455
                self.match(XplorMRParser.Simple_name)
                self.state = 1456
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Kconst]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1457
                self.match(XplorMRParser.Kconst)
                self.state = 1459
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1458
                    self.match(XplorMRParser.Equ_op)


                self.state = 1461
                self.match(XplorMRParser.Simple_name)
                self.state = 1462
                self.number_s()
                pass
            elif token in [XplorMRParser.Omega]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1463
                self.match(XplorMRParser.Omega)
                self.state = 1465
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1464
                    self.match(XplorMRParser.Equ_op)


                self.state = 1467
                self.match(XplorMRParser.Simple_name)
                self.state = 1468
                self.number_s()
                pass
            elif token in [XplorMRParser.Tauc]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1469
                self.match(XplorMRParser.Tauc)
                self.state = 1471
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1470
                    self.match(XplorMRParser.Equ_op)


                self.state = 1473
                self.match(XplorMRParser.Simple_name)
                self.state = 1474
                self.number_s()
                self.state = 1475
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1477
                self.match(XplorMRParser.Print)
                self.state = 1478
                self.match(XplorMRParser.Threshold)
                self.state = 1479
                self.number_s()
                self.state = 1483
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1480
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1481
                    self.match(XplorMRParser.Classification)
                    self.state = 1482
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

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

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


    class Pre_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pre_assign

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

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




    def pre_assign(self):

        localctx = XplorMRParser.Pre_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_pre_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1489
            self.match(XplorMRParser.Assign)
            self.state = 1490
            self.selection()
            self.state = 1491
            self.selection()
            self.state = 1492
            self.number()
            self.state = 1493
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pcs_statementContext(ParserRuleContext):

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

        def pcs_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pcs_assignContext,0)


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_statement

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

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




    def pcs_statement(self):

        localctx = XplorMRParser.Pcs_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_pcs_statement)
        try:
            self.state = 1531
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1495
                self.pcs_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1496
                self.match(XplorMRParser.Classification)
                self.state = 1497
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1498
                self.match(XplorMRParser.Tolerance)
                self.state = 1499
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1500
                self.match(XplorMRParser.Coefficients)
                self.state = 1501
                self.number_s()
                self.state = 1502
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1504
                self.match(XplorMRParser.ForceConstant)
                self.state = 1505
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1506
                self.match(XplorMRParser.Nrestraints)
                self.state = 1507
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1508
                self.match(XplorMRParser.Print)
                self.state = 1509
                self.match(XplorMRParser.Threshold)
                self.state = 1510
                self.number_s()
                self.state = 1514
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1511
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1512
                    self.match(XplorMRParser.Classification)
                    self.state = 1513
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1516
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1517
                self.match(XplorMRParser.Save)
                self.state = 1518
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1519
                self.match(XplorMRParser.Fmed)
                self.state = 1520
                self.number_s()
                self.state = 1521
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1523
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1524
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1525
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1526
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1527
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1528
                self.match(XplorMRParser.Soff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1529
                self.match(XplorMRParser.Frun)
                self.state = 1530
                self.match(XplorMRParser.Integer)
                pass
            else:
                raise NoViableAltException(self)

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


    class Pcs_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pcs_assign

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

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




    def pcs_assign(self):

        localctx = XplorMRParser.Pcs_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_pcs_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1533
            self.match(XplorMRParser.Assign)
            self.state = 1534
            self.selection()
            self.state = 1535
            self.selection()
            self.state = 1536
            self.selection()
            self.state = 1537
            self.selection()
            self.state = 1538
            self.selection()
            self.state = 1539
            self.number()
            self.state = 1540
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Prdc_statementContext(ParserRuleContext):

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

        def prdc_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Prdc_assignContext,0)


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_statement

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

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




    def prdc_statement(self):

        localctx = XplorMRParser.Prdc_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_prdc_statement)
        try:
            self.state = 1568
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1542
                self.prdc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1543
                self.match(XplorMRParser.Classification)
                self.state = 1544
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1545
                self.match(XplorMRParser.Tolerance)
                self.state = 1546
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1547
                self.match(XplorMRParser.Coefficients)
                self.state = 1548
                self.number_s()
                self.state = 1549
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1551
                self.match(XplorMRParser.ForceConstant)
                self.state = 1552
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1553
                self.match(XplorMRParser.Nrestraints)
                self.state = 1554
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1555
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1556
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1557
                self.match(XplorMRParser.Fmed)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1558
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1559
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1560
                self.match(XplorMRParser.Frun)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1561
                self.match(XplorMRParser.Print)
                self.state = 1562
                self.match(XplorMRParser.Threshold)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1563
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1564
                self.match(XplorMRParser.Save)
                self.state = 1565
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1566
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1567
                self.match(XplorMRParser.Soff)
                pass
            else:
                raise NoViableAltException(self)

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


    class Prdc_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_prdc_assign

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

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




    def prdc_assign(self):

        localctx = XplorMRParser.Prdc_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_prdc_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1570
            self.match(XplorMRParser.Assign)
            self.state = 1571
            self.selection()
            self.state = 1572
            self.selection()
            self.state = 1573
            self.selection()
            self.state = 1574
            self.selection()
            self.state = 1575
            self.selection()
            self.state = 1576
            self.selection()
            self.state = 1577
            self.number()
            self.state = 1578
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Porientation_statementContext(ParserRuleContext):

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

        def porientation_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Porientation_assignContext,0)


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

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

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_statement

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

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




    def porientation_statement(self):

        localctx = XplorMRParser.Porientation_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_porientation_statement)
        try:
            self.state = 1591
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1580
                self.porientation_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1581
                self.match(XplorMRParser.Classification)
                self.state = 1582
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1583
                self.match(XplorMRParser.ForceConstant)
                self.state = 1584
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1585
                self.match(XplorMRParser.Nrestraints)
                self.state = 1586
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1587
                self.match(XplorMRParser.Print)
                self.state = 1588
                self.match(XplorMRParser.Threshold)
                self.state = 1589
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1590
                self.match(XplorMRParser.Reset)
                pass
            else:
                raise NoViableAltException(self)

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


    class Porientation_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_porientation_assign

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

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




    def porientation_assign(self):

        localctx = XplorMRParser.Porientation_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_porientation_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1593
            self.match(XplorMRParser.Assign)
            self.state = 1594
            self.selection()
            self.state = 1595
            self.selection()
            self.state = 1596
            self.number()
            self.state = 1597
            self.number()
            self.state = 1598
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pccr_statementContext(ParserRuleContext):

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

        def pccr_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Pccr_assignContext,0)


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

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

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

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

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

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


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

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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_statement

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

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




    def pccr_statement(self):

        localctx = XplorMRParser.Pccr_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_pccr_statement)
        try:
            self.state = 1617
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1600
                self.pccr_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1601
                self.match(XplorMRParser.Classification)
                self.state = 1602
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Weip]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1603
                self.match(XplorMRParser.Weip)
                self.state = 1604
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1605
                self.match(XplorMRParser.Coefficients)
                self.state = 1606
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1607
                self.match(XplorMRParser.ForceConstant)
                self.state = 1608
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1609
                self.match(XplorMRParser.Nrestraints)
                self.state = 1610
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1611
                self.match(XplorMRParser.Print)
                self.state = 1612
                self.match(XplorMRParser.Threshold)
                self.state = 1613
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1614
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1615
                self.match(XplorMRParser.Frun)
                self.state = 1616
                self.match(XplorMRParser.Integer)
                pass
            else:
                raise NoViableAltException(self)

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


    class Pccr_assignContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_pccr_assign

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

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




    def pccr_assign(self):

        localctx = XplorMRParser.Pccr_assignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_pccr_assign)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1619
            self.match(XplorMRParser.Assign)
            self.state = 1620
            self.selection()
            self.state = 1621
            self.selection()
            self.state = 1622
            self.selection()
            self.state = 1623
            self.number()
            self.state = 1624
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_statementContext(ParserRuleContext):

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

        def hbond_assign(self):
            return self.getTypedRuleContext(XplorMRParser.Hbond_assignContext,0)


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

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

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_hbond_statement

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

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




    def hbond_statement(self):

        localctx = XplorMRParser.Hbond_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_hbond_statement)
        try:
            self.state = 1637
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1626
                self.hbond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1627
                self.match(XplorMRParser.Classification)
                self.state = 1628
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1629
                self.match(XplorMRParser.ForceConstant)
                self.state = 1630
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1631
                self.match(XplorMRParser.Nrestraints)
                self.state = 1632
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1633
                self.match(XplorMRParser.Print)
                self.state = 1634
                self.match(XplorMRParser.Threshold)
                self.state = 1635
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1636
                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 = 1639
            self.match(XplorMRParser.Assign)
            self.state = 1640
            self.selection()
            self.state = 1641
            self.selection()
            self.state = 1642
            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 = 1644
            self.match(XplorMRParser.L_paren)
            self.state = 1645
            self.selection_expression()
            self.state = 1646
            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 = 1648
            self.term()
            self.state = 1653
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 1649
                self.match(XplorMRParser.Or_op)
                self.state = 1650
                self.term()
                self.state = 1655
                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 = 1656
            self.factor(0)
            self.state = 1661
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.And_op:
                self.state = 1657
                self.match(XplorMRParser.And_op)
                self.state = 1658
                self.factor(0)
                self.state = 1663
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class FactorContext(ParserRuleContext):

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

        def Store_6(self):
            return self.getToken(XplorMRParser.Store_6, 0)

        def Store_7(self):
            return self.getToken(XplorMRParser.Store_7, 0)

        def Store_8(self):
            return self.getToken(XplorMRParser.Store_8, 0)

        def Store_9(self):
            return self.getToken(XplorMRParser.Store_9, 0)

        def Tag(self):
            return self.getToken(XplorMRParser.Tag, 0)

        def Around(self):
            return self.getToken(XplorMRParser.Around, 0)

        def Saround(self):
            return self.getToken(XplorMRParser.Saround, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_factor

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFactor" ):
                listener.enterFactor(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFactor" ):
                listener.exitFactor(self)



    def factor(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = XplorMRParser.FactorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 174
        self.enterRecursionRule(localctx, 174, self.RULE_factor, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1791
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1665
                self.match(XplorMRParser.L_paren)
                self.state = 1666
                self.selection_expression()
                self.state = 1667
                self.match(XplorMRParser.R_paren)
                pass

            elif la_ == 2:
                self.state = 1669
                self.match(XplorMRParser.All)
                pass

            elif la_ == 3:
                self.state = 1670
                self.match(XplorMRParser.Atom)
                self.state = 1671
                _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 = 1672
                _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 = 1673
                _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 = 1674
                self.match(XplorMRParser.Attribute)
                self.state = 1676
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Abs:
                    self.state = 1675
                    self.match(XplorMRParser.Abs)


                self.state = 1678
                self.match(XplorMRParser.Attr_properties)
                self.state = 1679
                self.match(XplorMRParser.Comparison_ops)
                self.state = 1680
                self.number_f()
                pass

            elif la_ == 5:
                self.state = 1681
                self.match(XplorMRParser.BondedTo)
                self.state = 1682
                self.factor(27)
                pass

            elif la_ == 6:
                self.state = 1683
                self.match(XplorMRParser.ByGroup)
                self.state = 1684
                self.factor(26)
                pass

            elif la_ == 7:
                self.state = 1685
                self.match(XplorMRParser.ByRes)
                self.state = 1686
                self.factor(25)
                pass

            elif la_ == 8:
                self.state = 1687
                self.match(XplorMRParser.Chemical)
                self.state = 1694
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1688
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1689
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1692
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
                    if la_ == 1:
                        self.state = 1690
                        self.match(XplorMRParser.Colon)
                        self.state = 1691
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                self.state = 1696
                self.match(XplorMRParser.Hydrogen)
                pass

            elif la_ == 10:
                self.state = 1697
                self.match(XplorMRParser.Id)
                self.state = 1698
                self.match(XplorMRParser.Integer)
                pass

            elif la_ == 11:
                self.state = 1699
                self.match(XplorMRParser.Known)
                pass

            elif la_ == 12:
                self.state = 1700
                self.match(XplorMRParser.Name)
                self.state = 1707
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1701
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1702
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1705
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
                    if la_ == 1:
                        self.state = 1703
                        self.match(XplorMRParser.Colon)
                        self.state = 1704
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 13:
                self.state = 1709
                self.match(XplorMRParser.Not_op)
                self.state = 1710
                self.factor(19)
                pass

            elif la_ == 14:
                self.state = 1711
                self.match(XplorMRParser.Point)
                self.state = 1712
                self.match(XplorMRParser.L_paren)
                self.state = 1713
                self.number_f()
                self.state = 1715
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1714
                    self.match(XplorMRParser.Comma)


                self.state = 1717
                self.number_f()
                self.state = 1719
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1718
                    self.match(XplorMRParser.Comma)


                self.state = 1721
                self.number_f()
                self.state = 1722
                self.match(XplorMRParser.R_paren)
                self.state = 1723
                self.match(XplorMRParser.Cut)
                self.state = 1724
                self.number_f()
                pass

            elif la_ == 15:
                self.state = 1726
                self.match(XplorMRParser.Point)
                self.state = 1727
                self.match(XplorMRParser.L_paren)
                self.state = 1728
                self.match(XplorMRParser.Tail)
                self.state = 1730
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1729
                    self.match(XplorMRParser.Equ_op)


                self.state = 1732
                self.selection()
                self.state = 1734
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1733
                    self.match(XplorMRParser.Comma)


                self.state = 1741
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Head:
                    self.state = 1736
                    self.match(XplorMRParser.Head)
                    self.state = 1738
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==XplorMRParser.Equ_op:
                        self.state = 1737
                        self.match(XplorMRParser.Equ_op)


                    self.state = 1740
                    self.selection()


                self.state = 1743
                self.match(XplorMRParser.R_paren)
                self.state = 1744
                self.match(XplorMRParser.Cut)
                self.state = 1745
                self.number_f()
                pass

            elif la_ == 16:
                self.state = 1747
                self.match(XplorMRParser.Previous)
                pass

            elif la_ == 17:
                self.state = 1748
                self.match(XplorMRParser.Pseudo)
                pass

            elif la_ == 18:
                self.state = 1749
                self.match(XplorMRParser.Residue)
                self.state = 1756
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Integers]:
                    self.state = 1750
                    self.match(XplorMRParser.Integers)
                    pass
                elif token in [XplorMRParser.Integer]:
                    self.state = 1751
                    self.match(XplorMRParser.Integer)
                    self.state = 1754
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
                    if la_ == 1:
                        self.state = 1752
                        self.match(XplorMRParser.Colon)
                        self.state = 1753
                        self.match(XplorMRParser.Integer)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 19:
                self.state = 1758
                self.match(XplorMRParser.Resname)
                self.state = 1765
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1759
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1760
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1763
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
                    if la_ == 1:
                        self.state = 1761
                        self.match(XplorMRParser.Colon)
                        self.state = 1762
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 20:
                self.state = 1767
                self.match(XplorMRParser.SegIdentifier)
                self.state = 1779
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1768
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1769
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1772
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                    if la_ == 1:
                        self.state = 1770
                        self.match(XplorMRParser.Colon)
                        self.state = 1771
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Double_quote_string]:
                    self.state = 1774
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 1777
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
                    if la_ == 1:
                        self.state = 1775
                        self.match(XplorMRParser.Colon)
                        self.state = 1776
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 21:
                self.state = 1781
                self.match(XplorMRParser.Store_1)
                pass

            elif la_ == 22:
                self.state = 1782
                self.match(XplorMRParser.Store_2)
                pass

            elif la_ == 23:
                self.state = 1783
                self.match(XplorMRParser.Store_3)
                pass

            elif la_ == 24:
                self.state = 1784
                self.match(XplorMRParser.Store_4)
                pass

            elif la_ == 25:
                self.state = 1785
                self.match(XplorMRParser.Store_5)
                pass

            elif la_ == 26:
                self.state = 1786
                self.match(XplorMRParser.Store_6)
                pass

            elif la_ == 27:
                self.state = 1787
                self.match(XplorMRParser.Store_7)
                pass

            elif la_ == 28:
                self.state = 1788
                self.match(XplorMRParser.Store_8)
                pass

            elif la_ == 29:
                self.state = 1789
                self.match(XplorMRParser.Store_9)
                pass

            elif la_ == 30:
                self.state = 1790
                self.match(XplorMRParser.Tag)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1801
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,146,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1799
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                    if la_ == 1:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1793
                        if not self.precpred(self._ctx, 30):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 30)")
                        self.state = 1794
                        self.match(XplorMRParser.Around)
                        self.state = 1795
                        self.number_f()
                        pass

                    elif la_ == 2:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1796
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1797
                        self.match(XplorMRParser.Saround)
                        self.state = 1798
                        self.number_f()
                        pass

             
                self.state = 1803
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,146,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class NumberContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber" ):
                listener.enterNumber(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber" ):
                listener.exitNumber(self)




    def number(self):

        localctx = XplorMRParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1804
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_fContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_f

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber_f" ):
                listener.enterNumber_f(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber_f" ):
                listener.exitNumber_f(self)




    def number_f(self):

        localctx = XplorMRParser.Number_fContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_number_f)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1806
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_sContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Real(self):
            return self.getToken(XplorMRParser.Real, 0)

        def Integer(self):
            return self.getToken(XplorMRParser.Integer, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_number_s

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber_s" ):
                listener.enterNumber_s(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber_s" ):
                listener.exitNumber_s(self)




    def number_s(self):

        localctx = XplorMRParser.Number_sContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_number_s)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1808
            _la = self._input.LA(1)
            if not(_la==XplorMRParser.Integer or _la==XplorMRParser.Real):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Flag_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def Flags(self):
            return self.getToken(XplorMRParser.Flags, 0)

        def Include(self):
            return self.getToken(XplorMRParser.Include, 0)

        def End_flag(self):
            return self.getToken(XplorMRParser.End_flag, 0)

        def Exclude(self):
            return self.getToken(XplorMRParser.Exclude, 0)

        def Class_name(self, i:int=None):
            if i is None:
                return self.getTokens(XplorMRParser.Class_name)
            else:
                return self.getToken(XplorMRParser.Class_name, i)

        def Any_class(self):
            return self.getToken(XplorMRParser.Any_class, 0)

        def getRuleIndex(self):
            return XplorMRParser.RULE_flag_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFlag_statement" ):
                listener.enterFlag_statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFlag_statement" ):
                listener.exitFlag_statement(self)




    def flag_statement(self):

        localctx = XplorMRParser.Flag_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_flag_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1810
            self.match(XplorMRParser.Flags)
            self.state = 1821
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Exclude:
                self.state = 1811
                self.match(XplorMRParser.Exclude)
                self.state = 1819
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Include, XplorMRParser.Class_name]:
                    self.state = 1815
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==XplorMRParser.Class_name:
                        self.state = 1812
                        self.match(XplorMRParser.Class_name)
                        self.state = 1817
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [XplorMRParser.Any_class]:
                    self.state = 1818
                    self.match(XplorMRParser.Any_class)
                    pass
                else:
                    raise NoViableAltException(self)



            self.state = 1823
            self.match(XplorMRParser.Include)
            self.state = 1827
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Class_name:
                self.state = 1824
                self.match(XplorMRParser.Class_name)
                self.state = 1829
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1830
            self.match(XplorMRParser.End_flag)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[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)
         




