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


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


class XplorMRParser ( Parser ):

    grammarFileName = "XplorMRParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

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

    symbolicNames = [ "<INVALID>", "Set", "End", "Noe", "Assign", "Asymptote", 
                      "Averaging", "Bhig", "Ceiling", "Classification", 
                      "CountViol", "Distribute", "Monomers", "Ncount", "Nrestraints", 
                      "Potential", "Predict", "Print", "Threshold", "Reset", 
                      "Rswitch", "Scale", "SoExponent", "SqConstant", "SqExponent", 
                      "SqOffset", "Temperature", "Noe_avr_methods", "Noe_potential", 
                      "Cutoff", "Cuton", "From", "To", "Restraints", "Dihedral", 
                      "Nassign", "Sanisotropy", "Coefficients", "ForceConstant", 
                      "Rdc_potential", "Xdipolar", "Dipolar", "Type", "Sign", 
                      "Average", "Rdc_dist_fix_types", "Rdc_avr_methods", 
                      "VectorAngle", "Cv", "Partition", "Tensor", "Anisotropy", 
                      "Rdc_anis_types", "Planar", "Group", "Initialize", 
                      "Selection", "Weight", "Xadc", "Expectation", "Size", 
                      "Zero", "Coupling", "DegEnergy", "Coupling_potential", 
                      "Carbon", "PhiStep", "PsiStep", "Rcoil", "Proton", 
                      "Observed", "Amides", "Carbons", "Nitrogens", "Oxygens", 
                      "RingAtoms", "AlphasAndAmides", "Error", "Rmsd_or_Not", 
                      "Ramachandran", "Gaussian", "Phase", "Quartic", "Shape", 
                      "Sort", "Gauss_or_Quart", "Dimensions", "Collapse", 
                      "Danisotropy", "Diff_anis_types", "Orient", "Height", 
                      "MaxGaussians", "NewGaussian", "Dcsa", "Sigma", "Csa_types", 
                      "Pcsa", "OneBond", "AngleDb", "DerivFlag", "Angle_dihedral", 
                      "Paramagnetic", "Kconst", "Omega", "Tauc", "Debug", 
                      "Xpcs", "Tolerance", "Save", "Fmed", "ErrOn", "ErrOff", 
                      "Fon", "Foff", "Son", "Soff", "Frun", "Xrdcoupling", 
                      "Xangle", "Xccr", "Weip", "Hbda", "All", "Around", 
                      "Atom", "Attribute", "BondedTo", "ByGroup", "ByRes", 
                      "Chemical", "Hydrogen", "Id", "Known", "Name", "Point", 
                      "Cut", "Previous", "Pseudo", "Residue", "Resname", 
                      "Saround", "SegIdentifier", "Store_1", "Store_2", 
                      "Store_3", "Store_4", "Store_5", "Store_6", "Store_7", 
                      "Store_8", "Store_9", "Tag", "Tail", "Head", "Or_op", 
                      "And_op", "Not_op", "Comma", "Complex", "Integer", 
                      "Logical", "Real", "Double_quote_string", "Simple_name", 
                      "Simple_names", "Integers", "L_paren", "R_paren", 
                      "Colon", "Equ_op", "Lt_op", "Gt_op", "Leq_op", "Geq_op", 
                      "Neq_op", "SPACE", "COMMENT", "LINE_COMMENT", "SET_VARIABLE", 
                      "Abs", "Attr_properties", "Comparison_ops", "SPACE_ATTR" ]

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

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

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

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




    class Xplor_nih_mrContext(ParserRuleContext):

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

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

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return XplorMRParser.RULE_xplor_nih_mr

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

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




    def xplor_nih_mr(self):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

            self.state = 275
            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 = 277
            self.match(XplorMRParser.Noe)
            self.state = 281
            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 = 278
                self.noe_statement()
                self.state = 283
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 284
            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 = 286
            self.match(XplorMRParser.Restraints)
            self.state = 287
            self.match(XplorMRParser.Dihedral)
            self.state = 291
            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 = 288
                self.dihedral_statement()
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 294
            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 = 336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Sanisotropy]:
                self.enterOuterAlt(localctx, 1)
                self.state = 296
                self.match(XplorMRParser.Sanisotropy)
                self.state = 300
                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 = 297
                    self.sani_statement()
                    self.state = 302
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 303
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Xdipolar, XplorMRParser.Dipolar]:
                self.enterOuterAlt(localctx, 2)
                self.state = 304
                _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 = 308
                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 = 305
                    self.xdip_statement()
                    self.state = 310
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 311
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.VectorAngle]:
                self.enterOuterAlt(localctx, 3)
                self.state = 312
                self.match(XplorMRParser.VectorAngle)
                self.state = 316
                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 = 313
                    self.vean_statement()
                    self.state = 318
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 319
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Tensor]:
                self.enterOuterAlt(localctx, 4)
                self.state = 320
                self.match(XplorMRParser.Tensor)
                self.state = 324
                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 = 321
                    self.tenso_statement()
                    self.state = 326
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

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

                self.state = 335
                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 = 338
            self.match(XplorMRParser.Restraints)
            self.state = 339
            self.match(XplorMRParser.Planar)
            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Group or _la==XplorMRParser.Initialize:
                self.state = 340
                self.planar_statement()
                self.state = 345
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 346
            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 = 348
            self.match(XplorMRParser.Xadc)
            self.state = 352
            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 = 349
                self.antidistance_statement()
                self.state = 354
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 355
            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 = 357
            self.match(XplorMRParser.Coupling)
            self.state = 361
            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 = 358
                self.coupling_statement()
                self.state = 363
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Carbon_shift_restraintContext(ParserRuleContext):

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

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

        def carbon_shift_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Carbon_shift_statementContext,0)


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_restraint

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

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




    def carbon_shift_restraint(self):

        localctx = XplorMRParser.Carbon_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_carbon_shift_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self.match(XplorMRParser.Carbon)
            self.state = 367
            self.carbon_shift_statement()
            self.state = 368
            self.match(XplorMRParser.End)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Proton_shift_restraintContext(ParserRuleContext):

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

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

        def proton_shift_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Proton_shift_statementContext,0)


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_proton_shift_restraint

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

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




    def proton_shift_restraint(self):

        localctx = XplorMRParser.Proton_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_proton_shift_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 370
            self.match(XplorMRParser.Proton)
            self.state = 371
            self.proton_shift_statement()
            self.state = 372
            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 = 374
            self.match(XplorMRParser.Ramachandran)
            self.state = 378
            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 = 375
                self.ramachandran_statement()
                self.state = 380
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 381
            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 = 383
            self.match(XplorMRParser.Collapse)
            self.state = 387
            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 = 384
                self.collapse_statement()
                self.state = 389
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 390
            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 = 392
            self.match(XplorMRParser.Danisotropy)
            self.state = 396
            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 = 393
                self.diffusion_statement()
                self.state = 398
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 399
            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 = 401
            self.match(XplorMRParser.Orient)
            self.state = 405
            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 = 402
                self.orientation_statement()
                self.state = 407
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 408
            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 = 410
            self.match(XplorMRParser.Dcsa)
            self.state = 414
            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 = 411
                self.csa_statement()
                self.state = 416
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 417
            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 = 419
            self.match(XplorMRParser.Pcsa)
            self.state = 423
            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 = 420
                self.pcsa_statement()
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 426
            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 = 428
            self.match(XplorMRParser.OneBond)
            self.state = 432
            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 = 429
                self.one_bond_coupling_statement()
                self.state = 434
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 435
            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 = 437
            self.match(XplorMRParser.AngleDb)
            self.state = 441
            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 = 438
                self.angle_db_statement()
                self.state = 443
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 444
            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 = 446
            self.match(XplorMRParser.Paramagnetic)
            self.state = 450
            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 = 447
                self.pre_statement()
                self.state = 452
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 453
            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 = 455
            self.match(XplorMRParser.Xpcs)
            self.state = 459
            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 = 456
                self.pcs_statement()
                self.state = 461
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 462
            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 = 464
            self.match(XplorMRParser.Xrdcoupling)
            self.state = 468
            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 = 465
                self.prdc_statement()
                self.state = 470
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 471
            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 = 473
            self.match(XplorMRParser.Xangle)
            self.state = 477
            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 = 474
                self.porientation_statement()
                self.state = 479
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 480
            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 = 482
            self.match(XplorMRParser.Xccr)
            self.state = 486
            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 = 483
                self.pccr_statement()
                self.state = 488
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 489
            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 = 491
            self.match(XplorMRParser.Hbda)
            self.state = 495
            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 = 492
                self.hbond_statement()
                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 498
            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 = 571
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 500
                self.noe_assign()
                pass
            elif token in [XplorMRParser.Asymptote]:
                self.enterOuterAlt(localctx, 2)
                self.state = 501
                self.match(XplorMRParser.Asymptote)
                self.state = 502
                self.match(XplorMRParser.Simple_name)
                self.state = 503
                self.number_s()
                pass
            elif token in [XplorMRParser.Averaging]:
                self.enterOuterAlt(localctx, 3)
                self.state = 504
                self.match(XplorMRParser.Averaging)
                self.state = 505
                self.match(XplorMRParser.Simple_name)
                self.state = 506
                self.match(XplorMRParser.Noe_avr_methods)
                pass
            elif token in [XplorMRParser.Bhig]:
                self.enterOuterAlt(localctx, 4)
                self.state = 507
                self.match(XplorMRParser.Bhig)
                self.state = 508
                self.match(XplorMRParser.Simple_name)
                self.state = 509
                self.number_s()
                pass
            elif token in [XplorMRParser.Ceiling]:
                self.enterOuterAlt(localctx, 5)
                self.state = 510
                self.match(XplorMRParser.Ceiling)
                self.state = 512
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 511
                    self.match(XplorMRParser.Equ_op)


                self.state = 514
                self.number_s()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 6)
                self.state = 515
                self.match(XplorMRParser.Classification)
                self.state = 516
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.CountViol]:
                self.enterOuterAlt(localctx, 7)
                self.state = 517
                self.match(XplorMRParser.CountViol)
                self.state = 518
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Distribute]:
                self.enterOuterAlt(localctx, 8)
                self.state = 519
                self.match(XplorMRParser.Distribute)
                self.state = 520
                self.match(XplorMRParser.Simple_name)
                self.state = 521
                self.match(XplorMRParser.Simple_name)
                self.state = 522
                self.number_s()
                pass
            elif token in [XplorMRParser.Monomers]:
                self.enterOuterAlt(localctx, 9)
                self.state = 523
                self.match(XplorMRParser.Monomers)
                self.state = 524
                self.match(XplorMRParser.Simple_name)
                self.state = 525
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Ncount]:
                self.enterOuterAlt(localctx, 10)
                self.state = 526
                self.match(XplorMRParser.Ncount)
                self.state = 527
                self.match(XplorMRParser.Simple_name)
                self.state = 528
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 11)
                self.state = 529
                self.match(XplorMRParser.Nrestraints)
                self.state = 531
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 530
                    self.match(XplorMRParser.Equ_op)


                self.state = 533
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 12)
                self.state = 534
                self.match(XplorMRParser.Potential)
                self.state = 535
                self.match(XplorMRParser.Simple_name)
                self.state = 536
                self.match(XplorMRParser.Noe_potential)
                pass
            elif token in [XplorMRParser.Predict]:
                self.enterOuterAlt(localctx, 13)
                self.state = 537
                self.match(XplorMRParser.Predict)
                self.state = 538
                self.predict_statement()
                self.state = 539
                self.match(XplorMRParser.End)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 14)
                self.state = 541
                self.match(XplorMRParser.Print)
                self.state = 542
                self.match(XplorMRParser.Threshold)
                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.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 15)
                self.state = 547
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Rswitch]:
                self.enterOuterAlt(localctx, 16)
                self.state = 548
                self.match(XplorMRParser.Rswitch)
                self.state = 549
                self.match(XplorMRParser.Simple_name)
                self.state = 550
                self.number_s()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 17)
                self.state = 551
                self.match(XplorMRParser.Scale)
                self.state = 552
                self.match(XplorMRParser.Simple_name)
                self.state = 553
                self.number_s()
                pass
            elif token in [XplorMRParser.SoExponent]:
                self.enterOuterAlt(localctx, 18)
                self.state = 554
                self.match(XplorMRParser.SoExponent)
                self.state = 555
                self.match(XplorMRParser.Simple_name)
                self.state = 556
                self.number_s()
                pass
            elif token in [XplorMRParser.SqConstant]:
                self.enterOuterAlt(localctx, 19)
                self.state = 557
                self.match(XplorMRParser.SqConstant)
                self.state = 558
                self.match(XplorMRParser.Simple_name)
                self.state = 559
                self.number_s()
                pass
            elif token in [XplorMRParser.SqExponent]:
                self.enterOuterAlt(localctx, 20)
                self.state = 560
                self.match(XplorMRParser.SqExponent)
                self.state = 561
                self.match(XplorMRParser.Simple_name)
                self.state = 562
                self.number_s()
                pass
            elif token in [XplorMRParser.SqOffset]:
                self.enterOuterAlt(localctx, 21)
                self.state = 563
                self.match(XplorMRParser.SqOffset)
                self.state = 564
                self.match(XplorMRParser.Simple_name)
                self.state = 565
                self.number_s()
                pass
            elif token in [XplorMRParser.Temperature]:
                self.enterOuterAlt(localctx, 22)
                self.state = 566
                self.match(XplorMRParser.Temperature)
                self.state = 568
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 567
                    self.match(XplorMRParser.Equ_op)


                self.state = 570
                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 = 573
            self.match(XplorMRParser.Assign)
            self.state = 574
            self.selection()
            self.state = 575
            self.selection()
            self.state = 576
            self.number()
            self.state = 577
            self.number()
            self.state = 578
            self.number()
            self.state = 585
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 579
                self.match(XplorMRParser.Or_op)
                self.state = 580
                self.selection()
                self.state = 581
                self.selection()
                self.state = 587
                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 = 602
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 1)
                self.state = 588
                self.match(XplorMRParser.Cutoff)
                self.state = 590
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 589
                    self.match(XplorMRParser.Equ_op)


                self.state = 592
                self.number_s()
                pass
            elif token in [XplorMRParser.Cuton]:
                self.enterOuterAlt(localctx, 2)
                self.state = 593
                self.match(XplorMRParser.Cuton)
                self.state = 595
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 594
                    self.match(XplorMRParser.Equ_op)


                self.state = 597
                self.number_s()
                pass
            elif token in [XplorMRParser.From]:
                self.enterOuterAlt(localctx, 3)
                self.state = 598
                self.match(XplorMRParser.From)
                self.state = 599
                self.selection()
                pass
            elif token in [XplorMRParser.To]:
                self.enterOuterAlt(localctx, 4)
                self.state = 600
                self.match(XplorMRParser.To)
                self.state = 601
                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 = 613
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 604
                self.dihedral_assign()
                pass
            elif token in [XplorMRParser.Nassign]:
                self.enterOuterAlt(localctx, 2)
                self.state = 605
                self.match(XplorMRParser.Nassign)
                self.state = 607
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 606
                    self.match(XplorMRParser.Equ_op)


                self.state = 609
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 3)
                self.state = 610
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 611
                self.match(XplorMRParser.Scale)
                self.state = 612
                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 = 615
            self.match(XplorMRParser.Assign)
            self.state = 616
            self.selection()
            self.state = 617
            self.selection()
            self.state = 618
            self.selection()
            self.state = 619
            self.selection()
            self.state = 620
            self.number()
            self.state = 621
            self.number()
            self.state = 622
            self.number()
            self.state = 623
            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 = 643
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 625
                self.sani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 626
                self.match(XplorMRParser.Classification)
                self.state = 627
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 628
                self.match(XplorMRParser.Coefficients)
                self.state = 629
                self.number_s()
                self.state = 630
                self.number_s()
                self.state = 631
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 633
                self.match(XplorMRParser.ForceConstant)
                self.state = 634
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 635
                self.match(XplorMRParser.Nrestraints)
                self.state = 636
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 637
                self.match(XplorMRParser.Potential)
                self.state = 638
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 639
                self.match(XplorMRParser.Print)
                self.state = 640
                self.match(XplorMRParser.Threshold)
                self.state = 641
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 642
                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 = 645
            self.match(XplorMRParser.Assign)
            self.state = 646
            self.selection()
            self.state = 647
            self.selection()
            self.state = 648
            self.selection()
            self.state = 649
            self.selection()
            self.state = 650
            self.selection()
            self.state = 651
            self.selection()
            self.state = 652
            self.number()
            self.state = 653
            self.number()
            self.state = 655
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 654
                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 = 683
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 657
                self.xdip_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 658
                self.match(XplorMRParser.Classification)
                self.state = 659
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 3)
                self.state = 660
                self.match(XplorMRParser.Type)
                self.state = 661
                self.match(XplorMRParser.Rdc_dist_fix_types)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 4)
                self.state = 662
                self.match(XplorMRParser.Scale)
                self.state = 663
                self.number_s()
                pass
            elif token in [XplorMRParser.Sign]:
                self.enterOuterAlt(localctx, 5)
                self.state = 664
                self.match(XplorMRParser.Sign)
                self.state = 665
                self.match(XplorMRParser.Logical)
                pass
            elif token in [XplorMRParser.Average]:
                self.enterOuterAlt(localctx, 6)
                self.state = 666
                self.match(XplorMRParser.Average)
                self.state = 667
                self.match(XplorMRParser.Rdc_avr_methods)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 7)
                self.state = 668
                self.match(XplorMRParser.Coefficients)
                self.state = 669
                self.number_s()
                self.state = 670
                self.number_s()
                self.state = 671
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 8)
                self.state = 673
                self.match(XplorMRParser.ForceConstant)
                self.state = 674
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 675
                self.match(XplorMRParser.Nrestraints)
                self.state = 676
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 10)
                self.state = 677
                self.match(XplorMRParser.Potential)
                self.state = 678
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 11)
                self.state = 679
                self.match(XplorMRParser.Print)
                self.state = 680
                self.match(XplorMRParser.Threshold)
                self.state = 681
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 682
                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 = 685
            self.match(XplorMRParser.Assign)
            self.state = 686
            self.selection()
            self.state = 687
            self.selection()
            self.state = 688
            self.selection()
            self.state = 689
            self.selection()
            self.state = 690
            self.selection()
            self.state = 691
            self.selection()
            self.state = 692
            self.number()
            self.state = 693
            self.number()
            self.state = 700
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 694
                self.number()

            elif la_ == 2:
                self.state = 695
                self.number()
                self.state = 696
                self.number()
                self.state = 697
                self.number()
                self.state = 698
                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 = 725
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 702
                self.vean_assign()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 2)
                self.state = 703
                self.match(XplorMRParser.Cv)
                self.state = 705
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 704
                    self.match(XplorMRParser.Equ_op)


                self.state = 707
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 3)
                self.state = 708
                self.match(XplorMRParser.Classification)
                self.state = 709
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 710
                self.match(XplorMRParser.ForceConstant)
                self.state = 711
                self.number_s()
                self.state = 712
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 714
                self.match(XplorMRParser.Nrestraints)
                self.state = 715
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 6)
                self.state = 716
                self.match(XplorMRParser.Partition)
                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.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 721
                self.match(XplorMRParser.Print)
                self.state = 722
                self.match(XplorMRParser.Threshold)
                self.state = 723
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 724
                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 = 727
            self.match(XplorMRParser.Assign)
            self.state = 728
            self.selection()
            self.state = 729
            self.selection()
            self.state = 730
            self.selection()
            self.state = 731
            self.selection()
            self.state = 732
            self.number()
            self.state = 733
            self.number()
            self.state = 734
            self.number()
            self.state = 735
            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 = 750
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 737
                self.tenso_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 738
                self.match(XplorMRParser.Classification)
                self.state = 739
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 740
                self.match(XplorMRParser.Coefficients)
                self.state = 741
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 742
                self.match(XplorMRParser.Nrestraints)
                self.state = 743
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 744
                self.match(XplorMRParser.Potential)
                self.state = 745
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 746
                self.match(XplorMRParser.Print)
                self.state = 747
                self.match(XplorMRParser.Threshold)
                self.state = 748
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 749
                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 = 752
            self.match(XplorMRParser.Assign)
            self.state = 753
            self.selection()
            self.state = 754
            self.selection()
            self.state = 755
            self.number()
            self.state = 756
            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 = 779
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 758
                self.anis_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 759
                self.match(XplorMRParser.Classification)
                self.state = 760
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 761
                self.match(XplorMRParser.Coefficients)
                self.state = 762
                self.number_s()
                self.state = 763
                self.number_s()
                self.state = 764
                self.number_s()
                self.state = 765
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 767
                self.match(XplorMRParser.ForceConstant)
                self.state = 768
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 769
                self.match(XplorMRParser.Nrestraints)
                self.state = 770
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 771
                self.match(XplorMRParser.Potential)
                self.state = 772
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 773
                self.match(XplorMRParser.Print)
                self.state = 774
                self.match(XplorMRParser.Threshold)
                self.state = 775
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 776
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 777
                self.match(XplorMRParser.Type)
                self.state = 778
                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 = 781
            self.match(XplorMRParser.Assign)
            self.state = 782
            self.selection()
            self.state = 783
            self.selection()
            self.state = 784
            self.selection()
            self.state = 785
            self.selection()
            self.state = 786
            self.number()
            self.state = 787
            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 group_statement(self):
            return self.getTypedRuleContext(XplorMRParser.Group_statementContext,0)


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

        def getRuleIndex(self):
            return XplorMRParser.RULE_planar_statement

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

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




    def planar_statement(self):

        localctx = XplorMRParser.Planar_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_planar_statement)
        try:
            self.state = 792
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Group]:
                self.enterOuterAlt(localctx, 1)
                self.state = 789
                self.match(XplorMRParser.Group)
                self.state = 790
                self.group_statement()
                pass
            elif token in [XplorMRParser.Initialize]:
                self.enterOuterAlt(localctx, 2)
                self.state = 791
                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 = 804
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Selection]:
                self.enterOuterAlt(localctx, 1)
                self.state = 794
                self.match(XplorMRParser.Selection)
                self.state = 796
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 795
                    self.match(XplorMRParser.Equ_op)


                self.state = 798
                self.selection()
                pass
            elif token in [XplorMRParser.Weight]:
                self.enterOuterAlt(localctx, 2)
                self.state = 799
                self.match(XplorMRParser.Weight)
                self.state = 801
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 800
                    self.match(XplorMRParser.Equ_op)


                self.state = 803
                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 = 830
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 806
                self.xadc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 807
                self.match(XplorMRParser.Classification)
                self.state = 808
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 809
                self.match(XplorMRParser.Expectation)
                self.state = 810
                self.match(XplorMRParser.Integer)
                self.state = 811
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 812
                self.match(XplorMRParser.ForceConstant)
                self.state = 813
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 814
                self.match(XplorMRParser.Nrestraints)
                self.state = 815
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 6)
                self.state = 816
                self.match(XplorMRParser.Print)
                self.state = 817
                self.match(XplorMRParser.Threshold)
                self.state = 818
                self.number_s()
                self.state = 822
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 819
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 820
                    self.match(XplorMRParser.Classification)
                    self.state = 821
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 7)
                self.state = 824
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 8)
                self.state = 825
                self.match(XplorMRParser.Size)
                self.state = 826
                self.number_s()
                self.state = 827
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 9)
                self.state = 829
                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 = 832
            self.match(XplorMRParser.Assign)
            self.state = 833
            self.selection()
            self.state = 834
            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 = 875
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 836
                self.coup_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 837
                self.match(XplorMRParser.Classification)
                self.state = 838
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 839
                self.match(XplorMRParser.Coefficients)
                self.state = 840
                self.number_s()
                self.state = 841
                self.number_s()
                self.state = 842
                self.number_s()
                self.state = 843
                self.number_s()
                pass
            elif token in [XplorMRParser.Cv]:
                self.enterOuterAlt(localctx, 4)
                self.state = 845
                self.match(XplorMRParser.Cv)
                self.state = 847
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 846
                    self.match(XplorMRParser.Equ_op)


                self.state = 849
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.DegEnergy]:
                self.enterOuterAlt(localctx, 5)
                self.state = 850
                self.match(XplorMRParser.DegEnergy)
                self.state = 851
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 852
                self.match(XplorMRParser.ForceConstant)
                self.state = 853
                self.number_s()
                self.state = 855
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 854
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 857
                self.match(XplorMRParser.Nrestraints)
                self.state = 858
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Partition]:
                self.enterOuterAlt(localctx, 8)
                self.state = 859
                self.match(XplorMRParser.Partition)
                self.state = 861
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 860
                    self.match(XplorMRParser.Equ_op)


                self.state = 863
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 864
                self.match(XplorMRParser.Potential)
                self.state = 865
                self.match(XplorMRParser.Coupling_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 866
                self.match(XplorMRParser.Print)
                self.state = 867
                self.match(XplorMRParser.Threshold)
                self.state = 868
                self.number_s()
                self.state = 872
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 869
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 870
                    self.match(XplorMRParser.Classification)
                    self.state = 871
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 874
                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 = 877
            self.match(XplorMRParser.Assign)
            self.state = 878
            self.selection()
            self.state = 879
            self.selection()
            self.state = 880
            self.selection()
            self.state = 881
            self.selection()
            self.state = 887
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 882
                self.selection()
                self.state = 883
                self.selection()
                self.state = 884
                self.selection()
                self.state = 885
                self.selection()


            self.state = 889
            self.number()
            self.state = 890
            self.number()
            self.state = 894
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 891
                self.number()
                self.state = 892
                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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.Carbon_shift_rcoilContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.Carbon_shift_rcoilContext,i)


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

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

        def getRuleIndex(self):
            return XplorMRParser.RULE_carbon_shift_statement

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

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




    def carbon_shift_statement(self):

        localctx = XplorMRParser.Carbon_shift_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_carbon_shift_statement)
        self._la = 0 # Token type
        try:
            self.state = 927
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 896
                self.carbon_shift_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 897
                self.match(XplorMRParser.Classification)
                self.state = 898
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 3)
                self.state = 899
                self.match(XplorMRParser.Expectation)
                self.state = 900
                self.match(XplorMRParser.Integer)
                self.state = 901
                self.match(XplorMRParser.Integer)
                self.state = 902
                self.number_s()
                self.state = 903
                self.number_s()
                self.state = 904
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 906
                self.match(XplorMRParser.ForceConstant)
                self.state = 907
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 908
                self.match(XplorMRParser.Nrestraints)
                self.state = 909
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.PhiStep]:
                self.enterOuterAlt(localctx, 6)
                self.state = 910
                self.match(XplorMRParser.PhiStep)
                self.state = 911
                self.number_s()
                pass
            elif token in [XplorMRParser.PsiStep]:
                self.enterOuterAlt(localctx, 7)
                self.state = 912
                self.match(XplorMRParser.PsiStep)
                self.state = 913
                self.number_s()
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 914
                self.match(XplorMRParser.Potential)
                self.state = 915
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 916
                self.match(XplorMRParser.Print)
                self.state = 917
                self.match(XplorMRParser.Threshold)
                self.state = 918
                self.number_s()
                pass
            elif token in [XplorMRParser.End, XplorMRParser.Rcoil]:
                self.enterOuterAlt(localctx, 10)
                self.state = 922
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Rcoil:
                    self.state = 919
                    self.carbon_shift_rcoil()
                    self.state = 924
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 925
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 926
                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 = 929
            self.match(XplorMRParser.Assign)
            self.state = 930
            self.selection()
            self.state = 931
            self.selection()
            self.state = 932
            self.selection()
            self.state = 933
            self.selection()
            self.state = 934
            self.selection()
            self.state = 935
            self.number()
            self.state = 936
            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 = 938
            self.match(XplorMRParser.Rcoil)
            self.state = 939
            self.selection()
            self.state = 940
            self.number_s()
            self.state = 941
            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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(XplorMRParser.ObservedContext)
            else:
                return self.getTypedRuleContext(XplorMRParser.ObservedContext,i)


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


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


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


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


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


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


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


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


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

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

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

        def 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 = 1021
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 946
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Observed:
                    self.state = 943
                    self.observed()
                    self.state = 948
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Rcoil:
                    self.state = 949
                    self.proton_shift_rcoil()
                    self.state = 954
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 958
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Anisotropy:
                    self.state = 955
                    self.proton_shift_anisotropy()
                    self.state = 960
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 964
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Amides:
                    self.state = 961
                    self.proton_shift_amides()
                    self.state = 966
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 970
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Carbons:
                    self.state = 967
                    self.proton_shift_carbons()
                    self.state = 972
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 976
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Nitrogens:
                    self.state = 973
                    self.proton_shift_nitrogens()
                    self.state = 978
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 982
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.Oxygens:
                    self.state = 979
                    self.proton_shift_oxygens()
                    self.state = 984
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 988
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.RingAtoms:
                    self.state = 985
                    self.proton_shift_ring_atoms()
                    self.state = 990
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 994
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==XplorMRParser.AlphasAndAmides:
                    self.state = 991
                    self.proton_shift_alphas_and_amides()
                    self.state = 996
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

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

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 999
                self.match(XplorMRParser.Error)
                self.state = 1000
                self.number_s()
                pass

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

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1003
                self.match(XplorMRParser.ForceConstant)
                self.state = 1004
                self.number_s()
                self.state = 1006
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1005
                    self.number_s()


                pass

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

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1010
                self.match(XplorMRParser.Print)
                self.state = 1011
                self.match(XplorMRParser.Threshold)
                self.state = 1012
                self.number_s()
                self.state = 1016
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1013
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1014
                    self.match(XplorMRParser.Classification)
                    self.state = 1015
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

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

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


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


    class ObservedContext(ParserRuleContext):

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

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

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


        def 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 = 1023
            self.match(XplorMRParser.Observed)
            self.state = 1024
            self.selection()
            self.state = 1026
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1025
                self.selection()


            self.state = 1028
            self.number_s()
            self.state = 1030
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                self.state = 1029
                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 = 1032
            self.match(XplorMRParser.Rcoil)
            self.state = 1033
            self.selection()
            self.state = 1034
            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 = 1036
            self.match(XplorMRParser.Anisotropy)
            self.state = 1037
            self.selection()
            self.state = 1038
            self.selection()
            self.state = 1039
            self.selection()
            self.state = 1040
            self.match(XplorMRParser.Simple_name)
            self.state = 1042
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.Logical:
                self.state = 1041
                self.match(XplorMRParser.Logical)


            self.state = 1044
            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 = 1046
            self.match(XplorMRParser.Amides)
            self.state = 1047
            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 = 1049
            self.match(XplorMRParser.Carbons)
            self.state = 1050
            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 = 1052
            self.match(XplorMRParser.Nitrogens)
            self.state = 1053
            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 = 1055
            self.match(XplorMRParser.Oxygens)
            self.state = 1056
            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 = 1058
            self.match(XplorMRParser.RingAtoms)
            self.state = 1059
            self.match(XplorMRParser.Simple_name)
            self.state = 1060
            self.selection()
            self.state = 1061
            self.selection()
            self.state = 1062
            self.selection()
            self.state = 1063
            self.selection()
            self.state = 1064
            self.selection()
            self.state = 1066
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1065
                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 = 1068
            self.match(XplorMRParser.AlphasAndAmides)
            self.state = 1069
            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 = 1173
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1071
                self.rama_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1072
                self.match(XplorMRParser.Classification)
                self.state = 1073
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1074
                self.match(XplorMRParser.Cutoff)
                self.state = 1075
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1076
                self.match(XplorMRParser.ForceConstant)
                self.state = 1077
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1078
                self.match(XplorMRParser.Gaussian)
                self.state = 1079
                self.number_s()
                self.state = 1080
                self.number_s()
                self.state = 1081
                self.number_s()
                self.state = 1086
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,89,self._ctx)
                if la_ == 1:
                    self.state = 1082
                    self.number_s()
                    self.state = 1083
                    self.number_s()
                    self.state = 1084
                    self.number_s()


                self.state = 1092
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
                if la_ == 1:
                    self.state = 1088
                    self.number_s()
                    self.state = 1089
                    self.number_s()
                    self.state = 1090
                    self.number_s()


                self.state = 1098
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Integer or _la==XplorMRParser.Real:
                    self.state = 1094
                    self.number_s()
                    self.state = 1095
                    self.number_s()
                    self.state = 1096
                    self.number_s()


                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1100
                self.match(XplorMRParser.Nrestraints)
                self.state = 1101
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Phase]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1102
                self.match(XplorMRParser.Phase)
                self.state = 1103
                self.number_s()
                self.state = 1104
                self.number_s()
                self.state = 1105
                self.number_s()
                self.state = 1110
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
                if la_ == 1:
                    self.state = 1106
                    self.number_s()
                    self.state = 1107
                    self.number_s()
                    self.state = 1108
                    self.number_s()


                self.state = 1116
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
                if la_ == 1:
                    self.state = 1112
                    self.number_s()
                    self.state = 1113
                    self.number_s()
                    self.state = 1114
                    self.number_s()


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


                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1124
                self.match(XplorMRParser.Print)
                self.state = 1125
                self.match(XplorMRParser.Threshold)
                self.state = 1126
                self.number_s()
                self.state = 1130
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1127
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1128
                    self.match(XplorMRParser.Classification)
                    self.state = 1129
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1132
                self.match(XplorMRParser.Quartic)
                self.state = 1133
                self.number_s()
                self.state = 1134
                self.number_s()
                self.state = 1135
                self.number_s()
                self.state = 1140
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
                if la_ == 1:
                    self.state = 1136
                    self.number_s()
                    self.state = 1137
                    self.number_s()
                    self.state = 1138
                    self.number_s()


                self.state = 1146
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
                if la_ == 1:
                    self.state = 1142
                    self.number_s()
                    self.state = 1143
                    self.number_s()
                    self.state = 1144
                    self.number_s()


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


                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1154
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1155
                self.match(XplorMRParser.Scale)
                self.state = 1156
                self.number_s()
                pass
            elif token in [XplorMRParser.Shape]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1157
                self.match(XplorMRParser.Shape)
                self.state = 1158
                self.match(XplorMRParser.Gauss_or_Quart)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1159
                self.match(XplorMRParser.Size)
                self.state = 1160
                self.match(XplorMRParser.Dimensions)
                self.state = 1161
                self.number_s()
                self.state = 1163
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
                if la_ == 1:
                    self.state = 1162
                    self.number_s()


                self.state = 1166
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
                if la_ == 1:
                    self.state = 1165
                    self.number_s()


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


                pass
            elif token in [XplorMRParser.Sort]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1171
                self.match(XplorMRParser.Sort)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1172
                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 = 1175
            self.match(XplorMRParser.Assign)
            self.state = 1176
            self.selection()
            self.state = 1177
            self.selection()
            self.state = 1178
            self.selection()
            self.state = 1179
            self.selection()
            self.state = 1185
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
            if la_ == 1:
                self.state = 1180
                self.selection()
                self.state = 1181
                self.selection()
                self.state = 1182
                self.selection()
                self.state = 1183
                self.selection()


            self.state = 1192
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                self.state = 1187
                self.selection()
                self.state = 1188
                self.selection()
                self.state = 1189
                self.selection()
                self.state = 1190
                self.selection()


            self.state = 1199
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1194
                self.selection()
                self.state = 1195
                self.selection()
                self.state = 1196
                self.selection()
                self.state = 1197
                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 = 1206
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1201
                self.coll_assign()
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1202
                self.match(XplorMRParser.Scale)
                self.state = 1203
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1204
                self.match(XplorMRParser.Print)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1205
                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 = 1208
            self.match(XplorMRParser.Assign)
            self.state = 1209
            self.selection()
            self.state = 1210
            self.number()
            self.state = 1211
            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 = 1235
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1213
                self.dani_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1214
                self.match(XplorMRParser.Classification)
                self.state = 1215
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1216
                self.match(XplorMRParser.Coefficients)
                self.state = 1217
                self.number_s()
                self.state = 1218
                self.number_s()
                self.state = 1219
                self.number_s()
                self.state = 1220
                self.number_s()
                self.state = 1221
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1223
                self.match(XplorMRParser.ForceConstant)
                self.state = 1224
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1225
                self.match(XplorMRParser.Nrestraints)
                self.state = 1226
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1227
                self.match(XplorMRParser.Potential)
                self.state = 1228
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1229
                self.match(XplorMRParser.Print)
                self.state = 1230
                self.match(XplorMRParser.Threshold)
                self.state = 1231
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1232
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1233
                self.match(XplorMRParser.Type)
                self.state = 1234
                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 = 1237
            self.match(XplorMRParser.Assign)
            self.state = 1238
            self.selection()
            self.state = 1239
            self.selection()
            self.state = 1240
            self.selection()
            self.state = 1241
            self.selection()
            self.state = 1242
            self.selection()
            self.state = 1243
            self.selection()
            self.state = 1244
            self.number()
            self.state = 1245
            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 = 1304
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1247
                self.orie_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1248
                self.match(XplorMRParser.Classification)
                self.state = 1249
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Cutoff]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1250
                self.match(XplorMRParser.Cutoff)
                self.state = 1251
                self.number_s()
                pass
            elif token in [XplorMRParser.Height]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1252
                self.match(XplorMRParser.Height)
                self.state = 1253
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1254
                self.match(XplorMRParser.ForceConstant)
                self.state = 1255
                self.number_s()
                pass
            elif token in [XplorMRParser.Gaussian]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1256
                self.match(XplorMRParser.Gaussian)
                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.MaxGaussians]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1265
                self.match(XplorMRParser.MaxGaussians)
                self.state = 1266
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.NewGaussian]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1267
                self.match(XplorMRParser.NewGaussian)
                self.state = 1268
                self.number_s()
                self.state = 1269
                self.number_s()
                self.state = 1270
                self.number_s()
                self.state = 1271
                self.number_s()
                self.state = 1272
                self.number_s()
                self.state = 1273
                self.number_s()
                self.state = 1274
                self.number_s()
                self.state = 1275
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1277
                self.match(XplorMRParser.Nrestraints)
                self.state = 1278
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1279
                self.match(XplorMRParser.Print)
                self.state = 1280
                self.match(XplorMRParser.Threshold)
                self.state = 1281
                self.number_s()
                self.state = 1285
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1282
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1283
                    self.match(XplorMRParser.Classification)
                    self.state = 1284
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Quartic]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1287
                self.match(XplorMRParser.Quartic)
                self.state = 1288
                self.number_s()
                self.state = 1289
                self.number_s()
                self.state = 1290
                self.number_s()
                self.state = 1291
                self.number_s()
                self.state = 1292
                self.number_s()
                self.state = 1293
                self.number_s()
                self.state = 1294
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1296
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Residue]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1297
                self.match(XplorMRParser.Residue)
                self.state = 1298
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1299
                self.match(XplorMRParser.Size)
                self.state = 1300
                self.number_s()
                self.state = 1301
                self.number_s()
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1303
                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 = 1306
            self.match(XplorMRParser.Assign)
            self.state = 1307
            self.selection()
            self.state = 1308
            self.selection()
            self.state = 1309
            self.selection()
            self.state = 1310
            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 = 1339
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1312
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1313
                self.match(XplorMRParser.Classification)
                self.state = 1314
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1315
                self.match(XplorMRParser.Scale)
                self.state = 1316
                self.number_s()
                pass
            elif token in [XplorMRParser.Type]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1317
                self.match(XplorMRParser.Type)
                self.state = 1318
                self.match(XplorMRParser.Csa_types)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1319
                self.match(XplorMRParser.Coefficients)
                self.state = 1320
                self.number_s()
                self.state = 1321
                self.number_s()
                self.state = 1322
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1324
                self.match(XplorMRParser.Sigma)
                self.state = 1325
                self.number_s()
                self.state = 1326
                self.number_s()
                self.state = 1327
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1329
                self.match(XplorMRParser.ForceConstant)
                self.state = 1330
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1331
                self.match(XplorMRParser.Nrestraints)
                self.state = 1332
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1333
                self.match(XplorMRParser.Potential)
                self.state = 1334
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1335
                self.match(XplorMRParser.Print)
                self.state = 1336
                self.match(XplorMRParser.Threshold)
                self.state = 1337
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1338
                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 = 1341
            self.match(XplorMRParser.Assign)
            self.state = 1342
            self.selection()
            self.state = 1343
            self.selection()
            self.state = 1344
            self.selection()
            self.state = 1345
            self.selection()
            self.state = 1346
            self.selection()
            self.state = 1347
            self.selection()
            self.state = 1348
            self.selection()
            self.state = 1349
            self.number()
            self.state = 1350
            self.number()
            self.state = 1351
            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 = 1379
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1353
                self.csa_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1354
                self.match(XplorMRParser.Classification)
                self.state = 1355
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Scale]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1356
                self.match(XplorMRParser.Scale)
                self.state = 1357
                self.number_s()
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1358
                self.match(XplorMRParser.Coefficients)
                self.state = 1359
                self.number_s()
                self.state = 1360
                self.number_s()
                self.state = 1361
                self.number_s()
                pass
            elif token in [XplorMRParser.Sigma]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1363
                self.match(XplorMRParser.Sigma)
                self.state = 1364
                self.number_s()
                self.state = 1365
                self.number_s()
                self.state = 1366
                self.number_s()
                self.state = 1367
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1369
                self.match(XplorMRParser.ForceConstant)
                self.state = 1370
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1371
                self.match(XplorMRParser.Nrestraints)
                self.state = 1372
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1373
                self.match(XplorMRParser.Potential)
                self.state = 1374
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1375
                self.match(XplorMRParser.Print)
                self.state = 1376
                self.match(XplorMRParser.Threshold)
                self.state = 1377
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1378
                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 = 1403
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1381
                self.one_bond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1382
                self.match(XplorMRParser.Classification)
                self.state = 1383
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1384
                self.match(XplorMRParser.Coefficients)
                self.state = 1385
                self.number_s()
                self.state = 1386
                self.number_s()
                self.state = 1387
                self.number_s()
                self.state = 1388
                self.number_s()
                self.state = 1389
                self.number_s()
                self.state = 1390
                self.number_s()
                self.state = 1391
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1393
                self.match(XplorMRParser.ForceConstant)
                self.state = 1394
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1395
                self.match(XplorMRParser.Nrestraints)
                self.state = 1396
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1397
                self.match(XplorMRParser.Potential)
                self.state = 1398
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1399
                self.match(XplorMRParser.Print)
                self.state = 1400
                self.match(XplorMRParser.Threshold)
                self.state = 1401
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1402
                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 = 1405
            self.match(XplorMRParser.Assign)
            self.state = 1406
            self.selection()
            self.state = 1407
            self.selection()
            self.state = 1408
            self.selection()
            self.state = 1409
            self.selection()
            self.state = 1410
            self.selection()
            self.state = 1411
            self.selection()
            self.state = 1412
            self.selection()
            self.state = 1413
            self.selection()
            self.state = 1414
            self.number()
            self.state = 1415
            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 = 1448
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1417
                self.angle_db_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1418
                self.match(XplorMRParser.Classification)
                self.state = 1419
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.DerivFlag]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1420
                self.match(XplorMRParser.DerivFlag)
                self.state = 1421
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Expectation]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1422
                self.match(XplorMRParser.Expectation)
                self.state = 1423
                self.match(XplorMRParser.Integer)
                self.state = 1424
                self.match(XplorMRParser.Integer)
                self.state = 1425
                self.number_s()
                pass
            elif token in [XplorMRParser.Error]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1426
                self.match(XplorMRParser.Error)
                self.state = 1427
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1428
                self.match(XplorMRParser.ForceConstant)
                self.state = 1429
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1430
                self.match(XplorMRParser.Nrestraints)
                self.state = 1431
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1432
                self.match(XplorMRParser.Potential)
                self.state = 1433
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1434
                self.match(XplorMRParser.Print)
                self.state = 1435
                self.match(XplorMRParser.Threshold)
                self.state = 1436
                self.number_s()
                self.state = 1440
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1437
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1438
                    self.match(XplorMRParser.Classification)
                    self.state = 1439
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1442
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Size]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1443
                self.match(XplorMRParser.Size)
                self.state = 1444
                self.match(XplorMRParser.Angle_dihedral)
                self.state = 1445
                self.match(XplorMRParser.Integer)
                self.state = 1446
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Zero]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1447
                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 = 1450
            self.match(XplorMRParser.Assign)
            self.state = 1451
            self.selection()
            self.state = 1452
            self.selection()
            self.state = 1453
            self.selection()
            self.state = 1454
            self.selection()
            self.state = 1455
            self.selection()
            self.state = 1456
            self.selection()
            self.state = 1457
            self.selection()
            self.state = 1458
            self.selection()
            self.state = 1459
            self.selection()
            self.state = 1460
            self.selection()
            self.state = 1461
            self.selection()
            self.state = 1463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==XplorMRParser.L_paren:
                self.state = 1462
                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 = 1518
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1465
                self.pre_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1466
                self.match(XplorMRParser.Classification)
                self.state = 1468
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1467
                    self.match(XplorMRParser.Equ_op)


                self.state = 1470
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1471
                self.match(XplorMRParser.ForceConstant)
                self.state = 1473
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1472
                    self.match(XplorMRParser.Equ_op)


                self.state = 1475
                self.match(XplorMRParser.Simple_name)
                self.state = 1476
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1477
                self.match(XplorMRParser.Nrestraints)
                self.state = 1479
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1478
                    self.match(XplorMRParser.Equ_op)


                self.state = 1481
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Potential]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1482
                self.match(XplorMRParser.Potential)
                self.state = 1484
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1483
                    self.match(XplorMRParser.Equ_op)


                self.state = 1486
                self.match(XplorMRParser.Simple_name)
                self.state = 1487
                self.match(XplorMRParser.Rdc_potential)
                pass
            elif token in [XplorMRParser.Kconst]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1488
                self.match(XplorMRParser.Kconst)
                self.state = 1490
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1489
                    self.match(XplorMRParser.Equ_op)


                self.state = 1492
                self.match(XplorMRParser.Simple_name)
                self.state = 1493
                self.number_s()
                pass
            elif token in [XplorMRParser.Omega]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1494
                self.match(XplorMRParser.Omega)
                self.state = 1496
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1495
                    self.match(XplorMRParser.Equ_op)


                self.state = 1498
                self.match(XplorMRParser.Simple_name)
                self.state = 1499
                self.number_s()
                pass
            elif token in [XplorMRParser.Tauc]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1500
                self.match(XplorMRParser.Tauc)
                self.state = 1502
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1501
                    self.match(XplorMRParser.Equ_op)


                self.state = 1504
                self.match(XplorMRParser.Simple_name)
                self.state = 1505
                self.number_s()
                self.state = 1506
                self.number_s()
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 9)
                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, 10)
                self.state = 1516
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Debug]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1517
                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 = 1520
            self.match(XplorMRParser.Assign)
            self.state = 1521
            self.selection()
            self.state = 1522
            self.selection()
            self.state = 1523
            self.number()
            self.state = 1524
            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 = 1562
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1526
                self.pcs_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1527
                self.match(XplorMRParser.Classification)
                self.state = 1528
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1529
                self.match(XplorMRParser.Tolerance)
                self.state = 1530
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1531
                self.match(XplorMRParser.Coefficients)
                self.state = 1532
                self.number_s()
                self.state = 1533
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1535
                self.match(XplorMRParser.ForceConstant)
                self.state = 1536
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1537
                self.match(XplorMRParser.Nrestraints)
                self.state = 1538
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1539
                self.match(XplorMRParser.Print)
                self.state = 1540
                self.match(XplorMRParser.Threshold)
                self.state = 1541
                self.number_s()
                self.state = 1545
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.All]:
                    self.state = 1542
                    self.match(XplorMRParser.All)
                    pass
                elif token in [XplorMRParser.Classification]:
                    self.state = 1543
                    self.match(XplorMRParser.Classification)
                    self.state = 1544
                    self.match(XplorMRParser.Simple_name)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1547
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1548
                self.match(XplorMRParser.Save)
                self.state = 1549
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1550
                self.match(XplorMRParser.Fmed)
                self.state = 1551
                self.number_s()
                self.state = 1552
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1554
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1555
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1556
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1557
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1558
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1559
                self.match(XplorMRParser.Soff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1560
                self.match(XplorMRParser.Frun)
                self.state = 1561
                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 = 1564
            self.match(XplorMRParser.Assign)
            self.state = 1565
            self.selection()
            self.state = 1566
            self.selection()
            self.state = 1567
            self.selection()
            self.state = 1568
            self.selection()
            self.state = 1569
            self.selection()
            self.state = 1570
            self.number()
            self.state = 1571
            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 = 1599
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1573
                self.prdc_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1574
                self.match(XplorMRParser.Classification)
                self.state = 1575
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Tolerance]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1576
                self.match(XplorMRParser.Tolerance)
                self.state = 1577
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1578
                self.match(XplorMRParser.Coefficients)
                self.state = 1579
                self.number_s()
                self.state = 1580
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1582
                self.match(XplorMRParser.ForceConstant)
                self.state = 1583
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1584
                self.match(XplorMRParser.Nrestraints)
                self.state = 1585
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.ErrOn]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1586
                self.match(XplorMRParser.ErrOn)
                pass
            elif token in [XplorMRParser.ErrOff]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1587
                self.match(XplorMRParser.ErrOff)
                pass
            elif token in [XplorMRParser.Fmed]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1588
                self.match(XplorMRParser.Fmed)
                pass
            elif token in [XplorMRParser.Fon]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1589
                self.match(XplorMRParser.Fon)
                pass
            elif token in [XplorMRParser.Foff]:
                self.enterOuterAlt(localctx, 11)
                self.state = 1590
                self.match(XplorMRParser.Foff)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 12)
                self.state = 1591
                self.match(XplorMRParser.Frun)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 13)
                self.state = 1592
                self.match(XplorMRParser.Print)
                self.state = 1593
                self.match(XplorMRParser.Threshold)
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 14)
                self.state = 1594
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Save]:
                self.enterOuterAlt(localctx, 15)
                self.state = 1595
                self.match(XplorMRParser.Save)
                self.state = 1596
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Son]:
                self.enterOuterAlt(localctx, 16)
                self.state = 1597
                self.match(XplorMRParser.Son)
                pass
            elif token in [XplorMRParser.Soff]:
                self.enterOuterAlt(localctx, 17)
                self.state = 1598
                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 = 1601
            self.match(XplorMRParser.Assign)
            self.state = 1602
            self.selection()
            self.state = 1603
            self.selection()
            self.state = 1604
            self.selection()
            self.state = 1605
            self.selection()
            self.state = 1606
            self.selection()
            self.state = 1607
            self.selection()
            self.state = 1608
            self.number()
            self.state = 1609
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class 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 = 1622
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1611
                self.porientation_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1612
                self.match(XplorMRParser.Classification)
                self.state = 1613
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1614
                self.match(XplorMRParser.ForceConstant)
                self.state = 1615
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1616
                self.match(XplorMRParser.Nrestraints)
                self.state = 1617
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1618
                self.match(XplorMRParser.Print)
                self.state = 1619
                self.match(XplorMRParser.Threshold)
                self.state = 1620
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1621
                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 = 1624
            self.match(XplorMRParser.Assign)
            self.state = 1625
            self.selection()
            self.state = 1626
            self.selection()
            self.state = 1627
            self.number()
            self.state = 1628
            self.number()
            self.state = 1629
            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 = 1648
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1631
                self.pccr_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1632
                self.match(XplorMRParser.Classification)
                self.state = 1633
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.Weip]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1634
                self.match(XplorMRParser.Weip)
                self.state = 1635
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Coefficients]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1636
                self.match(XplorMRParser.Coefficients)
                self.state = 1637
                self.number_s()
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1638
                self.match(XplorMRParser.ForceConstant)
                self.state = 1639
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1640
                self.match(XplorMRParser.Nrestraints)
                self.state = 1641
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1642
                self.match(XplorMRParser.Print)
                self.state = 1643
                self.match(XplorMRParser.Threshold)
                self.state = 1644
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1645
                self.match(XplorMRParser.Reset)
                pass
            elif token in [XplorMRParser.Frun]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1646
                self.match(XplorMRParser.Frun)
                self.state = 1647
                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 = 1650
            self.match(XplorMRParser.Assign)
            self.state = 1651
            self.selection()
            self.state = 1652
            self.selection()
            self.state = 1653
            self.selection()
            self.state = 1654
            self.number()
            self.state = 1655
            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 = 1668
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [XplorMRParser.Assign]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1657
                self.hbond_assign()
                pass
            elif token in [XplorMRParser.Classification]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1658
                self.match(XplorMRParser.Classification)
                self.state = 1659
                self.match(XplorMRParser.Simple_name)
                pass
            elif token in [XplorMRParser.ForceConstant]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1660
                self.match(XplorMRParser.ForceConstant)
                self.state = 1661
                self.number_s()
                pass
            elif token in [XplorMRParser.Nrestraints]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1662
                self.match(XplorMRParser.Nrestraints)
                self.state = 1663
                self.match(XplorMRParser.Integer)
                pass
            elif token in [XplorMRParser.Print]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1664
                self.match(XplorMRParser.Print)
                self.state = 1665
                self.match(XplorMRParser.Threshold)
                self.state = 1666
                self.number_s()
                pass
            elif token in [XplorMRParser.Reset]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1667
                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 = 1670
            self.match(XplorMRParser.Assign)
            self.state = 1671
            self.selection()
            self.state = 1672
            self.selection()
            self.state = 1673
            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 = 1675
            self.match(XplorMRParser.L_paren)
            self.state = 1676
            self.selection_expression()
            self.state = 1677
            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 = 1679
            self.term()
            self.state = 1684
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.Or_op:
                self.state = 1680
                self.match(XplorMRParser.Or_op)
                self.state = 1681
                self.term()
                self.state = 1686
                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 = 1687
            self.factor(0)
            self.state = 1692
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==XplorMRParser.And_op:
                self.state = 1688
                self.match(XplorMRParser.And_op)
                self.state = 1689
                self.factor(0)
                self.state = 1694
                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 = 1822
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,151,self._ctx)
            if la_ == 1:
                self.state = 1696
                self.match(XplorMRParser.L_paren)
                self.state = 1697
                self.selection_expression()
                self.state = 1698
                self.match(XplorMRParser.R_paren)
                pass

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

            elif la_ == 3:
                self.state = 1701
                self.match(XplorMRParser.Atom)
                self.state = 1702
                _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 = 1703
                _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 = 1704
                _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 = 1705
                self.match(XplorMRParser.Attribute)
                self.state = 1707
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Abs:
                    self.state = 1706
                    self.match(XplorMRParser.Abs)


                self.state = 1709
                self.match(XplorMRParser.Attr_properties)
                self.state = 1710
                self.match(XplorMRParser.Comparison_ops)
                self.state = 1711
                self.number_f()
                pass

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

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

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

            elif la_ == 8:
                self.state = 1718
                self.match(XplorMRParser.Chemical)
                self.state = 1725
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1719
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1720
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1723
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,134,self._ctx)
                    if la_ == 1:
                        self.state = 1721
                        self.match(XplorMRParser.Colon)
                        self.state = 1722
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

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

            elif la_ == 10:
                self.state = 1728
                self.match(XplorMRParser.Id)
                self.state = 1729
                self.match(XplorMRParser.Integer)
                pass

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

            elif la_ == 12:
                self.state = 1731
                self.match(XplorMRParser.Name)
                self.state = 1738
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1732
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1733
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1736
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                    if la_ == 1:
                        self.state = 1734
                        self.match(XplorMRParser.Colon)
                        self.state = 1735
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

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

            elif la_ == 14:
                self.state = 1742
                self.match(XplorMRParser.Point)
                self.state = 1743
                self.match(XplorMRParser.L_paren)
                self.state = 1744
                self.number_f()
                self.state = 1746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1745
                    self.match(XplorMRParser.Comma)


                self.state = 1748
                self.number_f()
                self.state = 1750
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1749
                    self.match(XplorMRParser.Comma)


                self.state = 1752
                self.number_f()
                self.state = 1753
                self.match(XplorMRParser.R_paren)
                self.state = 1754
                self.match(XplorMRParser.Cut)
                self.state = 1755
                self.number_f()
                pass

            elif la_ == 15:
                self.state = 1757
                self.match(XplorMRParser.Point)
                self.state = 1758
                self.match(XplorMRParser.L_paren)
                self.state = 1759
                self.match(XplorMRParser.Tail)
                self.state = 1761
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Equ_op:
                    self.state = 1760
                    self.match(XplorMRParser.Equ_op)


                self.state = 1763
                self.selection()
                self.state = 1765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Comma:
                    self.state = 1764
                    self.match(XplorMRParser.Comma)


                self.state = 1772
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==XplorMRParser.Head:
                    self.state = 1767
                    self.match(XplorMRParser.Head)
                    self.state = 1769
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==XplorMRParser.Equ_op:
                        self.state = 1768
                        self.match(XplorMRParser.Equ_op)


                    self.state = 1771
                    self.selection()


                self.state = 1774
                self.match(XplorMRParser.R_paren)
                self.state = 1775
                self.match(XplorMRParser.Cut)
                self.state = 1776
                self.number_f()
                pass

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

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

            elif la_ == 18:
                self.state = 1780
                self.match(XplorMRParser.Residue)
                self.state = 1787
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Integers]:
                    self.state = 1781
                    self.match(XplorMRParser.Integers)
                    pass
                elif token in [XplorMRParser.Integer]:
                    self.state = 1782
                    self.match(XplorMRParser.Integer)
                    self.state = 1785
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
                    if la_ == 1:
                        self.state = 1783
                        self.match(XplorMRParser.Colon)
                        self.state = 1784
                        self.match(XplorMRParser.Integer)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 19:
                self.state = 1789
                self.match(XplorMRParser.Resname)
                self.state = 1796
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1790
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1791
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1794
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
                    if la_ == 1:
                        self.state = 1792
                        self.match(XplorMRParser.Colon)
                        self.state = 1793
                        self.match(XplorMRParser.Simple_name)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 20:
                self.state = 1798
                self.match(XplorMRParser.SegIdentifier)
                self.state = 1810
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [XplorMRParser.Simple_names]:
                    self.state = 1799
                    self.match(XplorMRParser.Simple_names)
                    pass
                elif token in [XplorMRParser.Simple_name]:
                    self.state = 1800
                    self.match(XplorMRParser.Simple_name)
                    self.state = 1803
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
                    if la_ == 1:
                        self.state = 1801
                        self.match(XplorMRParser.Colon)
                        self.state = 1802
                        self.match(XplorMRParser.Simple_name)


                    pass
                elif token in [XplorMRParser.Double_quote_string]:
                    self.state = 1805
                    self.match(XplorMRParser.Double_quote_string)
                    self.state = 1808
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,149,self._ctx)
                    if la_ == 1:
                        self.state = 1806
                        self.match(XplorMRParser.Colon)
                        self.state = 1807
                        self.match(XplorMRParser.Double_quote_string)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

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

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

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

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

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

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

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

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

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

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


            self._ctx.stop = self._input.LT(-1)
            self.state = 1832
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1830
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,152,self._ctx)
                    if la_ == 1:
                        localctx = XplorMRParser.FactorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_factor)
                        self.state = 1824
                        if not self.precpred(self._ctx, 30):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 30)")
                        self.state = 1825
                        self.match(XplorMRParser.Around)
                        self.state = 1826
                        self.number_f()
                        pass

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

             
                self.state = 1834
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.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 = 1835
            _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 = 1837
            _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 = 1839
            _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



    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)
         




