# Generated from AmberMRParser.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\u00cc")
        buf.write("\u03f6\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 \3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2H\n\2")
        buf.write("\f\2\16\2K\13\2\3\2\3\2\3\3\3\3\6\3Q\n\3\r\3\16\3R\3\3")
        buf.write("\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3")
        buf.write("\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\n\7\n")
        buf.write("p\n\n\f\n\16\ns\13\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\5\13\u0088\n\13\3\13\3\13\5\13\u008c\n\13\3\13\3")
        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u0096\n\13\3\13")
        buf.write("\3\13\3\13\3\13\5\13\u009c\n\13\3\13\3\13\3\13\3\13\5")
        buf.write("\13\u00a2\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13")
        buf.write("\u00b6\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00bf")
        buf.write("\n\13\3\f\7\f\u00c2\n\f\f\f\16\f\u00c5\13\f\3\r\3\r\3")
        buf.write("\r\3\r\3\r\3\r\3\r\5\r\u00ce\n\r\3\r\3\r\3\r\3\r\3\r\3")
        buf.write("\r\3\r\5\r\u00d7\n\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3")
        buf.write("\r\5\r\u00e2\n\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\5")
        buf.write("\r\u00ed\n\r\3\r\3\r\3\r\3\r\5\r\u00f3\n\r\3\r\3\r\3\r")
        buf.write("\3\r\5\r\u00f9\n\r\5\r\u00fb\n\r\3\16\7\16\u00fe\n\16")
        buf.write("\f\16\16\16\u0101\13\16\3\17\3\17\3\17\3\17\5\17\u0107")
        buf.write("\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u0110\n")
        buf.write("\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17")
        buf.write("\u011b\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u0124")
        buf.write("\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17")
        buf.write("\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u0138\n")
        buf.write("\17\5\17\u013a\n\17\3\20\7\20\u013d\n\20\f\20\16\20\u0140")
        buf.write("\13\20\3\21\3\21\3\21\3\21\5\21\u0146\n\21\3\21\3\21\3")
        buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0153")
        buf.write("\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u015c\n")
        buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
        buf.write("\3\21\5\21\u0169\n\21\5\21\u016b\n\21\3\22\7\22\u016e")
        buf.write("\n\22\f\22\16\22\u0171\13\22\3\23\3\23\3\23\3\23\5\23")
        buf.write("\u0177\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u0180")
        buf.write("\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u0189\n")
        buf.write("\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u0193")
        buf.write("\n\23\3\23\3\23\3\23\3\23\5\23\u0199\n\23\5\23\u019b\n")
        buf.write("\23\3\24\7\24\u019e\n\24\f\24\16\24\u01a1\13\24\3\25\3")
        buf.write("\25\3\25\3\25\5\25\u01a7\n\25\3\25\3\25\3\25\3\25\3\25")
        buf.write("\3\25\3\25\5\25\u01b0\n\25\3\25\3\25\3\25\3\25\3\25\3")
        buf.write("\25\3\25\5\25\u01b9\n\25\3\25\3\25\3\25\3\25\3\25\3\25")
        buf.write("\3\25\3\25\5\25\u01c3\n\25\5\25\u01c5\n\25\3\26\3\26\3")
        buf.write("\26\3\26\5\26\u01cb\n\26\3\26\3\26\3\26\3\26\3\26\3\26")
        buf.write("\3\26\5\26\u01d4\n\26\3\26\3\26\3\26\3\26\3\26\3\26\3")
        buf.write("\26\5\26\u01dd\n\26\3\26\3\26\3\26\5\26\u01e2\n\26\3\27")
        buf.write("\3\27\3\27\3\27\5\27\u01e8\n\27\3\27\3\27\5\27\u01ec\n")
        buf.write("\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u01f5\n\27")
        buf.write("\3\27\3\27\5\27\u01f9\n\27\3\27\3\27\3\27\3\27\3\27\3")
        buf.write("\27\3\27\5\27\u0202\n\27\3\27\3\27\5\27\u0206\n\27\3\27")
        buf.write("\3\27\3\27\5\27\u020b\n\27\3\30\3\30\3\30\3\30\5\30\u0211")
        buf.write("\n\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u021a\n")
        buf.write("\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0223\n\30")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u022c\n\30\3")
        buf.write("\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0235\n\30\3\30")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u023e\n\30\3\30\3")
        buf.write("\30\3\30\5\30\u0243\n\30\3\31\3\31\3\31\3\31\5\31\u0249")
        buf.write("\n\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0252\n")
        buf.write("\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u025b\n\31")
        buf.write("\3\31\3\31\3\31\5\31\u0260\n\31\3\32\3\32\3\32\3\32\5")
        buf.write("\32\u0266\n\32\3\32\3\32\5\32\u026a\n\32\3\32\3\32\5\32")
        buf.write("\u026e\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u0277")
        buf.write("\n\32\3\32\3\32\5\32\u027b\n\32\3\32\3\32\5\32\u027f\n")
        buf.write("\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u0288\n\32")
        buf.write("\3\32\3\32\5\32\u028c\n\32\3\32\3\32\5\32\u0290\n\32\3")
        buf.write("\32\3\32\3\32\5\32\u0295\n\32\3\33\3\33\3\33\3\33\5\33")
        buf.write("\u029b\n\33\3\33\3\33\5\33\u029f\n\33\3\33\3\33\5\33\u02a3")
        buf.write("\n\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u02ac\n")
        buf.write("\33\3\33\3\33\5\33\u02b0\n\33\3\33\3\33\5\33\u02b4\n\33")
        buf.write("\3\33\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u02bd\n\33\3")
        buf.write("\33\3\33\5\33\u02c1\n\33\3\33\3\33\5\33\u02c5\n\33\3\33")
        buf.write("\3\33\3\33\5\33\u02ca\n\33\3\34\3\34\3\34\3\34\5\34\u02d0")
        buf.write("\n\34\3\34\3\34\5\34\u02d4\n\34\3\34\3\34\5\34\u02d8\n")
        buf.write("\34\3\34\3\34\5\34\u02dc\n\34\3\34\3\34\5\34\u02e0\n\34")
        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u02e9\n\34\3")
        buf.write("\34\3\34\5\34\u02ed\n\34\3\34\3\34\5\34\u02f1\n\34\3\34")
        buf.write("\3\34\5\34\u02f5\n\34\3\34\3\34\5\34\u02f9\n\34\3\34\3")
        buf.write("\34\3\34\3\34\3\34\3\34\3\34\5\34\u0302\n\34\3\34\3\34")
        buf.write("\5\34\u0306\n\34\3\34\3\34\5\34\u030a\n\34\3\34\3\34\5")
        buf.write("\34\u030e\n\34\3\34\3\34\5\34\u0312\n\34\3\34\3\34\3\34")
        buf.write("\5\34\u0317\n\34\3\35\3\35\3\35\3\35\5\35\u031d\n\35\3")
        buf.write("\35\3\35\5\35\u0321\n\35\3\35\3\35\5\35\u0325\n\35\3\35")
        buf.write("\3\35\5\35\u0329\n\35\3\35\3\35\5\35\u032d\n\35\3\35\3")
        buf.write("\35\5\35\u0331\n\35\3\35\3\35\5\35\u0335\n\35\3\35\3\35")
        buf.write("\3\35\3\35\3\35\3\35\3\35\5\35\u033e\n\35\3\35\3\35\5")
        buf.write("\35\u0342\n\35\3\35\3\35\5\35\u0346\n\35\3\35\3\35\5\35")
        buf.write("\u034a\n\35\3\35\3\35\5\35\u034e\n\35\3\35\3\35\5\35\u0352")
        buf.write("\n\35\3\35\3\35\5\35\u0356\n\35\3\35\3\35\3\35\3\35\3")
        buf.write("\35\3\35\3\35\5\35\u035f\n\35\3\35\3\35\5\35\u0363\n\35")
        buf.write("\3\35\3\35\5\35\u0367\n\35\3\35\3\35\5\35\u036b\n\35\3")
        buf.write("\35\3\35\5\35\u036f\n\35\3\35\3\35\5\35\u0373\n\35\3\35")
        buf.write("\3\35\5\35\u0377\n\35\3\35\3\35\3\35\5\35\u037c\n\35\3")
        buf.write("\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36")
        buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36")
        buf.write("\u0393\n\36\3\37\3\37\3\37\3\37\5\37\u0399\n\37\3\37\3")
        buf.write("\37\5\37\u039d\n\37\3\37\3\37\5\37\u03a1\n\37\3\37\3\37")
        buf.write("\3\37\3\37\3\37\3\37\3\37\5\37\u03aa\n\37\3\37\3\37\5")
        buf.write("\37\u03ae\n\37\3\37\3\37\5\37\u03b2\n\37\3\37\3\37\3\37")
        buf.write("\3\37\3\37\3\37\3\37\5\37\u03bb\n\37\3\37\3\37\5\37\u03bf")
        buf.write("\n\37\3\37\3\37\5\37\u03c3\n\37\3\37\3\37\3\37\5\37\u03c8")
        buf.write("\n\37\3 \3 \3 \3 \5 \u03ce\n \3 \7 \u03d1\n \f \16 \u03d4")
        buf.write("\13 \3 \3 \3 \3 \3 \3 \5 \u03dc\n \3 \7 \u03df\n \f \16")
        buf.write(" \u03e2\13 \3 \3 \3 \3 \3 \3 \5 \u03ea\n \3 \7 \u03ed")
        buf.write("\n \f \16 \u03f0\13 \3 \3 \5 \u03f4\n \3 \2\2!\2\4\6\b")
        buf.write("\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668")
        buf.write(":<>\2\35\4\2\5\5\")\3\2\u00a4\u00a5\4\2\6\6!!\3\2\u00ab")
        buf.write("\u00ac\4\2\b\b,\63\7\2\t\t\f\r\20\20++\64\65\5\2\n\13")
        buf.write("\16\17\668\3\2\21 \3\2<=\3\2>@\4\2AEGG\5\2IIRRTU\4\2J")
        buf.write("JNN\4\2MMPQ\4\2RRWW\4\2NN``\4\2OOY]\4\2QQ__\4\2bbhi\3")
        buf.write("\2cd\3\2ef\4\2ggoo\4\2jnpq\4\2tt{{\3\2uw\3\2xy\3\2|\u0082")
        buf.write("\2\u04a1\2I\3\2\2\2\4N\3\2\2\2\6V\3\2\2\2\bZ\3\2\2\2\n")
        buf.write("^\3\2\2\2\fb\3\2\2\2\16f\3\2\2\2\20j\3\2\2\2\22q\3\2\2")
        buf.write("\2\24\u00be\3\2\2\2\26\u00c3\3\2\2\2\30\u00fa\3\2\2\2")
        buf.write("\32\u00ff\3\2\2\2\34\u0139\3\2\2\2\36\u013e\3\2\2\2 \u016a")
        buf.write("\3\2\2\2\"\u016f\3\2\2\2$\u019a\3\2\2\2&\u019f\3\2\2\2")
        buf.write("(\u01c4\3\2\2\2*\u01e1\3\2\2\2,\u020a\3\2\2\2.\u0242\3")
        buf.write("\2\2\2\60\u025f\3\2\2\2\62\u0294\3\2\2\2\64\u02c9\3\2")
        buf.write("\2\2\66\u0316\3\2\2\28\u037b\3\2\2\2:\u0392\3\2\2\2<\u03c7")
        buf.write("\3\2\2\2>\u03f3\3\2\2\2@H\5\4\3\2AH\5\6\4\2BH\5\b\5\2")
        buf.write("CH\5\n\6\2DH\5\f\7\2EH\5\16\b\2FH\5\20\t\2G@\3\2\2\2G")
        buf.write("A\3\2\2\2GB\3\2\2\2GC\3\2\2\2GD\3\2\2\2GE\3\2\2\2GF\3")
        buf.write("\2\2\2HK\3\2\2\2IG\3\2\2\2IJ\3\2\2\2JL\3\2\2\2KI\3\2\2")
        buf.write("\2LM\7\2\2\3M\3\3\2\2\2NP\7\u0085\2\2OQ\7\u0092\2\2PO")
        buf.write("\3\2\2\2QR\3\2\2\2RP\3\2\2\2RS\3\2\2\2ST\3\2\2\2TU\7\u0094")
        buf.write("\2\2U\5\3\2\2\2VW\7\4\2\2WX\5\22\n\2XY\7\3\2\2Y\7\3\2")
        buf.write("\2\2Z[\79\2\2[\\\5\26\f\2\\]\7\3\2\2]\t\3\2\2\2^_\7H\2")
        buf.write("\2_`\5\32\16\2`a\7\3\2\2a\13\3\2\2\2bc\7V\2\2cd\5\36\20")
        buf.write("\2de\7\3\2\2e\r\3\2\2\2fg\7a\2\2gh\5\"\22\2hi\7\3\2\2")
        buf.write("i\17\3\2\2\2jk\7s\2\2kl\5&\24\2lm\7\3\2\2m\21\3\2\2\2")
        buf.write("np\5\24\13\2on\3\2\2\2ps\3\2\2\2qo\3\2\2\2qr\3\2\2\2r")
        buf.write("\23\3\2\2\2sq\3\2\2\2tu\t\2\2\2uv\7\u00a1\2\2vw\t\3\2")
        buf.write("\2w\u00bf\7\u00a2\2\2xy\t\4\2\2yz\7\u00a8\2\2z{\t\5\2")
        buf.write("\2{\u00bf\7\u00a9\2\2|}\7\7\2\2}~\7\u008d\2\2~\u0087\7")
        buf.write("\u008e\2\2\177\u0088\5*\26\2\u0080\u0088\5,\27\2\u0081")
        buf.write("\u0088\5\62\32\2\u0082\u0088\5.\30\2\u0083\u0088\5\60")
        buf.write("\31\2\u0084\u0088\5\64\33\2\u0085\u0088\5\66\34\2\u0086")
        buf.write("\u0088\58\35\2\u0087\177\3\2\2\2\u0087\u0080\3\2\2\2\u0087")
        buf.write("\u0081\3\2\2\2\u0087\u0082\3\2\2\2\u0087\u0083\3\2\2\2")
        buf.write("\u0087\u0084\3\2\2\2\u0087\u0085\3\2\2\2\u0087\u0086\3")
        buf.write("\2\2\2\u0088\u0089\3\2\2\2\u0089\u008b\7\u00cb\2\2\u008a")
        buf.write("\u008c\7\u0083\2\2\u008b\u008a\3\2\2\2\u008b\u008c\3\2")
        buf.write("\2\2\u008c\u00bf\3\2\2\2\u008d\u008e\t\6\2\2\u008e\u008f")
        buf.write("\7\u00b3\2\2\u008f\u0090\7\u00b5\2\2\u0090\u00bf\7\u00b4")
        buf.write("\2\2\u0091\u0092\t\7\2\2\u0092\u0093\7\u009d\2\2\u0093")
        buf.write("\u0095\7\u009e\2\2\u0094\u0096\7\u0083\2\2\u0095\u0094")
        buf.write("\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u00bf\3\2\2\2\u0097")
        buf.write("\u0098\t\b\2\2\u0098\u0099\7\u0095\2\2\u0099\u009b\7\u0097")
        buf.write("\2\2\u009a\u009c\7\u0083\2\2\u009b\u009a\3\2\2\2\u009b")
        buf.write("\u009c\3\2\2\2\u009c\u00bf\3\2\2\2\u009d\u009e\t\t\2\2")
        buf.write("\u009e\u009f\7\u0099\2\2\u009f\u00a1\7\u009b\2\2\u00a0")
        buf.write("\u00a2\7\u0083\2\2\u00a1\u00a0\3\2\2\2\u00a1\u00a2\3\2")
        buf.write("\2\2\u00a2\u00bf\3\2\2\2\u00a3\u00a4\7*\2\2\u00a4\u00a5")
        buf.write("\7\u00ae\2\2\u00a5\u00a6\7\u00b0\2\2\u00a6\u00bf\7\u00af")
        buf.write("\2\2\u00a7\u00a8\t\2\2\2\u00a8\u00a9\7\u00a0\2\2\u00a9")
        buf.write("\u00aa\7\u00b9\2\2\u00aa\u00ab\7\u00b8\2\2\u00ab\u00ac")
        buf.write("\7\u00a1\2\2\u00ac\u00ad\t\3\2\2\u00ad\u00bf\7\u00a2\2")
        buf.write("\2\u00ae\u00af\7\6\2\2\u00af\u00b0\7\u009a\2\2\u00b0\u00b1")
        buf.write("\7\u00b9\2\2\u00b1\u00b2\7\u00b8\2\2\u00b2\u00b3\7\u0099")
        buf.write("\2\2\u00b3\u00b5\7\u009b\2\2\u00b4\u00b6\7\u0083\2\2\u00b5")
        buf.write("\u00b4\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00bf\3\2\2\2")
        buf.write("\u00b7\u00b8\t\6\2\2\u00b8\u00b9\7\u00b2\2\2\u00b9\u00ba")
        buf.write("\7\u00b9\2\2\u00ba\u00bb\7\u00b8\2\2\u00bb\u00bc\7\u00b3")
        buf.write("\2\2\u00bc\u00bd\7\u00b5\2\2\u00bd\u00bf\7\u00b4\2\2\u00be")
        buf.write("t\3\2\2\2\u00bex\3\2\2\2\u00be|\3\2\2\2\u00be\u008d\3")
        buf.write("\2\2\2\u00be\u0091\3\2\2\2\u00be\u0097\3\2\2\2\u00be\u009d")
        buf.write("\3\2\2\2\u00be\u00a3\3\2\2\2\u00be\u00a7\3\2\2\2\u00be")
        buf.write("\u00ae\3\2\2\2\u00be\u00b7\3\2\2\2\u00bf\25\3\2\2\2\u00c0")
        buf.write("\u00c2\5\30\r\2\u00c1\u00c0\3\2\2\2\u00c2\u00c5\3\2\2")
        buf.write("\2\u00c3\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\27\3")
        buf.write("\2\2\2\u00c5\u00c3\3\2\2\2\u00c6\u00c7\7:\2\2\u00c7\u00c8")
        buf.write("\7\u0096\2\2\u00c8\u00c9\7\u00b9\2\2\u00c9\u00ca\7\u00b8")
        buf.write("\2\2\u00ca\u00cb\7\u0095\2\2\u00cb\u00cd\7\u0097\2\2\u00cc")
        buf.write("\u00ce\7\u0083\2\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2")
        buf.write("\2\2\u00ce\u00fb\3\2\2\2\u00cf\u00d0\7;\2\2\u00d0\u00d1")
        buf.write("\7\u009a\2\2\u00d1\u00d2\7\u00b9\2\2\u00d2\u00d3\7\u00b8")
        buf.write("\2\2\u00d3\u00d4\7\u0099\2\2\u00d4\u00d6\7\u009b\2\2\u00d5")
        buf.write("\u00d7\7\u0083\2\2\u00d6\u00d5\3\2\2\2\u00d6\u00d7\3\2")
        buf.write("\2\2\u00d7\u00fb\3\2\2\2\u00d8\u00d9\t\n\2\2\u00d9\u00da")
        buf.write("\7\u0096\2\2\u00da\u00db\7\u00b9\2\2\u00db\u00dc\7\u00b7")
        buf.write("\2\2\u00dc\u00dd\7\u00b9\2\2\u00dd\u00de\7\u00b8\2\2\u00de")
        buf.write("\u00df\7\u0095\2\2\u00df\u00e1\7\u0097\2\2\u00e0\u00e2")
        buf.write("\7\u0083\2\2\u00e1\u00e0\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2")
        buf.write("\u00fb\3\2\2\2\u00e3\u00e4\t\13\2\2\u00e4\u00e5\7\u009a")
        buf.write("\2\2\u00e5\u00e6\7\u00b9\2\2\u00e6\u00e7\7\u00b7\2\2\u00e7")
        buf.write("\u00e8\7\u00b9\2\2\u00e8\u00e9\7\u00b8\2\2\u00e9\u00ea")
        buf.write("\7\u0099\2\2\u00ea\u00ec\7\u009b\2\2\u00eb\u00ed\7\u0083")
        buf.write("\2\2\u00ec\u00eb\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00fb")
        buf.write("\3\2\2\2\u00ee\u00ef\t\f\2\2\u00ef\u00f0\7\u0099\2\2\u00f0")
        buf.write("\u00f2\7\u009b\2\2\u00f1\u00f3\7\u0083\2\2\u00f2\u00f1")
        buf.write("\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00fb\3\2\2\2\u00f4")
        buf.write("\u00f5\7F\2\2\u00f5\u00f6\7\u009d\2\2\u00f6\u00f8\7\u009e")
        buf.write("\2\2\u00f7\u00f9\7\u0083\2\2\u00f8\u00f7\3\2\2\2\u00f8")
        buf.write("\u00f9\3\2\2\2\u00f9\u00fb\3\2\2\2\u00fa\u00c6\3\2\2\2")
        buf.write("\u00fa\u00cf\3\2\2\2\u00fa\u00d8\3\2\2\2\u00fa\u00e3\3")
        buf.write("\2\2\2\u00fa\u00ee\3\2\2\2\u00fa\u00f4\3\2\2\2\u00fb\31")
        buf.write("\3\2\2\2\u00fc\u00fe\5\34\17\2\u00fd\u00fc\3\2\2\2\u00fe")
        buf.write("\u0101\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2")
        buf.write("\u0100\33\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u0103\t\r")
        buf.write("\2\2\u0103\u0104\7\u0095\2\2\u0104\u0106\7\u0097\2\2\u0105")
        buf.write("\u0107\7\u0083\2\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2")
        buf.write("\2\2\u0107\u013a\3\2\2\2\u0108\u0109\t\16\2\2\u0109\u010a")
        buf.write("\7\u0096\2\2\u010a\u010b\7\u00b9\2\2\u010b\u010c\7\u00b8")
        buf.write("\2\2\u010c\u010d\7\u0095\2\2\u010d\u010f\7\u0097\2\2\u010e")
        buf.write("\u0110\7\u0083\2\2\u010f\u010e\3\2\2\2\u010f\u0110\3\2")
        buf.write("\2\2\u0110\u013a\3\2\2\2\u0111\u0112\7K\2\2\u0112\u0113")
        buf.write("\7\u0096\2\2\u0113\u0114\7\u00b9\2\2\u0114\u0115\7\u00b7")
        buf.write("\2\2\u0115\u0116\7\u00b9\2\2\u0116\u0117\7\u00b8\2\2\u0117")
        buf.write("\u0118\7\u0095\2\2\u0118\u011a\7\u0097\2\2\u0119\u011b")
        buf.write("\7\u0083\2\2\u011a\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b")
        buf.write("\u013a\3\2\2\2\u011c\u011d\7O\2\2\u011d\u011e\7\u009a")
        buf.write("\2\2\u011e\u011f\7\u00b9\2\2\u011f\u0120\7\u00b8\2\2\u0120")
        buf.write("\u0121\7\u0099\2\2\u0121\u0123\7\u009b\2\2\u0122\u0124")
        buf.write("\7\u0083\2\2\u0123\u0122\3\2\2\2\u0123\u0124\3\2\2\2\u0124")
        buf.write("\u013a\3\2\2\2\u0125\u0126\t\17\2\2\u0126\u0127\7\u00a7")
        buf.write("\2\2\u0127\u0128\7\u00b9\2\2\u0128\u0129\7\u00b8\2\2\u0129")
        buf.write("\u012a\7\u00a8\2\2\u012a\u012b\t\5\2\2\u012b\u013a\7\u00a9")
        buf.write("\2\2\u012c\u012d\7L\2\2\u012d\u012e\7\u00b2\2\2\u012e")
        buf.write("\u012f\7\u00b9\2\2\u012f\u0130\7\u00b8\2\2\u0130\u0131")
        buf.write("\7\u00b3\2\2\u0131\u0132\7\u00b5\2\2\u0132\u013a\7\u00b4")
        buf.write("\2\2\u0133\u0134\7S\2\2\u0134\u0135\7\u0099\2\2\u0135")
        buf.write("\u0137\7\u009b\2\2\u0136\u0138\7\u0083\2\2\u0137\u0136")
        buf.write("\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013a\3\2\2\2\u0139")
        buf.write("\u0102\3\2\2\2\u0139\u0108\3\2\2\2\u0139\u0111\3\2\2\2")
        buf.write("\u0139\u011c\3\2\2\2\u0139\u0125\3\2\2\2\u0139\u012c\3")
        buf.write("\2\2\2\u0139\u0133\3\2\2\2\u013a\35\3\2\2\2\u013b\u013d")
        buf.write("\5 \21\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\37\3\2\2\2\u0140")
        buf.write("\u013e\3\2\2\2\u0141\u0142\t\20\2\2\u0142\u0143\7\u0095")
        buf.write("\2\2\u0143\u0145\7\u0097\2\2\u0144\u0146\7\u0083\2\2\u0145")
        buf.write("\u0144\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u016b\3\2\2\2")
        buf.write("\u0147\u0148\7X\2\2\u0148\u0149\7\u00b3\2\2\u0149\u014a")
        buf.write("\7\u00b5\2\2\u014a\u016b\7\u00b4\2\2\u014b\u014c\t\21")
        buf.write("\2\2\u014c\u014d\7\u0096\2\2\u014d\u014e\7\u00b9\2\2\u014e")
        buf.write("\u014f\7\u00b8\2\2\u014f\u0150\7\u0095\2\2\u0150\u0152")
        buf.write("\7\u0097\2\2\u0151\u0153\7\u0083\2\2\u0152\u0151\3\2\2")
        buf.write("\2\u0152\u0153\3\2\2\2\u0153\u016b\3\2\2\2\u0154\u0155")
        buf.write("\t\22\2\2\u0155\u0156\7\u009a\2\2\u0156\u0157\7\u00b9")
        buf.write("\2\2\u0157\u0158\7\u00b8\2\2\u0158\u0159\7\u0099\2\2\u0159")
        buf.write("\u015b\7\u009b\2\2\u015a\u015c\7\u0083\2\2\u015b\u015a")
        buf.write("\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u016b\3\2\2\2\u015d")
        buf.write("\u015e\t\23\2\2\u015e\u015f\7\u00a7\2\2\u015f\u0160\7")
        buf.write("\u00b9\2\2\u0160\u0161\7\u00b8\2\2\u0161\u0162\7\u00a8")
        buf.write("\2\2\u0162\u0163\t\5\2\2\u0163\u016b\7\u00a9\2\2\u0164")
        buf.write("\u0165\7^\2\2\u0165\u0166\7\u0099\2\2\u0166\u0168\7\u009b")
        buf.write("\2\2\u0167\u0169\7\u0083\2\2\u0168\u0167\3\2\2\2\u0168")
        buf.write("\u0169\3\2\2\2\u0169\u016b\3\2\2\2\u016a\u0141\3\2\2\2")
        buf.write("\u016a\u0147\3\2\2\2\u016a\u014b\3\2\2\2\u016a\u0154\3")
        buf.write("\2\2\2\u016a\u015d\3\2\2\2\u016a\u0164\3\2\2\2\u016b!")
        buf.write("\3\2\2\2\u016c\u016e\5$\23\2\u016d\u016c\3\2\2\2\u016e")
        buf.write("\u0171\3\2\2\2\u016f\u016d\3\2\2\2\u016f\u0170\3\2\2\2")
        buf.write("\u0170#\3\2\2\2\u0171\u016f\3\2\2\2\u0172\u0173\t\24\2")
        buf.write("\2\u0173\u0174\7\u0095\2\2\u0174\u0176\7\u0097\2\2\u0175")
        buf.write("\u0177\7\u0083\2\2\u0176\u0175\3\2\2\2\u0176\u0177\3\2")
        buf.write("\2\2\u0177\u019b\3\2\2\2\u0178\u0179\t\25\2\2\u0179\u017a")
        buf.write("\7\u0096\2\2\u017a\u017b\7\u00b9\2\2\u017b\u017c\7\u00b8")
        buf.write("\2\2\u017c\u017d\7\u0095\2\2\u017d\u017f\7\u0097\2\2\u017e")
        buf.write("\u0180\7\u0083\2\2\u017f\u017e\3\2\2\2\u017f\u0180\3\2")
        buf.write("\2\2\u0180\u019b\3\2\2\2\u0181\u0182\t\26\2\2\u0182\u0183")
        buf.write("\7\u009a\2\2\u0183\u0184\7\u00b9\2\2\u0184\u0185\7\u00b8")
        buf.write("\2\2\u0185\u0186\7\u0099\2\2\u0186\u0188\7\u009b\2\2\u0187")
        buf.write("\u0189\7\u0083\2\2\u0188\u0187\3\2\2\2\u0188\u0189\3\2")
        buf.write("\2\2\u0189\u019b\3\2\2\2\u018a\u018b\t\27\2\2\u018b\u018c")
        buf.write("\7\u00a8\2\2\u018c\u018d\t\5\2\2\u018d\u019b\7\u00a9\2")
        buf.write("\2\u018e\u018f\t\30\2\2\u018f\u0190\7\u0099\2\2\u0190")
        buf.write("\u0192\7\u009b\2\2\u0191\u0193\7\u0083\2\2\u0192\u0191")
        buf.write("\3\2\2\2\u0192\u0193\3\2\2\2\u0193\u019b\3\2\2\2\u0194")
        buf.write("\u0195\7r\2\2\u0195\u0196\7\u008d\2\2\u0196\u0198\7\u0086")
        buf.write("\2\2\u0197\u0199\7\u0083\2\2\u0198\u0197\3\2\2\2\u0198")
        buf.write("\u0199\3\2\2\2\u0199\u019b\3\2\2\2\u019a\u0172\3\2\2\2")
        buf.write("\u019a\u0178\3\2\2\2\u019a\u0181\3\2\2\2\u019a\u018a\3")
        buf.write("\2\2\2\u019a\u018e\3\2\2\2\u019a\u0194\3\2\2\2\u019b%")
        buf.write("\3\2\2\2\u019c\u019e\5(\25\2\u019d\u019c\3\2\2\2\u019e")
        buf.write("\u01a1\3\2\2\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2")
        buf.write("\u01a0\'\3\2\2\2\u01a1\u019f\3\2\2\2\u01a2\u01a3\t\31")
        buf.write("\2\2\u01a3\u01a4\7\u0095\2\2\u01a4\u01a6\7\u0097\2\2\u01a5")
        buf.write("\u01a7\7\u0083\2\2\u01a6\u01a5\3\2\2\2\u01a6\u01a7\3\2")
        buf.write("\2\2\u01a7\u01c5\3\2\2\2\u01a8\u01a9\t\32\2\2\u01a9\u01aa")
        buf.write("\7\u0096\2\2\u01aa\u01ab\7\u00b9\2\2\u01ab\u01ac\7\u00b8")
        buf.write("\2\2\u01ac\u01ad\7\u0095\2\2\u01ad\u01af\7\u0097\2\2\u01ae")
        buf.write("\u01b0\7\u0083\2\2\u01af\u01ae\3\2\2\2\u01af\u01b0\3\2")
        buf.write("\2\2\u01b0\u01c5\3\2\2\2\u01b1\u01b2\t\33\2\2\u01b2\u01b3")
        buf.write("\7\u009a\2\2\u01b3\u01b4\7\u00b9\2\2\u01b4\u01b5\7\u00b8")
        buf.write("\2\2\u01b5\u01b6\7\u0099\2\2\u01b6\u01b8\7\u009b\2\2\u01b7")
        buf.write("\u01b9\7\u0083\2\2\u01b8\u01b7\3\2\2\2\u01b8\u01b9\3\2")
        buf.write("\2\2\u01b9\u01c5\3\2\2\2\u01ba\u01bb\7z\2\2\u01bb\u01bc")
        buf.write("\7\u00a8\2\2\u01bc\u01bd\t\5\2\2\u01bd\u01c5\7\u00a9\2")
        buf.write("\2\u01be\u01bf\t\34\2\2\u01bf\u01c0\7\u0099\2\2\u01c0")
        buf.write("\u01c2\7\u009b\2\2\u01c1\u01c3\7\u0083\2\2\u01c2\u01c1")
        buf.write("\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4")
        buf.write("\u01a2\3\2\2\2\u01c4\u01a8\3\2\2\2\u01c4\u01b1\3\2\2\2")
        buf.write("\u01c4\u01ba\3\2\2\2\u01c4\u01be\3\2\2\2\u01c5)\3\2\2")
        buf.write("\2\u01c6\u01c7\7\u00bb\2\2\u01c7\u01c8\7\u00c5\2\2\u01c8")
        buf.write("\u01ca\5:\36\2\u01c9\u01cb\7\u00c4\2\2\u01ca\u01c9\3\2")
        buf.write("\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd")
        buf.write("\5:\36\2\u01cd\u01ce\7\u00c6\2\2\u01ce\u01e2\3\2\2\2\u01cf")
        buf.write("\u01d0\7\u00bb\2\2\u01d0\u01d1\7\u00c7\2\2\u01d1\u01d3")
        buf.write("\5:\36\2\u01d2\u01d4\7\u00c4\2\2\u01d3\u01d2\3\2\2\2\u01d3")
        buf.write("\u01d4\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01d6\5:\36\2")
        buf.write("\u01d6\u01d7\7\u00c8\2\2\u01d7\u01e2\3\2\2\2\u01d8\u01d9")
        buf.write("\7\u00bb\2\2\u01d9\u01da\7\u00c9\2\2\u01da\u01dc\5:\36")
        buf.write("\2\u01db\u01dd\7\u00c4\2\2\u01dc\u01db\3\2\2\2\u01dc\u01dd")
        buf.write("\3\2\2\2\u01dd\u01de\3\2\2\2\u01de\u01df\5:\36\2\u01df")
        buf.write("\u01e0\7\u00ca\2\2\u01e0\u01e2\3\2\2\2\u01e1\u01c6\3\2")
        buf.write("\2\2\u01e1\u01cf\3\2\2\2\u01e1\u01d8\3\2\2\2\u01e2+\3")
        buf.write("\2\2\2\u01e3\u01e4\7\u00bc\2\2\u01e4\u01e5\7\u00c5\2\2")
        buf.write("\u01e5\u01e7\5:\36\2\u01e6\u01e8\7\u00c4\2\2\u01e7\u01e6")
        buf.write("\3\2\2\2\u01e7\u01e8\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9")
        buf.write("\u01eb\5:\36\2\u01ea\u01ec\7\u00c4\2\2\u01eb\u01ea\3\2")
        buf.write("\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee")
        buf.write("\5:\36\2\u01ee\u01ef\7\u00c6\2\2\u01ef\u020b\3\2\2\2\u01f0")
        buf.write("\u01f1\7\u00bc\2\2\u01f1\u01f2\7\u00c7\2\2\u01f2\u01f4")
        buf.write("\5:\36\2\u01f3\u01f5\7\u00c4\2\2\u01f4\u01f3\3\2\2\2\u01f4")
        buf.write("\u01f5\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f8\5:\36\2")
        buf.write("\u01f7\u01f9\7\u00c4\2\2\u01f8\u01f7\3\2\2\2\u01f8\u01f9")
        buf.write("\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fb\5:\36\2\u01fb")
        buf.write("\u01fc\7\u00c8\2\2\u01fc\u020b\3\2\2\2\u01fd\u01fe\7\u00bc")
        buf.write("\2\2\u01fe\u01ff\7\u00c9\2\2\u01ff\u0201\5:\36\2\u0200")
        buf.write("\u0202\7\u00c4\2\2\u0201\u0200\3\2\2\2\u0201\u0202\3\2")
        buf.write("\2\2\u0202\u0203\3\2\2\2\u0203\u0205\5:\36\2\u0204\u0206")
        buf.write("\7\u00c4\2\2\u0205\u0204\3\2\2\2\u0205\u0206\3\2\2\2\u0206")
        buf.write("\u0207\3\2\2\2\u0207\u0208\5:\36\2\u0208\u0209\7\u00ca")
        buf.write("\2\2\u0209\u020b\3\2\2\2\u020a\u01e3\3\2\2\2\u020a\u01f0")
        buf.write("\3\2\2\2\u020a\u01fd\3\2\2\2\u020b-\3\2\2\2\u020c\u020d")
        buf.write("\7\u00bc\2\2\u020d\u020e\7\u00c5\2\2\u020e\u0210\5:\36")
        buf.write("\2\u020f\u0211\7\u00c4\2\2\u0210\u020f\3\2\2\2\u0210\u0211")
        buf.write("\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0213\5<\37\2\u0213")
        buf.write("\u0214\7\u00c6\2\2\u0214\u0243\3\2\2\2\u0215\u0216\7\u00bc")
        buf.write("\2\2\u0216\u0217\7\u00c7\2\2\u0217\u0219\5:\36\2\u0218")
        buf.write("\u021a\7\u00c4\2\2\u0219\u0218\3\2\2\2\u0219\u021a\3\2")
        buf.write("\2\2\u021a\u021b\3\2\2\2\u021b\u021c\5<\37\2\u021c\u021d")
        buf.write("\7\u00c8\2\2\u021d\u0243\3\2\2\2\u021e\u021f\7\u00bc\2")
        buf.write("\2\u021f\u0220\7\u00c9\2\2\u0220\u0222\5:\36\2\u0221\u0223")
        buf.write("\7\u00c4\2\2\u0222\u0221\3\2\2\2\u0222\u0223\3\2\2\2\u0223")
        buf.write("\u0224\3\2\2\2\u0224\u0225\5<\37\2\u0225\u0226\7\u00ca")
        buf.write("\2\2\u0226\u0243\3\2\2\2\u0227\u0228\7\u00bc\2\2\u0228")
        buf.write("\u0229\7\u00c5\2\2\u0229\u022b\5<\37\2\u022a\u022c\7\u00c4")
        buf.write("\2\2\u022b\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022d")
        buf.write("\3\2\2\2\u022d\u022e\5:\36\2\u022e\u022f\7\u00c6\2\2\u022f")
        buf.write("\u0243\3\2\2\2\u0230\u0231\7\u00bc\2\2\u0231\u0232\7\u00c7")
        buf.write("\2\2\u0232\u0234\5<\37\2\u0233\u0235\7\u00c4\2\2\u0234")
        buf.write("\u0233\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2\2")
        buf.write("\u0236\u0237\5:\36\2\u0237\u0238\7\u00c8\2\2\u0238\u0243")
        buf.write("\3\2\2\2\u0239\u023a\7\u00bc\2\2\u023a\u023b\7\u00c9\2")
        buf.write("\2\u023b\u023d\5<\37\2\u023c\u023e\7\u00c4\2\2\u023d\u023c")
        buf.write("\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u023f\3\2\2\2\u023f")
        buf.write("\u0240\5:\36\2\u0240\u0241\7\u00ca\2\2\u0241\u0243\3\2")
        buf.write("\2\2\u0242\u020c\3\2\2\2\u0242\u0215\3\2\2\2\u0242\u021e")
        buf.write("\3\2\2\2\u0242\u0227\3\2\2\2\u0242\u0230\3\2\2\2\u0242")
        buf.write("\u0239\3\2\2\2\u0243/\3\2\2\2\u0244\u0245\7\u00bc\2\2")
        buf.write("\u0245\u0246\7\u00c5\2\2\u0246\u0248\5<\37\2\u0247\u0249")
        buf.write("\7\u00c4\2\2\u0248\u0247\3\2\2\2\u0248\u0249\3\2\2\2\u0249")
        buf.write("\u024a\3\2\2\2\u024a\u024b\5<\37\2\u024b\u024c\7\u00c6")
        buf.write("\2\2\u024c\u0260\3\2\2\2\u024d\u024e\7\u00bc\2\2\u024e")
        buf.write("\u024f\7\u00c7\2\2\u024f\u0251\5<\37\2\u0250\u0252\7\u00c4")
        buf.write("\2\2\u0251\u0250\3\2\2\2\u0251\u0252\3\2\2\2\u0252\u0253")
        buf.write("\3\2\2\2\u0253\u0254\5<\37\2\u0254\u0255\7\u00c8\2\2\u0255")
        buf.write("\u0260\3\2\2\2\u0256\u0257\7\u00bc\2\2\u0257\u0258\7\u00c9")
        buf.write("\2\2\u0258\u025a\5<\37\2\u0259\u025b\7\u00c4\2\2\u025a")
        buf.write("\u0259\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c\3\2\2\2")
        buf.write("\u025c\u025d\5<\37\2\u025d\u025e\7\u00ca\2\2\u025e\u0260")
        buf.write("\3\2\2\2\u025f\u0244\3\2\2\2\u025f\u024d\3\2\2\2\u025f")
        buf.write("\u0256\3\2\2\2\u0260\61\3\2\2\2\u0261\u0262\7\u00bd\2")
        buf.write("\2\u0262\u0263\7\u00c5\2\2\u0263\u0265\5:\36\2\u0264\u0266")
        buf.write("\7\u00c4\2\2\u0265\u0264\3\2\2\2\u0265\u0266\3\2\2\2\u0266")
        buf.write("\u0267\3\2\2\2\u0267\u0269\5:\36\2\u0268\u026a\7\u00c4")
        buf.write("\2\2\u0269\u0268\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026b")
        buf.write("\3\2\2\2\u026b\u026d\5:\36\2\u026c\u026e\7\u00c4\2\2\u026d")
        buf.write("\u026c\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u026f\3\2\2\2")
        buf.write("\u026f\u0270\5:\36\2\u0270\u0271\7\u00c6\2\2\u0271\u0295")
        buf.write("\3\2\2\2\u0272\u0273\7\u00bd\2\2\u0273\u0274\7\u00c7\2")
        buf.write("\2\u0274\u0276\5:\36\2\u0275\u0277\7\u00c4\2\2\u0276\u0275")
        buf.write("\3\2\2\2\u0276\u0277\3\2\2\2\u0277\u0278\3\2\2\2\u0278")
        buf.write("\u027a\5:\36\2\u0279\u027b\7\u00c4\2\2\u027a\u0279\3\2")
        buf.write("\2\2\u027a\u027b\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027e")
        buf.write("\5:\36\2\u027d\u027f\7\u00c4\2\2\u027e\u027d\3\2\2\2\u027e")
        buf.write("\u027f\3\2\2\2\u027f\u0280\3\2\2\2\u0280\u0281\5:\36\2")
        buf.write("\u0281\u0282\7\u00c8\2\2\u0282\u0295\3\2\2\2\u0283\u0284")
        buf.write("\7\u00bd\2\2\u0284\u0285\7\u00c9\2\2\u0285\u0287\5:\36")
        buf.write("\2\u0286\u0288\7\u00c4\2\2\u0287\u0286\3\2\2\2\u0287\u0288")
        buf.write("\3\2\2\2\u0288\u0289\3\2\2\2\u0289\u028b\5:\36\2\u028a")
        buf.write("\u028c\7\u00c4\2\2\u028b\u028a\3\2\2\2\u028b\u028c\3\2")
        buf.write("\2\2\u028c\u028d\3\2\2\2\u028d\u028f\5:\36\2\u028e\u0290")
        buf.write("\7\u00c4\2\2\u028f\u028e\3\2\2\2\u028f\u0290\3\2\2\2\u0290")
        buf.write("\u0291\3\2\2\2\u0291\u0292\5:\36\2\u0292\u0293\7\u00ca")
        buf.write("\2\2\u0293\u0295\3\2\2\2\u0294\u0261\3\2\2\2\u0294\u0272")
        buf.write("\3\2\2\2\u0294\u0283\3\2\2\2\u0295\63\3\2\2\2\u0296\u0297")
        buf.write("\7\u00be\2\2\u0297\u0298\7\u00c5\2\2\u0298\u029a\5*\26")
        buf.write("\2\u0299\u029b\7\u00c4\2\2\u029a\u0299\3\2\2\2\u029a\u029b")
        buf.write("\3\2\2\2\u029b\u029c\3\2\2\2\u029c\u029e\7\u00c2\2\2\u029d")
        buf.write("\u029f\7\u00c4\2\2\u029e\u029d\3\2\2\2\u029e\u029f\3\2")
        buf.write("\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a2\5*\26\2\u02a1\u02a3")
        buf.write("\7\u00c4\2\2\u02a2\u02a1\3\2\2\2\u02a2\u02a3\3\2\2\2\u02a3")
        buf.write("\u02a4\3\2\2\2\u02a4\u02a5\7\u00c2\2\2\u02a5\u02a6\7\u00c6")
        buf.write("\2\2\u02a6\u02ca\3\2\2\2\u02a7\u02a8\7\u00be\2\2\u02a8")
        buf.write("\u02a9\7\u00c7\2\2\u02a9\u02ab\5*\26\2\u02aa\u02ac\7\u00c4")
        buf.write("\2\2\u02ab\u02aa\3\2\2\2\u02ab\u02ac\3\2\2\2\u02ac\u02ad")
        buf.write("\3\2\2\2\u02ad\u02af\7\u00c2\2\2\u02ae\u02b0\7\u00c4\2")
        buf.write("\2\u02af\u02ae\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b1")
        buf.write("\3\2\2\2\u02b1\u02b3\5*\26\2\u02b2\u02b4\7\u00c4\2\2\u02b3")
        buf.write("\u02b2\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\3\2\2\2")
        buf.write("\u02b5\u02b6\7\u00c2\2\2\u02b6\u02b7\7\u00c8\2\2\u02b7")
        buf.write("\u02ca\3\2\2\2\u02b8\u02b9\7\u00be\2\2\u02b9\u02ba\7\u00c9")
        buf.write("\2\2\u02ba\u02bc\5*\26\2\u02bb\u02bd\7\u00c4\2\2\u02bc")
        buf.write("\u02bb\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd\u02be\3\2\2\2")
        buf.write("\u02be\u02c0\7\u00c2\2\2\u02bf\u02c1\7\u00c4\2\2\u02c0")
        buf.write("\u02bf\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c2\3\2\2\2")
        buf.write("\u02c2\u02c4\5*\26\2\u02c3\u02c5\7\u00c4\2\2\u02c4\u02c3")
        buf.write("\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6")
        buf.write("\u02c7\7\u00c2\2\2\u02c7\u02c8\7\u00ca\2\2\u02c8\u02ca")
        buf.write("\3\2\2\2\u02c9\u0296\3\2\2\2\u02c9\u02a7\3\2\2\2\u02c9")
        buf.write("\u02b8\3\2\2\2\u02ca\65\3\2\2\2\u02cb\u02cc\7\u00be\2")
        buf.write("\2\u02cc\u02cd\7\u00c5\2\2\u02cd\u02cf\5*\26\2\u02ce\u02d0")
        buf.write("\7\u00c4\2\2\u02cf\u02ce\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0")
        buf.write("\u02d1\3\2\2\2\u02d1\u02d3\7\u00c2\2\2\u02d2\u02d4\7\u00c4")
        buf.write("\2\2\u02d3\u02d2\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d5")
        buf.write("\3\2\2\2\u02d5\u02d7\5*\26\2\u02d6\u02d8\7\u00c4\2\2\u02d7")
        buf.write("\u02d6\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02d9\3\2\2\2")
        buf.write("\u02d9\u02db\7\u00c2\2\2\u02da\u02dc\7\u00c4\2\2\u02db")
        buf.write("\u02da\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02dd\3\2\2\2")
        buf.write("\u02dd\u02df\5*\26\2\u02de\u02e0\7\u00c4\2\2\u02df\u02de")
        buf.write("\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1")
        buf.write("\u02e2\7\u00c2\2\2\u02e2\u02e3\7\u00c6\2\2\u02e3\u0317")
        buf.write("\3\2\2\2\u02e4\u02e5\7\u00be\2\2\u02e5\u02e6\7\u00c7\2")
        buf.write("\2\u02e6\u02e8\5*\26\2\u02e7\u02e9\7\u00c4\2\2\u02e8\u02e7")
        buf.write("\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea")
        buf.write("\u02ec\7\u00c2\2\2\u02eb\u02ed\7\u00c4\2\2\u02ec\u02eb")
        buf.write("\3\2\2\2\u02ec\u02ed\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee")
        buf.write("\u02f0\5*\26\2\u02ef\u02f1\7\u00c4\2\2\u02f0\u02ef\3\2")
        buf.write("\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f4")
        buf.write("\7\u00c2\2\2\u02f3\u02f5\7\u00c4\2\2\u02f4\u02f3\3\2\2")
        buf.write("\2\u02f4\u02f5\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u02f8")
        buf.write("\5*\26\2\u02f7\u02f9\7\u00c4\2\2\u02f8\u02f7\3\2\2\2\u02f8")
        buf.write("\u02f9\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fb\7\u00c2")
        buf.write("\2\2\u02fb\u02fc\7\u00c8\2\2\u02fc\u0317\3\2\2\2\u02fd")
        buf.write("\u02fe\7\u00be\2\2\u02fe\u02ff\7\u00c9\2\2\u02ff\u0301")
        buf.write("\5*\26\2\u0300\u0302\7\u00c4\2\2\u0301\u0300\3\2\2\2\u0301")
        buf.write("\u0302\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0305\7\u00c2")
        buf.write("\2\2\u0304\u0306\7\u00c4\2\2\u0305\u0304\3\2\2\2\u0305")
        buf.write("\u0306\3\2\2\2\u0306\u0307\3\2\2\2\u0307\u0309\5*\26\2")
        buf.write("\u0308\u030a\7\u00c4\2\2\u0309\u0308\3\2\2\2\u0309\u030a")
        buf.write("\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030d\7\u00c2\2\2\u030c")
        buf.write("\u030e\7\u00c4\2\2\u030d\u030c\3\2\2\2\u030d\u030e\3\2")
        buf.write("\2\2\u030e\u030f\3\2\2\2\u030f\u0311\5*\26\2\u0310\u0312")
        buf.write("\7\u00c4\2\2\u0311\u0310\3\2\2\2\u0311\u0312\3\2\2\2\u0312")
        buf.write("\u0313\3\2\2\2\u0313\u0314\7\u00c2\2\2\u0314\u0315\7\u00ca")
        buf.write("\2\2\u0315\u0317\3\2\2\2\u0316\u02cb\3\2\2\2\u0316\u02e4")
        buf.write("\3\2\2\2\u0316\u02fd\3\2\2\2\u0317\67\3\2\2\2\u0318\u0319")
        buf.write("\7\u00be\2\2\u0319\u031a\7\u00c5\2\2\u031a\u031c\5*\26")
        buf.write("\2\u031b\u031d\7\u00c4\2\2\u031c\u031b\3\2\2\2\u031c\u031d")
        buf.write("\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0320\7\u00c2\2\2\u031f")
        buf.write("\u0321\7\u00c4\2\2\u0320\u031f\3\2\2\2\u0320\u0321\3\2")
        buf.write("\2\2\u0321\u0322\3\2\2\2\u0322\u0324\5*\26\2\u0323\u0325")
        buf.write("\7\u00c4\2\2\u0324\u0323\3\2\2\2\u0324\u0325\3\2\2\2\u0325")
        buf.write("\u0326\3\2\2\2\u0326\u0328\7\u00c2\2\2\u0327\u0329\7\u00c4")
        buf.write("\2\2\u0328\u0327\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u032a")
        buf.write("\3\2\2\2\u032a\u032c\5*\26\2\u032b\u032d\7\u00c4\2\2\u032c")
        buf.write("\u032b\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u032e\3\2\2\2")
        buf.write("\u032e\u0330\7\u00c2\2\2\u032f\u0331\7\u00c4\2\2\u0330")
        buf.write("\u032f\3\2\2\2\u0330\u0331\3\2\2\2\u0331\u0332\3\2\2\2")
        buf.write("\u0332\u0334\5*\26\2\u0333\u0335\7\u00c4\2\2\u0334\u0333")
        buf.write("\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0336\3\2\2\2\u0336")
        buf.write("\u0337\7\u00c2\2\2\u0337\u0338\7\u00c6\2\2\u0338\u037c")
        buf.write("\3\2\2\2\u0339\u033a\7\u00be\2\2\u033a\u033b\7\u00c7\2")
        buf.write("\2\u033b\u033d\5*\26\2\u033c\u033e\7\u00c4\2\2\u033d\u033c")
        buf.write("\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u033f\3\2\2\2\u033f")
        buf.write("\u0341\7\u00c2\2\2\u0340\u0342\7\u00c4\2\2\u0341\u0340")
        buf.write("\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0343\3\2\2\2\u0343")
        buf.write("\u0345\5*\26\2\u0344\u0346\7\u00c4\2\2\u0345\u0344\3\2")
        buf.write("\2\2\u0345\u0346\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0349")
        buf.write("\7\u00c2\2\2\u0348\u034a\7\u00c4\2\2\u0349\u0348\3\2\2")
        buf.write("\2\u0349\u034a\3\2\2\2\u034a\u034b\3\2\2\2\u034b\u034d")
        buf.write("\5*\26\2\u034c\u034e\7\u00c4\2\2\u034d\u034c\3\2\2\2\u034d")
        buf.write("\u034e\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0351\7\u00c2")
        buf.write("\2\2\u0350\u0352\7\u00c4\2\2\u0351\u0350\3\2\2\2\u0351")
        buf.write("\u0352\3\2\2\2\u0352\u0353\3\2\2\2\u0353\u0355\5*\26\2")
        buf.write("\u0354\u0356\7\u00c4\2\2\u0355\u0354\3\2\2\2\u0355\u0356")
        buf.write("\3\2\2\2\u0356\u0357\3\2\2\2\u0357\u0358\7\u00c2\2\2\u0358")
        buf.write("\u0359\7\u00c8\2\2\u0359\u037c\3\2\2\2\u035a\u035b\7\u00be")
        buf.write("\2\2\u035b\u035c\7\u00c9\2\2\u035c\u035e\5*\26\2\u035d")
        buf.write("\u035f\7\u00c4\2\2\u035e\u035d\3\2\2\2\u035e\u035f\3\2")
        buf.write("\2\2\u035f\u0360\3\2\2\2\u0360\u0362\7\u00c2\2\2\u0361")
        buf.write("\u0363\7\u00c4\2\2\u0362\u0361\3\2\2\2\u0362\u0363\3\2")
        buf.write("\2\2\u0363\u0364\3\2\2\2\u0364\u0366\5*\26\2\u0365\u0367")
        buf.write("\7\u00c4\2\2\u0366\u0365\3\2\2\2\u0366\u0367\3\2\2\2\u0367")
        buf.write("\u0368\3\2\2\2\u0368\u036a\7\u00c2\2\2\u0369\u036b\7\u00c4")
        buf.write("\2\2\u036a\u0369\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036c")
        buf.write("\3\2\2\2\u036c\u036e\5*\26\2\u036d\u036f\7\u00c4\2\2\u036e")
        buf.write("\u036d\3\2\2\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2\2\2")
        buf.write("\u0370\u0372\7\u00c2\2\2\u0371\u0373\7\u00c4\2\2\u0372")
        buf.write("\u0371\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0374\3\2\2\2")
        buf.write("\u0374\u0376\5*\26\2\u0375\u0377\7\u00c4\2\2\u0376\u0375")
        buf.write("\3\2\2\2\u0376\u0377\3\2\2\2\u0377\u0378\3\2\2\2\u0378")
        buf.write("\u0379\7\u00c2\2\2\u0379\u037a\7\u00ca\2\2\u037a\u037c")
        buf.write("\3\2\2\2\u037b\u0318\3\2\2\2\u037b\u0339\3\2\2\2\u037b")
        buf.write("\u035a\3\2\2\2\u037c9\3\2\2\2\u037d\u0393\7\u00c1\2\2")
        buf.write("\u037e\u037f\7\u00c5\2\2\u037f\u0380\7\u00c1\2\2\u0380")
        buf.write("\u0393\7\u00c6\2\2\u0381\u0382\7\u00c7\2\2\u0382\u0383")
        buf.write("\7\u00c1\2\2\u0383\u0393\7\u00c8\2\2\u0384\u0385\7\u00c9")
        buf.write("\2\2\u0385\u0386\7\u00c1\2\2\u0386\u0393\7\u00ca\2\2\u0387")
        buf.write("\u0393\7\u00c3\2\2\u0388\u0389\7\u00c5\2\2\u0389\u038a")
        buf.write("\7\u00c3\2\2\u038a\u0393\7\u00c6\2\2\u038b\u038c\7\u00c7")
        buf.write("\2\2\u038c\u038d\7\u00c3\2\2\u038d\u0393\7\u00c8\2\2\u038e")
        buf.write("\u038f\7\u00c9\2\2\u038f\u0390\7\u00c3\2\2\u0390\u0393")
        buf.write("\7\u00ca\2\2\u0391\u0393\5> \2\u0392\u037d\3\2\2\2\u0392")
        buf.write("\u037e\3\2\2\2\u0392\u0381\3\2\2\2\u0392\u0384\3\2\2\2")
        buf.write("\u0392\u0387\3\2\2\2\u0392\u0388\3\2\2\2\u0392\u038b\3")
        buf.write("\2\2\2\u0392\u038e\3\2\2\2\u0392\u0391\3\2\2\2\u0393;")
        buf.write("\3\2\2\2\u0394\u0395\7\u00bf\2\2\u0395\u0396\7\u00c5\2")
        buf.write("\2\u0396\u0398\5:\36\2\u0397\u0399\7\u00c4\2\2\u0398\u0397")
        buf.write("\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u039a\3\2\2\2\u039a")
        buf.write("\u039c\5:\36\2\u039b\u039d\7\u00c4\2\2\u039c\u039b\3\2")
        buf.write("\2\2\u039c\u039d\3\2\2\2\u039d\u039e\3\2\2\2\u039e\u03a0")
        buf.write("\5:\36\2\u039f\u03a1\7\u00c4\2\2\u03a0\u039f\3\2\2\2\u03a0")
        buf.write("\u03a1\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2\u03a3\5:\36\2")
        buf.write("\u03a3\u03a4\7\u00c6\2\2\u03a4\u03c8\3\2\2\2\u03a5\u03a6")
        buf.write("\7\u00bf\2\2\u03a6\u03a7\7\u00c7\2\2\u03a7\u03a9\5:\36")
        buf.write("\2\u03a8\u03aa\7\u00c4\2\2\u03a9\u03a8\3\2\2\2\u03a9\u03aa")
        buf.write("\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u03ad\5:\36\2\u03ac")
        buf.write("\u03ae\7\u00c4\2\2\u03ad\u03ac\3\2\2\2\u03ad\u03ae\3\2")
        buf.write("\2\2\u03ae\u03af\3\2\2\2\u03af\u03b1\5:\36\2\u03b0\u03b2")
        buf.write("\7\u00c4\2\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2")
        buf.write("\u03b3\3\2\2\2\u03b3\u03b4\5:\36\2\u03b4\u03b5\7\u00c8")
        buf.write("\2\2\u03b5\u03c8\3\2\2\2\u03b6\u03b7\7\u00bf\2\2\u03b7")
        buf.write("\u03b8\7\u00c9\2\2\u03b8\u03ba\5:\36\2\u03b9\u03bb\7\u00c4")
        buf.write("\2\2\u03ba\u03b9\3\2\2\2\u03ba\u03bb\3\2\2\2\u03bb\u03bc")
        buf.write("\3\2\2\2\u03bc\u03be\5:\36\2\u03bd\u03bf\7\u00c4\2\2\u03be")
        buf.write("\u03bd\3\2\2\2\u03be\u03bf\3\2\2\2\u03bf\u03c0\3\2\2\2")
        buf.write("\u03c0\u03c2\5:\36\2\u03c1\u03c3\7\u00c4\2\2\u03c2\u03c1")
        buf.write("\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4")
        buf.write("\u03c5\5:\36\2\u03c5\u03c6\7\u00ca\2\2\u03c6\u03c8\3\2")
        buf.write("\2\2\u03c7\u0394\3\2\2\2\u03c7\u03a5\3\2\2\2\u03c7\u03b6")
        buf.write("\3\2\2\2\u03c8=\3\2\2\2\u03c9\u03ca\7\u00c0\2\2\u03ca")
        buf.write("\u03cb\7\u00c5\2\2\u03cb\u03d2\5:\36\2\u03cc\u03ce\7\u00c4")
        buf.write("\2\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03cf")
        buf.write("\3\2\2\2\u03cf\u03d1\5:\36\2\u03d0\u03cd\3\2\2\2\u03d1")
        buf.write("\u03d4\3\2\2\2\u03d2\u03d0\3\2\2\2\u03d2\u03d3\3\2\2\2")
        buf.write("\u03d3\u03d5\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d5\u03d6\7")
        buf.write("\u00c6\2\2\u03d6\u03f4\3\2\2\2\u03d7\u03d8\7\u00c0\2\2")
        buf.write("\u03d8\u03d9\7\u00c7\2\2\u03d9\u03e0\5:\36\2\u03da\u03dc")
        buf.write("\7\u00c4\2\2\u03db\u03da\3\2\2\2\u03db\u03dc\3\2\2\2\u03dc")
        buf.write("\u03dd\3\2\2\2\u03dd\u03df\5:\36\2\u03de\u03db\3\2\2\2")
        buf.write("\u03df\u03e2\3\2\2\2\u03e0\u03de\3\2\2\2\u03e0\u03e1\3")
        buf.write("\2\2\2\u03e1\u03e3\3\2\2\2\u03e2\u03e0\3\2\2\2\u03e3\u03e4")
        buf.write("\7\u00c8\2\2\u03e4\u03f4\3\2\2\2\u03e5\u03e6\7\u00c0\2")
        buf.write("\2\u03e6\u03e7\7\u00c9\2\2\u03e7\u03ee\5:\36\2\u03e8\u03ea")
        buf.write("\7\u00c4\2\2\u03e9\u03e8\3\2\2\2\u03e9\u03ea\3\2\2\2\u03ea")
        buf.write("\u03eb\3\2\2\2\u03eb\u03ed\5:\36\2\u03ec\u03e9\3\2\2\2")
        buf.write("\u03ed\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3")
        buf.write("\2\2\2\u03ef\u03f1\3\2\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2")
        buf.write("\7\u00ca\2\2\u03f2\u03f4\3\2\2\2\u03f3\u03c9\3\2\2\2\u03f3")
        buf.write("\u03d7\3\2\2\2\u03f3\u03e5\3\2\2\2\u03f4?\3\2\2\2\u0091")
        buf.write("GIRq\u0087\u008b\u0095\u009b\u00a1\u00b5\u00be\u00c3\u00cd")
        buf.write("\u00d6\u00e1\u00ec\u00f2\u00f8\u00fa\u00ff\u0106\u010f")
        buf.write("\u011a\u0123\u0137\u0139\u013e\u0145\u0152\u015b\u0168")
        buf.write("\u016a\u016f\u0176\u017f\u0188\u0192\u0198\u019a\u019f")
        buf.write("\u01a6\u01af\u01b8\u01c2\u01c4\u01ca\u01d3\u01dc\u01e1")
        buf.write("\u01e7\u01eb\u01f4\u01f8\u0201\u0205\u020a\u0210\u0219")
        buf.write("\u0222\u022b\u0234\u023d\u0242\u0248\u0251\u025a\u025f")
        buf.write("\u0265\u0269\u026d\u0276\u027a\u027e\u0287\u028b\u028f")
        buf.write("\u0294\u029a\u029e\u02a2\u02ab\u02af\u02b3\u02bc\u02c0")
        buf.write("\u02c4\u02c9\u02cf\u02d3\u02d7\u02db\u02df\u02e8\u02ec")
        buf.write("\u02f0\u02f4\u02f8\u0301\u0305\u0309\u030d\u0311\u0316")
        buf.write("\u031c\u0320\u0324\u0328\u032c\u0330\u0334\u033d\u0341")
        buf.write("\u0345\u0349\u034d\u0351\u0355\u035e\u0362\u0366\u036a")
        buf.write("\u036e\u0372\u0376\u037b\u0392\u0398\u039c\u03a0\u03a9")
        buf.write("\u03ad\u03b1\u03ba\u03be\u03c2\u03c7\u03cd\u03d2\u03db")
        buf.write("\u03e0\u03e9\u03ee\u03f3")
        return buf.getvalue()


class AmberMRParser ( Parser ):

    grammarFileName = "AmberMRParser.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>", "'&'" ]

    symbolicNames = [ "<INVALID>", "END", "RST", "IAT", "RSTWT", "RESTRAINT", 
                      "ATNAM", "IRESID", "NSTEP1", "NSTEP2", "IRSTYP", "IALTD", 
                      "IFVARI", "NINC", "IMULT", "R1", "R2", "R3", "R4", 
                      "RK2", "RK3", "R1A", "R2A", "R3A", "R4A", "RK2A", 
                      "RK3A", "R0", "K0", "R0A", "K0A", "RJCOEF", "IGR1", 
                      "IGR2", "IGR3", "IGR4", "IGR5", "IGR6", "IGR7", "IGR8", 
                      "FXYZ", "OUTXYZ", "GRNAM1", "GRNAM2", "GRNAM3", "GRNAM4", 
                      "GRNAM5", "GRNAM6", "GRNAM7", "GRNAM8", "IR6", "IFNTYP", 
                      "IXPK", "NXPK", "ICONSTR", "NOEEXP", "NPEAK", "EMIX", 
                      "IHP", "JHP", "AEXP", "ARANGE", "AWT", "INVWT1", "INVWT2", 
                      "OMEGA", "TAUROT", "TAUMET", "ID2O", "OSCALE", "SHF", 
                      "NRING", "NATR", "IATR", "NAMR", "STR", "IPROT", "OBS", 
                      "SHRANG", "WT", "NPROT", "SHCUT", "NTER", "CTER", 
                      "PCSHF", "NME", "NMPMC", "OPTPHI", "OPTTET", "OPTOMG", 
                      "OPTA1", "OPTA2", "OPTKON", "TOLPRO", "MLTPRO", "ALIGN", 
                      "NDIP", "ID", "JD", "DOBSL", "DOBSU", "DWT", "DATASET", 
                      "NUM_DATASET", "S11", "S12", "S13", "S22", "S23", 
                      "GIGJ", "DIJ", "DCUT", "FREEZEMOL", "CSA", "NCSA", 
                      "ICSA", "JCSA", "KCSA", "COBSL", "COBSU", "CWT", "DATASETC", 
                      "FIELD", "SIGMA11", "SIGMA12", "SIGMA13", "SIGMA22", 
                      "SIGMA23", "CCUT", "Comma", "Ampersand", "COMMENT", 
                      "Logical", "L_paren", "R_paren", "L_brace", "R_brace", 
                      "L_brakt", "R_brakt", "Equ_op", "L_QUOT", "SPACE", 
                      "HIDDEN_COMMENT", "EMPTY_COMMENT", "Any_name", "SPACE_C", 
                      "RETURN_C", "Equ_op_IP", "L_paren_IP", "Integer", 
                      "SPACE_IP", "Equ_op_RP", "L_paren_RP", "Real", "SPACE_RP", 
                      "Equ_op_BP", "BoolInt", "SPACE_BP", "L_paren_IA", 
                      "Equ_op_IA", "Comma_IA", "Asterisk_IA", "Integers", 
                      "MultiplicativeInt", "RETURN_IA", "L_paren_RA", "Equ_op_RA", 
                      "Comma_RA", "Asterisk_RA", "Reals", "MultiplicativeReal", 
                      "RETURN_RA", "Equ_op_BA", "Comma_BA", "BoolInts", 
                      "RETURN_BA", "L_paren_QA", "Equ_op_QA", "Comma_QA", 
                      "Qstrings", "RETURN_QA", "Comma_A", "R_paren_A", "Decimal", 
                      "SPACE_A", "DISTANCE_F", "ANGLE_F", "TORSION_F", "COORDINATE_F", 
                      "PLANE_F", "COM_F", "Integer_F", "Real_F", "Ambmask_F", 
                      "Comma_F", "L_paren_F", "R_paren_F", "L_brace_F", 
                      "R_brace_F", "L_brakt_F", "R_brakt_F", "R_QUOT", "SPACE_F" ]

    RULE_amber_mr = 0
    RULE_comment = 1
    RULE_nmr_restraint = 2
    RULE_noesy_volume_restraint = 3
    RULE_chemical_shift_restraint = 4
    RULE_pcs_restraint = 5
    RULE_dipolar_coupling_restraint = 6
    RULE_csa_restraint = 7
    RULE_restraint_statement = 8
    RULE_restraint_factor = 9
    RULE_noeexp_statement = 10
    RULE_noeexp_factor = 11
    RULE_shf_statement = 12
    RULE_shf_factor = 13
    RULE_pcshf_statement = 14
    RULE_pcshf_factor = 15
    RULE_align_statement = 16
    RULE_align_factor = 17
    RULE_csa_statement = 18
    RULE_csa_factor = 19
    RULE_distance_rst_func_call = 20
    RULE_angle_rst_func_call = 21
    RULE_plane_point_angle_rst_func_call = 22
    RULE_plane_plane_angle_rst_func_call = 23
    RULE_torsion_rst_func_call = 24
    RULE_coordinate2_rst_func_call = 25
    RULE_coordinate3_rst_func_call = 26
    RULE_coordinate4_rst_func_call = 27
    RULE_restraint_func_expr = 28
    RULE_plane_rst_func_call = 29
    RULE_com_rst_func_call = 30

    ruleNames =  [ "amber_mr", "comment", "nmr_restraint", "noesy_volume_restraint", 
                   "chemical_shift_restraint", "pcs_restraint", "dipolar_coupling_restraint", 
                   "csa_restraint", "restraint_statement", "restraint_factor", 
                   "noeexp_statement", "noeexp_factor", "shf_statement", 
                   "shf_factor", "pcshf_statement", "pcshf_factor", "align_statement", 
                   "align_factor", "csa_statement", "csa_factor", "distance_rst_func_call", 
                   "angle_rst_func_call", "plane_point_angle_rst_func_call", 
                   "plane_plane_angle_rst_func_call", "torsion_rst_func_call", 
                   "coordinate2_rst_func_call", "coordinate3_rst_func_call", 
                   "coordinate4_rst_func_call", "restraint_func_expr", "plane_rst_func_call", 
                   "com_rst_func_call" ]

    EOF = Token.EOF
    END=1
    RST=2
    IAT=3
    RSTWT=4
    RESTRAINT=5
    ATNAM=6
    IRESID=7
    NSTEP1=8
    NSTEP2=9
    IRSTYP=10
    IALTD=11
    IFVARI=12
    NINC=13
    IMULT=14
    R1=15
    R2=16
    R3=17
    R4=18
    RK2=19
    RK3=20
    R1A=21
    R2A=22
    R3A=23
    R4A=24
    RK2A=25
    RK3A=26
    R0=27
    K0=28
    R0A=29
    K0A=30
    RJCOEF=31
    IGR1=32
    IGR2=33
    IGR3=34
    IGR4=35
    IGR5=36
    IGR6=37
    IGR7=38
    IGR8=39
    FXYZ=40
    OUTXYZ=41
    GRNAM1=42
    GRNAM2=43
    GRNAM3=44
    GRNAM4=45
    GRNAM5=46
    GRNAM6=47
    GRNAM7=48
    GRNAM8=49
    IR6=50
    IFNTYP=51
    IXPK=52
    NXPK=53
    ICONSTR=54
    NOEEXP=55
    NPEAK=56
    EMIX=57
    IHP=58
    JHP=59
    AEXP=60
    ARANGE=61
    AWT=62
    INVWT1=63
    INVWT2=64
    OMEGA=65
    TAUROT=66
    TAUMET=67
    ID2O=68
    OSCALE=69
    SHF=70
    NRING=71
    NATR=72
    IATR=73
    NAMR=74
    STR=75
    IPROT=76
    OBS=77
    SHRANG=78
    WT=79
    NPROT=80
    SHCUT=81
    NTER=82
    CTER=83
    PCSHF=84
    NME=85
    NMPMC=86
    OPTPHI=87
    OPTTET=88
    OPTOMG=89
    OPTA1=90
    OPTA2=91
    OPTKON=92
    TOLPRO=93
    MLTPRO=94
    ALIGN=95
    NDIP=96
    ID=97
    JD=98
    DOBSL=99
    DOBSU=100
    DWT=101
    DATASET=102
    NUM_DATASET=103
    S11=104
    S12=105
    S13=106
    S22=107
    S23=108
    GIGJ=109
    DIJ=110
    DCUT=111
    FREEZEMOL=112
    CSA=113
    NCSA=114
    ICSA=115
    JCSA=116
    KCSA=117
    COBSL=118
    COBSU=119
    CWT=120
    DATASETC=121
    FIELD=122
    SIGMA11=123
    SIGMA12=124
    SIGMA13=125
    SIGMA22=126
    SIGMA23=127
    CCUT=128
    Comma=129
    Ampersand=130
    COMMENT=131
    Logical=132
    L_paren=133
    R_paren=134
    L_brace=135
    R_brace=136
    L_brakt=137
    R_brakt=138
    Equ_op=139
    L_QUOT=140
    SPACE=141
    HIDDEN_COMMENT=142
    EMPTY_COMMENT=143
    Any_name=144
    SPACE_C=145
    RETURN_C=146
    Equ_op_IP=147
    L_paren_IP=148
    Integer=149
    SPACE_IP=150
    Equ_op_RP=151
    L_paren_RP=152
    Real=153
    SPACE_RP=154
    Equ_op_BP=155
    BoolInt=156
    SPACE_BP=157
    L_paren_IA=158
    Equ_op_IA=159
    Comma_IA=160
    Asterisk_IA=161
    Integers=162
    MultiplicativeInt=163
    RETURN_IA=164
    L_paren_RA=165
    Equ_op_RA=166
    Comma_RA=167
    Asterisk_RA=168
    Reals=169
    MultiplicativeReal=170
    RETURN_RA=171
    Equ_op_BA=172
    Comma_BA=173
    BoolInts=174
    RETURN_BA=175
    L_paren_QA=176
    Equ_op_QA=177
    Comma_QA=178
    Qstrings=179
    RETURN_QA=180
    Comma_A=181
    R_paren_A=182
    Decimal=183
    SPACE_A=184
    DISTANCE_F=185
    ANGLE_F=186
    TORSION_F=187
    COORDINATE_F=188
    PLANE_F=189
    COM_F=190
    Integer_F=191
    Real_F=192
    Ambmask_F=193
    Comma_F=194
    L_paren_F=195
    R_paren_F=196
    L_brace_F=197
    R_brace_F=198
    L_brakt_F=199
    R_brakt_F=200
    R_QUOT=201
    SPACE_F=202

    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 Amber_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(AmberMRParser.EOF, 0)

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


        def nmr_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Nmr_restraintContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Nmr_restraintContext,i)


        def noesy_volume_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Noesy_volume_restraintContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Noesy_volume_restraintContext,i)


        def chemical_shift_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Chemical_shift_restraintContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Chemical_shift_restraintContext,i)


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


        def dipolar_coupling_restraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Dipolar_coupling_restraintContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Dipolar_coupling_restraintContext,i)


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


        def getRuleIndex(self):
            return AmberMRParser.RULE_amber_mr

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

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




    def amber_mr(self):

        localctx = AmberMRParser.Amber_mrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_amber_mr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 71
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberMRParser.RST or _la==AmberMRParser.NOEEXP or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (AmberMRParser.SHF - 70)) | (1 << (AmberMRParser.PCSHF - 70)) | (1 << (AmberMRParser.ALIGN - 70)) | (1 << (AmberMRParser.CSA - 70)) | (1 << (AmberMRParser.COMMENT - 70)))) != 0):
                self.state = 69
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [AmberMRParser.COMMENT]:
                    self.state = 62
                    self.comment()
                    pass
                elif token in [AmberMRParser.RST]:
                    self.state = 63
                    self.nmr_restraint()
                    pass
                elif token in [AmberMRParser.NOEEXP]:
                    self.state = 64
                    self.noesy_volume_restraint()
                    pass
                elif token in [AmberMRParser.SHF]:
                    self.state = 65
                    self.chemical_shift_restraint()
                    pass
                elif token in [AmberMRParser.PCSHF]:
                    self.state = 66
                    self.pcs_restraint()
                    pass
                elif token in [AmberMRParser.ALIGN]:
                    self.state = 67
                    self.dipolar_coupling_restraint()
                    pass
                elif token in [AmberMRParser.CSA]:
                    self.state = 68
                    self.csa_restraint()
                    pass
                else:
                    raise NoViableAltException(self)

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

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


    class CommentContext(ParserRuleContext):

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

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

        def RETURN_C(self):
            return self.getToken(AmberMRParser.RETURN_C, 0)

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

        def getRuleIndex(self):
            return AmberMRParser.RULE_comment

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

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




    def comment(self):

        localctx = AmberMRParser.CommentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_comment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 76
            self.match(AmberMRParser.COMMENT)
            self.state = 78 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 77
                self.match(AmberMRParser.Any_name)
                self.state = 80 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==AmberMRParser.Any_name):
                    break

            self.state = 82
            self.match(AmberMRParser.RETURN_C)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Nmr_restraintContext(ParserRuleContext):

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

        def RST(self):
            return self.getToken(AmberMRParser.RST, 0)

        def restraint_statement(self):
            return self.getTypedRuleContext(AmberMRParser.Restraint_statementContext,0)


        def END(self):
            return self.getToken(AmberMRParser.END, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_nmr_restraint

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

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




    def nmr_restraint(self):

        localctx = AmberMRParser.Nmr_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_nmr_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 84
            self.match(AmberMRParser.RST)
            self.state = 85
            self.restraint_statement()
            self.state = 86
            self.match(AmberMRParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Noesy_volume_restraintContext(ParserRuleContext):

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

        def NOEEXP(self):
            return self.getToken(AmberMRParser.NOEEXP, 0)

        def noeexp_statement(self):
            return self.getTypedRuleContext(AmberMRParser.Noeexp_statementContext,0)


        def END(self):
            return self.getToken(AmberMRParser.END, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_noesy_volume_restraint

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

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




    def noesy_volume_restraint(self):

        localctx = AmberMRParser.Noesy_volume_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_noesy_volume_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 88
            self.match(AmberMRParser.NOEEXP)
            self.state = 89
            self.noeexp_statement()
            self.state = 90
            self.match(AmberMRParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Chemical_shift_restraintContext(ParserRuleContext):

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

        def SHF(self):
            return self.getToken(AmberMRParser.SHF, 0)

        def shf_statement(self):
            return self.getTypedRuleContext(AmberMRParser.Shf_statementContext,0)


        def END(self):
            return self.getToken(AmberMRParser.END, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_chemical_shift_restraint

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

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




    def chemical_shift_restraint(self):

        localctx = AmberMRParser.Chemical_shift_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_chemical_shift_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 92
            self.match(AmberMRParser.SHF)
            self.state = 93
            self.shf_statement()
            self.state = 94
            self.match(AmberMRParser.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 PCSHF(self):
            return self.getToken(AmberMRParser.PCSHF, 0)

        def pcshf_statement(self):
            return self.getTypedRuleContext(AmberMRParser.Pcshf_statementContext,0)


        def END(self):
            return self.getToken(AmberMRParser.END, 0)

        def getRuleIndex(self):
            return AmberMRParser.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 = AmberMRParser.Pcs_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_pcs_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 96
            self.match(AmberMRParser.PCSHF)
            self.state = 97
            self.pcshf_statement()
            self.state = 98
            self.match(AmberMRParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dipolar_coupling_restraintContext(ParserRuleContext):

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

        def ALIGN(self):
            return self.getToken(AmberMRParser.ALIGN, 0)

        def align_statement(self):
            return self.getTypedRuleContext(AmberMRParser.Align_statementContext,0)


        def END(self):
            return self.getToken(AmberMRParser.END, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_dipolar_coupling_restraint

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

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




    def dipolar_coupling_restraint(self):

        localctx = AmberMRParser.Dipolar_coupling_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_dipolar_coupling_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 100
            self.match(AmberMRParser.ALIGN)
            self.state = 101
            self.align_statement()
            self.state = 102
            self.match(AmberMRParser.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 CSA(self):
            return self.getToken(AmberMRParser.CSA, 0)

        def csa_statement(self):
            return self.getTypedRuleContext(AmberMRParser.Csa_statementContext,0)


        def END(self):
            return self.getToken(AmberMRParser.END, 0)

        def getRuleIndex(self):
            return AmberMRParser.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 = AmberMRParser.Csa_restraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_csa_restraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 104
            self.match(AmberMRParser.CSA)
            self.state = 105
            self.csa_statement()
            self.state = 106
            self.match(AmberMRParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Restraint_statementContext(ParserRuleContext):

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

        def restraint_factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Restraint_factorContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Restraint_factorContext,i)


        def getRuleIndex(self):
            return AmberMRParser.RULE_restraint_statement

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

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




    def restraint_statement(self):

        localctx = AmberMRParser.Restraint_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_restraint_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 111
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.IAT) | (1 << AmberMRParser.RSTWT) | (1 << AmberMRParser.RESTRAINT) | (1 << AmberMRParser.ATNAM) | (1 << AmberMRParser.IRESID) | (1 << AmberMRParser.NSTEP1) | (1 << AmberMRParser.NSTEP2) | (1 << AmberMRParser.IRSTYP) | (1 << AmberMRParser.IALTD) | (1 << AmberMRParser.IFVARI) | (1 << AmberMRParser.NINC) | (1 << AmberMRParser.IMULT) | (1 << AmberMRParser.R1) | (1 << AmberMRParser.R2) | (1 << AmberMRParser.R3) | (1 << AmberMRParser.R4) | (1 << AmberMRParser.RK2) | (1 << AmberMRParser.RK3) | (1 << AmberMRParser.R1A) | (1 << AmberMRParser.R2A) | (1 << AmberMRParser.R3A) | (1 << AmberMRParser.R4A) | (1 << AmberMRParser.RK2A) | (1 << AmberMRParser.RK3A) | (1 << AmberMRParser.R0) | (1 << AmberMRParser.K0) | (1 << AmberMRParser.R0A) | (1 << AmberMRParser.K0A) | (1 << AmberMRParser.RJCOEF) | (1 << AmberMRParser.IGR1) | (1 << AmberMRParser.IGR2) | (1 << AmberMRParser.IGR3) | (1 << AmberMRParser.IGR4) | (1 << AmberMRParser.IGR5) | (1 << AmberMRParser.IGR6) | (1 << AmberMRParser.IGR7) | (1 << AmberMRParser.IGR8) | (1 << AmberMRParser.FXYZ) | (1 << AmberMRParser.OUTXYZ) | (1 << AmberMRParser.GRNAM1) | (1 << AmberMRParser.GRNAM2) | (1 << AmberMRParser.GRNAM3) | (1 << AmberMRParser.GRNAM4) | (1 << AmberMRParser.GRNAM5) | (1 << AmberMRParser.GRNAM6) | (1 << AmberMRParser.GRNAM7) | (1 << AmberMRParser.GRNAM8) | (1 << AmberMRParser.IR6) | (1 << AmberMRParser.IFNTYP) | (1 << AmberMRParser.IXPK) | (1 << AmberMRParser.NXPK) | (1 << AmberMRParser.ICONSTR))) != 0):
                self.state = 108
                self.restraint_factor()
                self.state = 113
                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 Restraint_factorContext(ParserRuleContext):

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

        def Equ_op_IA(self):
            return self.getToken(AmberMRParser.Equ_op_IA, 0)

        def Comma_IA(self):
            return self.getToken(AmberMRParser.Comma_IA, 0)

        def IAT(self):
            return self.getToken(AmberMRParser.IAT, 0)

        def IGR1(self):
            return self.getToken(AmberMRParser.IGR1, 0)

        def IGR2(self):
            return self.getToken(AmberMRParser.IGR2, 0)

        def IGR3(self):
            return self.getToken(AmberMRParser.IGR3, 0)

        def IGR4(self):
            return self.getToken(AmberMRParser.IGR4, 0)

        def IGR5(self):
            return self.getToken(AmberMRParser.IGR5, 0)

        def IGR6(self):
            return self.getToken(AmberMRParser.IGR6, 0)

        def IGR7(self):
            return self.getToken(AmberMRParser.IGR7, 0)

        def IGR8(self):
            return self.getToken(AmberMRParser.IGR8, 0)

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

        def MultiplicativeInt(self):
            return self.getToken(AmberMRParser.MultiplicativeInt, 0)

        def Equ_op_RA(self):
            return self.getToken(AmberMRParser.Equ_op_RA, 0)

        def Comma_RA(self):
            return self.getToken(AmberMRParser.Comma_RA, 0)

        def RSTWT(self):
            return self.getToken(AmberMRParser.RSTWT, 0)

        def RJCOEF(self):
            return self.getToken(AmberMRParser.RJCOEF, 0)

        def Reals(self):
            return self.getToken(AmberMRParser.Reals, 0)

        def MultiplicativeReal(self):
            return self.getToken(AmberMRParser.MultiplicativeReal, 0)

        def RESTRAINT(self):
            return self.getToken(AmberMRParser.RESTRAINT, 0)

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

        def L_QUOT(self):
            return self.getToken(AmberMRParser.L_QUOT, 0)

        def R_QUOT(self):
            return self.getToken(AmberMRParser.R_QUOT, 0)

        def distance_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Distance_rst_func_callContext,0)


        def angle_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Angle_rst_func_callContext,0)


        def torsion_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Torsion_rst_func_callContext,0)


        def plane_point_angle_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Plane_point_angle_rst_func_callContext,0)


        def plane_plane_angle_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Plane_plane_angle_rst_func_callContext,0)


        def coordinate2_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Coordinate2_rst_func_callContext,0)


        def coordinate3_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Coordinate3_rst_func_callContext,0)


        def coordinate4_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Coordinate4_rst_func_callContext,0)


        def Comma(self):
            return self.getToken(AmberMRParser.Comma, 0)

        def Equ_op_QA(self):
            return self.getToken(AmberMRParser.Equ_op_QA, 0)

        def Qstrings(self):
            return self.getToken(AmberMRParser.Qstrings, 0)

        def Comma_QA(self):
            return self.getToken(AmberMRParser.Comma_QA, 0)

        def ATNAM(self):
            return self.getToken(AmberMRParser.ATNAM, 0)

        def GRNAM1(self):
            return self.getToken(AmberMRParser.GRNAM1, 0)

        def GRNAM2(self):
            return self.getToken(AmberMRParser.GRNAM2, 0)

        def GRNAM3(self):
            return self.getToken(AmberMRParser.GRNAM3, 0)

        def GRNAM4(self):
            return self.getToken(AmberMRParser.GRNAM4, 0)

        def GRNAM5(self):
            return self.getToken(AmberMRParser.GRNAM5, 0)

        def GRNAM6(self):
            return self.getToken(AmberMRParser.GRNAM6, 0)

        def GRNAM7(self):
            return self.getToken(AmberMRParser.GRNAM7, 0)

        def GRNAM8(self):
            return self.getToken(AmberMRParser.GRNAM8, 0)

        def Equ_op_BP(self):
            return self.getToken(AmberMRParser.Equ_op_BP, 0)

        def BoolInt(self):
            return self.getToken(AmberMRParser.BoolInt, 0)

        def IRESID(self):
            return self.getToken(AmberMRParser.IRESID, 0)

        def IRSTYP(self):
            return self.getToken(AmberMRParser.IRSTYP, 0)

        def IALTD(self):
            return self.getToken(AmberMRParser.IALTD, 0)

        def IMULT(self):
            return self.getToken(AmberMRParser.IMULT, 0)

        def OUTXYZ(self):
            return self.getToken(AmberMRParser.OUTXYZ, 0)

        def IR6(self):
            return self.getToken(AmberMRParser.IR6, 0)

        def IFNTYP(self):
            return self.getToken(AmberMRParser.IFNTYP, 0)

        def Equ_op_IP(self):
            return self.getToken(AmberMRParser.Equ_op_IP, 0)

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

        def NSTEP1(self):
            return self.getToken(AmberMRParser.NSTEP1, 0)

        def NSTEP2(self):
            return self.getToken(AmberMRParser.NSTEP2, 0)

        def IFVARI(self):
            return self.getToken(AmberMRParser.IFVARI, 0)

        def NINC(self):
            return self.getToken(AmberMRParser.NINC, 0)

        def IXPK(self):
            return self.getToken(AmberMRParser.IXPK, 0)

        def NXPK(self):
            return self.getToken(AmberMRParser.NXPK, 0)

        def ICONSTR(self):
            return self.getToken(AmberMRParser.ICONSTR, 0)

        def Equ_op_RP(self):
            return self.getToken(AmberMRParser.Equ_op_RP, 0)

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

        def R1(self):
            return self.getToken(AmberMRParser.R1, 0)

        def R2(self):
            return self.getToken(AmberMRParser.R2, 0)

        def R3(self):
            return self.getToken(AmberMRParser.R3, 0)

        def R4(self):
            return self.getToken(AmberMRParser.R4, 0)

        def RK2(self):
            return self.getToken(AmberMRParser.RK2, 0)

        def RK3(self):
            return self.getToken(AmberMRParser.RK3, 0)

        def R1A(self):
            return self.getToken(AmberMRParser.R1A, 0)

        def R2A(self):
            return self.getToken(AmberMRParser.R2A, 0)

        def R3A(self):
            return self.getToken(AmberMRParser.R3A, 0)

        def R4A(self):
            return self.getToken(AmberMRParser.R4A, 0)

        def RK2A(self):
            return self.getToken(AmberMRParser.RK2A, 0)

        def RK3A(self):
            return self.getToken(AmberMRParser.RK3A, 0)

        def R0(self):
            return self.getToken(AmberMRParser.R0, 0)

        def K0(self):
            return self.getToken(AmberMRParser.K0, 0)

        def R0A(self):
            return self.getToken(AmberMRParser.R0A, 0)

        def K0A(self):
            return self.getToken(AmberMRParser.K0A, 0)

        def FXYZ(self):
            return self.getToken(AmberMRParser.FXYZ, 0)

        def Equ_op_BA(self):
            return self.getToken(AmberMRParser.Equ_op_BA, 0)

        def BoolInts(self):
            return self.getToken(AmberMRParser.BoolInts, 0)

        def Comma_BA(self):
            return self.getToken(AmberMRParser.Comma_BA, 0)

        def L_paren_IA(self):
            return self.getToken(AmberMRParser.L_paren_IA, 0)

        def Decimal(self):
            return self.getToken(AmberMRParser.Decimal, 0)

        def R_paren_A(self):
            return self.getToken(AmberMRParser.R_paren_A, 0)

        def L_paren_RP(self):
            return self.getToken(AmberMRParser.L_paren_RP, 0)

        def L_paren_QA(self):
            return self.getToken(AmberMRParser.L_paren_QA, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_restraint_factor

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

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




    def restraint_factor(self):

        localctx = AmberMRParser.Restraint_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_restraint_factor)
        self._la = 0 # Token type
        try:
            self.state = 188
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 114
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.IAT) | (1 << AmberMRParser.IGR1) | (1 << AmberMRParser.IGR2) | (1 << AmberMRParser.IGR3) | (1 << AmberMRParser.IGR4) | (1 << AmberMRParser.IGR5) | (1 << AmberMRParser.IGR6) | (1 << AmberMRParser.IGR7) | (1 << AmberMRParser.IGR8))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 115
                self.match(AmberMRParser.Equ_op_IA)
                self.state = 116
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Integers or _la==AmberMRParser.MultiplicativeInt):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 117
                self.match(AmberMRParser.Comma_IA)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 118
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.RSTWT or _la==AmberMRParser.RJCOEF):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 119
                self.match(AmberMRParser.Equ_op_RA)
                self.state = 120
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Reals or _la==AmberMRParser.MultiplicativeReal):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 121
                self.match(AmberMRParser.Comma_RA)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 122
                self.match(AmberMRParser.RESTRAINT)
                self.state = 123
                self.match(AmberMRParser.Equ_op)
                self.state = 124
                self.match(AmberMRParser.L_QUOT)
                self.state = 133
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
                if la_ == 1:
                    self.state = 125
                    self.distance_rst_func_call()
                    pass

                elif la_ == 2:
                    self.state = 126
                    self.angle_rst_func_call()
                    pass

                elif la_ == 3:
                    self.state = 127
                    self.torsion_rst_func_call()
                    pass

                elif la_ == 4:
                    self.state = 128
                    self.plane_point_angle_rst_func_call()
                    pass

                elif la_ == 5:
                    self.state = 129
                    self.plane_plane_angle_rst_func_call()
                    pass

                elif la_ == 6:
                    self.state = 130
                    self.coordinate2_rst_func_call()
                    pass

                elif la_ == 7:
                    self.state = 131
                    self.coordinate3_rst_func_call()
                    pass

                elif la_ == 8:
                    self.state = 132
                    self.coordinate4_rst_func_call()
                    pass


                self.state = 135
                self.match(AmberMRParser.R_QUOT)
                self.state = 137
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 136
                    self.match(AmberMRParser.Comma)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 139
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.ATNAM) | (1 << AmberMRParser.GRNAM1) | (1 << AmberMRParser.GRNAM2) | (1 << AmberMRParser.GRNAM3) | (1 << AmberMRParser.GRNAM4) | (1 << AmberMRParser.GRNAM5) | (1 << AmberMRParser.GRNAM6) | (1 << AmberMRParser.GRNAM7) | (1 << AmberMRParser.GRNAM8))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 140
                self.match(AmberMRParser.Equ_op_QA)
                self.state = 141
                self.match(AmberMRParser.Qstrings)
                self.state = 142
                self.match(AmberMRParser.Comma_QA)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 143
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.IRESID) | (1 << AmberMRParser.IRSTYP) | (1 << AmberMRParser.IALTD) | (1 << AmberMRParser.IMULT) | (1 << AmberMRParser.OUTXYZ) | (1 << AmberMRParser.IR6) | (1 << AmberMRParser.IFNTYP))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 144
                self.match(AmberMRParser.Equ_op_BP)
                self.state = 145
                self.match(AmberMRParser.BoolInt)
                self.state = 147
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 146
                    self.match(AmberMRParser.Comma)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 149
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.NSTEP1) | (1 << AmberMRParser.NSTEP2) | (1 << AmberMRParser.IFVARI) | (1 << AmberMRParser.NINC) | (1 << AmberMRParser.IXPK) | (1 << AmberMRParser.NXPK) | (1 << AmberMRParser.ICONSTR))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 150
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 151
                self.match(AmberMRParser.Integer)
                self.state = 153
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 152
                    self.match(AmberMRParser.Comma)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 155
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.R1) | (1 << AmberMRParser.R2) | (1 << AmberMRParser.R3) | (1 << AmberMRParser.R4) | (1 << AmberMRParser.RK2) | (1 << AmberMRParser.RK3) | (1 << AmberMRParser.R1A) | (1 << AmberMRParser.R2A) | (1 << AmberMRParser.R3A) | (1 << AmberMRParser.R4A) | (1 << AmberMRParser.RK2A) | (1 << AmberMRParser.RK3A) | (1 << AmberMRParser.R0) | (1 << AmberMRParser.K0) | (1 << AmberMRParser.R0A) | (1 << AmberMRParser.K0A))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 156
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 157
                self.match(AmberMRParser.Real)
                self.state = 159
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 158
                    self.match(AmberMRParser.Comma)


                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 161
                self.match(AmberMRParser.FXYZ)
                self.state = 162
                self.match(AmberMRParser.Equ_op_BA)
                self.state = 163
                self.match(AmberMRParser.BoolInts)
                self.state = 164
                self.match(AmberMRParser.Comma_BA)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 165
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.IAT) | (1 << AmberMRParser.IGR1) | (1 << AmberMRParser.IGR2) | (1 << AmberMRParser.IGR3) | (1 << AmberMRParser.IGR4) | (1 << AmberMRParser.IGR5) | (1 << AmberMRParser.IGR6) | (1 << AmberMRParser.IGR7) | (1 << AmberMRParser.IGR8))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 166
                self.match(AmberMRParser.L_paren_IA)
                self.state = 167
                self.match(AmberMRParser.Decimal)
                self.state = 168
                self.match(AmberMRParser.R_paren_A)
                self.state = 169
                self.match(AmberMRParser.Equ_op_IA)
                self.state = 170
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Integers or _la==AmberMRParser.MultiplicativeInt):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 171
                self.match(AmberMRParser.Comma_IA)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 172
                self.match(AmberMRParser.RSTWT)
                self.state = 173
                self.match(AmberMRParser.L_paren_RP)
                self.state = 174
                self.match(AmberMRParser.Decimal)
                self.state = 175
                self.match(AmberMRParser.R_paren_A)
                self.state = 176
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 177
                self.match(AmberMRParser.Real)
                self.state = 179
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 178
                    self.match(AmberMRParser.Comma)


                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 181
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.ATNAM) | (1 << AmberMRParser.GRNAM1) | (1 << AmberMRParser.GRNAM2) | (1 << AmberMRParser.GRNAM3) | (1 << AmberMRParser.GRNAM4) | (1 << AmberMRParser.GRNAM5) | (1 << AmberMRParser.GRNAM6) | (1 << AmberMRParser.GRNAM7) | (1 << AmberMRParser.GRNAM8))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 182
                self.match(AmberMRParser.L_paren_QA)
                self.state = 183
                self.match(AmberMRParser.Decimal)
                self.state = 184
                self.match(AmberMRParser.R_paren_A)
                self.state = 185
                self.match(AmberMRParser.Equ_op_QA)
                self.state = 186
                self.match(AmberMRParser.Qstrings)
                self.state = 187
                self.match(AmberMRParser.Comma_QA)
                pass


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


    class Noeexp_statementContext(ParserRuleContext):

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

        def noeexp_factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Noeexp_factorContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Noeexp_factorContext,i)


        def getRuleIndex(self):
            return AmberMRParser.RULE_noeexp_statement

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

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




    def noeexp_statement(self):

        localctx = AmberMRParser.Noeexp_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_noeexp_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 193
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & ((1 << (AmberMRParser.NPEAK - 56)) | (1 << (AmberMRParser.EMIX - 56)) | (1 << (AmberMRParser.IHP - 56)) | (1 << (AmberMRParser.JHP - 56)) | (1 << (AmberMRParser.AEXP - 56)) | (1 << (AmberMRParser.ARANGE - 56)) | (1 << (AmberMRParser.AWT - 56)) | (1 << (AmberMRParser.INVWT1 - 56)) | (1 << (AmberMRParser.INVWT2 - 56)) | (1 << (AmberMRParser.OMEGA - 56)) | (1 << (AmberMRParser.TAUROT - 56)) | (1 << (AmberMRParser.TAUMET - 56)) | (1 << (AmberMRParser.ID2O - 56)) | (1 << (AmberMRParser.OSCALE - 56)))) != 0):
                self.state = 190
                self.noeexp_factor()
                self.state = 195
                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 Noeexp_factorContext(ParserRuleContext):

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

        def NPEAK(self):
            return self.getToken(AmberMRParser.NPEAK, 0)

        def L_paren_IP(self):
            return self.getToken(AmberMRParser.L_paren_IP, 0)

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

        def R_paren_A(self):
            return self.getToken(AmberMRParser.R_paren_A, 0)

        def Equ_op_IP(self):
            return self.getToken(AmberMRParser.Equ_op_IP, 0)

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

        def Comma(self):
            return self.getToken(AmberMRParser.Comma, 0)

        def EMIX(self):
            return self.getToken(AmberMRParser.EMIX, 0)

        def L_paren_RP(self):
            return self.getToken(AmberMRParser.L_paren_RP, 0)

        def Equ_op_RP(self):
            return self.getToken(AmberMRParser.Equ_op_RP, 0)

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

        def Comma_A(self):
            return self.getToken(AmberMRParser.Comma_A, 0)

        def IHP(self):
            return self.getToken(AmberMRParser.IHP, 0)

        def JHP(self):
            return self.getToken(AmberMRParser.JHP, 0)

        def AEXP(self):
            return self.getToken(AmberMRParser.AEXP, 0)

        def ARANGE(self):
            return self.getToken(AmberMRParser.ARANGE, 0)

        def AWT(self):
            return self.getToken(AmberMRParser.AWT, 0)

        def INVWT1(self):
            return self.getToken(AmberMRParser.INVWT1, 0)

        def INVWT2(self):
            return self.getToken(AmberMRParser.INVWT2, 0)

        def OMEGA(self):
            return self.getToken(AmberMRParser.OMEGA, 0)

        def TAUROT(self):
            return self.getToken(AmberMRParser.TAUROT, 0)

        def TAUMET(self):
            return self.getToken(AmberMRParser.TAUMET, 0)

        def OSCALE(self):
            return self.getToken(AmberMRParser.OSCALE, 0)

        def ID2O(self):
            return self.getToken(AmberMRParser.ID2O, 0)

        def Equ_op_BP(self):
            return self.getToken(AmberMRParser.Equ_op_BP, 0)

        def BoolInt(self):
            return self.getToken(AmberMRParser.BoolInt, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_noeexp_factor

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

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




    def noeexp_factor(self):

        localctx = AmberMRParser.Noeexp_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_noeexp_factor)
        self._la = 0 # Token type
        try:
            self.state = 248
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AmberMRParser.NPEAK]:
                self.enterOuterAlt(localctx, 1)
                self.state = 196
                self.match(AmberMRParser.NPEAK)
                self.state = 197
                self.match(AmberMRParser.L_paren_IP)
                self.state = 198
                self.match(AmberMRParser.Decimal)
                self.state = 199
                self.match(AmberMRParser.R_paren_A)
                self.state = 200
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 201
                self.match(AmberMRParser.Integer)
                self.state = 203
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 202
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.EMIX]:
                self.enterOuterAlt(localctx, 2)
                self.state = 205
                self.match(AmberMRParser.EMIX)
                self.state = 206
                self.match(AmberMRParser.L_paren_RP)
                self.state = 207
                self.match(AmberMRParser.Decimal)
                self.state = 208
                self.match(AmberMRParser.R_paren_A)
                self.state = 209
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 210
                self.match(AmberMRParser.Real)
                self.state = 212
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 211
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.IHP, AmberMRParser.JHP]:
                self.enterOuterAlt(localctx, 3)
                self.state = 214
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.IHP or _la==AmberMRParser.JHP):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 215
                self.match(AmberMRParser.L_paren_IP)
                self.state = 216
                self.match(AmberMRParser.Decimal)
                self.state = 217
                self.match(AmberMRParser.Comma_A)
                self.state = 218
                self.match(AmberMRParser.Decimal)
                self.state = 219
                self.match(AmberMRParser.R_paren_A)
                self.state = 220
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 221
                self.match(AmberMRParser.Integer)
                self.state = 223
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 222
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.AEXP, AmberMRParser.ARANGE, AmberMRParser.AWT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 225
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberMRParser.AEXP) | (1 << AmberMRParser.ARANGE) | (1 << AmberMRParser.AWT))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 226
                self.match(AmberMRParser.L_paren_RP)
                self.state = 227
                self.match(AmberMRParser.Decimal)
                self.state = 228
                self.match(AmberMRParser.Comma_A)
                self.state = 229
                self.match(AmberMRParser.Decimal)
                self.state = 230
                self.match(AmberMRParser.R_paren_A)
                self.state = 231
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 232
                self.match(AmberMRParser.Real)
                self.state = 234
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 233
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.INVWT1, AmberMRParser.INVWT2, AmberMRParser.OMEGA, AmberMRParser.TAUROT, AmberMRParser.TAUMET, AmberMRParser.OSCALE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 236
                _la = self._input.LA(1)
                if not(((((_la - 63)) & ~0x3f) == 0 and ((1 << (_la - 63)) & ((1 << (AmberMRParser.INVWT1 - 63)) | (1 << (AmberMRParser.INVWT2 - 63)) | (1 << (AmberMRParser.OMEGA - 63)) | (1 << (AmberMRParser.TAUROT - 63)) | (1 << (AmberMRParser.TAUMET - 63)) | (1 << (AmberMRParser.OSCALE - 63)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 237
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 238
                self.match(AmberMRParser.Real)
                self.state = 240
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 239
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.ID2O]:
                self.enterOuterAlt(localctx, 6)
                self.state = 242
                self.match(AmberMRParser.ID2O)
                self.state = 243
                self.match(AmberMRParser.Equ_op_BP)
                self.state = 244
                self.match(AmberMRParser.BoolInt)
                self.state = 246
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 245
                    self.match(AmberMRParser.Comma)


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

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

        def shf_factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Shf_factorContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Shf_factorContext,i)


        def getRuleIndex(self):
            return AmberMRParser.RULE_shf_statement

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

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




    def shf_statement(self):

        localctx = AmberMRParser.Shf_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_shf_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (AmberMRParser.NRING - 71)) | (1 << (AmberMRParser.NATR - 71)) | (1 << (AmberMRParser.IATR - 71)) | (1 << (AmberMRParser.NAMR - 71)) | (1 << (AmberMRParser.STR - 71)) | (1 << (AmberMRParser.IPROT - 71)) | (1 << (AmberMRParser.OBS - 71)) | (1 << (AmberMRParser.SHRANG - 71)) | (1 << (AmberMRParser.WT - 71)) | (1 << (AmberMRParser.NPROT - 71)) | (1 << (AmberMRParser.SHCUT - 71)) | (1 << (AmberMRParser.NTER - 71)) | (1 << (AmberMRParser.CTER - 71)))) != 0):
                self.state = 250
                self.shf_factor()
                self.state = 255
                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 Shf_factorContext(ParserRuleContext):

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

        def Equ_op_IP(self):
            return self.getToken(AmberMRParser.Equ_op_IP, 0)

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

        def NRING(self):
            return self.getToken(AmberMRParser.NRING, 0)

        def NPROT(self):
            return self.getToken(AmberMRParser.NPROT, 0)

        def NTER(self):
            return self.getToken(AmberMRParser.NTER, 0)

        def CTER(self):
            return self.getToken(AmberMRParser.CTER, 0)

        def Comma(self):
            return self.getToken(AmberMRParser.Comma, 0)

        def L_paren_IP(self):
            return self.getToken(AmberMRParser.L_paren_IP, 0)

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

        def R_paren_A(self):
            return self.getToken(AmberMRParser.R_paren_A, 0)

        def NATR(self):
            return self.getToken(AmberMRParser.NATR, 0)

        def IPROT(self):
            return self.getToken(AmberMRParser.IPROT, 0)

        def IATR(self):
            return self.getToken(AmberMRParser.IATR, 0)

        def Comma_A(self):
            return self.getToken(AmberMRParser.Comma_A, 0)

        def OBS(self):
            return self.getToken(AmberMRParser.OBS, 0)

        def L_paren_RP(self):
            return self.getToken(AmberMRParser.L_paren_RP, 0)

        def Equ_op_RP(self):
            return self.getToken(AmberMRParser.Equ_op_RP, 0)

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

        def L_paren_RA(self):
            return self.getToken(AmberMRParser.L_paren_RA, 0)

        def Equ_op_RA(self):
            return self.getToken(AmberMRParser.Equ_op_RA, 0)

        def Comma_RA(self):
            return self.getToken(AmberMRParser.Comma_RA, 0)

        def STR(self):
            return self.getToken(AmberMRParser.STR, 0)

        def SHRANG(self):
            return self.getToken(AmberMRParser.SHRANG, 0)

        def WT(self):
            return self.getToken(AmberMRParser.WT, 0)

        def Reals(self):
            return self.getToken(AmberMRParser.Reals, 0)

        def MultiplicativeReal(self):
            return self.getToken(AmberMRParser.MultiplicativeReal, 0)

        def NAMR(self):
            return self.getToken(AmberMRParser.NAMR, 0)

        def L_paren_QA(self):
            return self.getToken(AmberMRParser.L_paren_QA, 0)

        def Equ_op_QA(self):
            return self.getToken(AmberMRParser.Equ_op_QA, 0)

        def Qstrings(self):
            return self.getToken(AmberMRParser.Qstrings, 0)

        def Comma_QA(self):
            return self.getToken(AmberMRParser.Comma_QA, 0)

        def SHCUT(self):
            return self.getToken(AmberMRParser.SHCUT, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_shf_factor

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

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




    def shf_factor(self):

        localctx = AmberMRParser.Shf_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_shf_factor)
        self._la = 0 # Token type
        try:
            self.state = 311
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AmberMRParser.NRING, AmberMRParser.NPROT, AmberMRParser.NTER, AmberMRParser.CTER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 256
                _la = self._input.LA(1)
                if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (AmberMRParser.NRING - 71)) | (1 << (AmberMRParser.NPROT - 71)) | (1 << (AmberMRParser.NTER - 71)) | (1 << (AmberMRParser.CTER - 71)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 257
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 258
                self.match(AmberMRParser.Integer)
                self.state = 260
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 259
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.NATR, AmberMRParser.IPROT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 262
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.NATR or _la==AmberMRParser.IPROT):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 263
                self.match(AmberMRParser.L_paren_IP)
                self.state = 264
                self.match(AmberMRParser.Decimal)
                self.state = 265
                self.match(AmberMRParser.R_paren_A)
                self.state = 266
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 267
                self.match(AmberMRParser.Integer)
                self.state = 269
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 268
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.IATR]:
                self.enterOuterAlt(localctx, 3)
                self.state = 271
                self.match(AmberMRParser.IATR)
                self.state = 272
                self.match(AmberMRParser.L_paren_IP)
                self.state = 273
                self.match(AmberMRParser.Decimal)
                self.state = 274
                self.match(AmberMRParser.Comma_A)
                self.state = 275
                self.match(AmberMRParser.Decimal)
                self.state = 276
                self.match(AmberMRParser.R_paren_A)
                self.state = 277
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 278
                self.match(AmberMRParser.Integer)
                self.state = 280
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 279
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.OBS]:
                self.enterOuterAlt(localctx, 4)
                self.state = 282
                self.match(AmberMRParser.OBS)
                self.state = 283
                self.match(AmberMRParser.L_paren_RP)
                self.state = 284
                self.match(AmberMRParser.Decimal)
                self.state = 285
                self.match(AmberMRParser.R_paren_A)
                self.state = 286
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 287
                self.match(AmberMRParser.Real)
                self.state = 289
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 288
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.STR, AmberMRParser.SHRANG, AmberMRParser.WT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 291
                _la = self._input.LA(1)
                if not(((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (AmberMRParser.STR - 75)) | (1 << (AmberMRParser.SHRANG - 75)) | (1 << (AmberMRParser.WT - 75)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 292
                self.match(AmberMRParser.L_paren_RA)
                self.state = 293
                self.match(AmberMRParser.Decimal)
                self.state = 294
                self.match(AmberMRParser.R_paren_A)
                self.state = 295
                self.match(AmberMRParser.Equ_op_RA)
                self.state = 296
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Reals or _la==AmberMRParser.MultiplicativeReal):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 297
                self.match(AmberMRParser.Comma_RA)
                pass
            elif token in [AmberMRParser.NAMR]:
                self.enterOuterAlt(localctx, 6)
                self.state = 298
                self.match(AmberMRParser.NAMR)
                self.state = 299
                self.match(AmberMRParser.L_paren_QA)
                self.state = 300
                self.match(AmberMRParser.Decimal)
                self.state = 301
                self.match(AmberMRParser.R_paren_A)
                self.state = 302
                self.match(AmberMRParser.Equ_op_QA)
                self.state = 303
                self.match(AmberMRParser.Qstrings)
                self.state = 304
                self.match(AmberMRParser.Comma_QA)
                pass
            elif token in [AmberMRParser.SHCUT]:
                self.enterOuterAlt(localctx, 7)
                self.state = 305
                self.match(AmberMRParser.SHCUT)
                self.state = 306
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 307
                self.match(AmberMRParser.Real)
                self.state = 309
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 308
                    self.match(AmberMRParser.Comma)


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

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

        def pcshf_factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Pcshf_factorContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Pcshf_factorContext,i)


        def getRuleIndex(self):
            return AmberMRParser.RULE_pcshf_statement

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

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




    def pcshf_statement(self):

        localctx = AmberMRParser.Pcshf_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_pcshf_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 316
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (AmberMRParser.IPROT - 76)) | (1 << (AmberMRParser.OBS - 76)) | (1 << (AmberMRParser.WT - 76)) | (1 << (AmberMRParser.NPROT - 76)) | (1 << (AmberMRParser.NME - 76)) | (1 << (AmberMRParser.NMPMC - 76)) | (1 << (AmberMRParser.OPTPHI - 76)) | (1 << (AmberMRParser.OPTTET - 76)) | (1 << (AmberMRParser.OPTOMG - 76)) | (1 << (AmberMRParser.OPTA1 - 76)) | (1 << (AmberMRParser.OPTA2 - 76)) | (1 << (AmberMRParser.OPTKON - 76)) | (1 << (AmberMRParser.TOLPRO - 76)) | (1 << (AmberMRParser.MLTPRO - 76)))) != 0):
                self.state = 313
                self.pcshf_factor()
                self.state = 318
                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 Pcshf_factorContext(ParserRuleContext):

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

        def Equ_op_IP(self):
            return self.getToken(AmberMRParser.Equ_op_IP, 0)

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

        def NPROT(self):
            return self.getToken(AmberMRParser.NPROT, 0)

        def NME(self):
            return self.getToken(AmberMRParser.NME, 0)

        def Comma(self):
            return self.getToken(AmberMRParser.Comma, 0)

        def NMPMC(self):
            return self.getToken(AmberMRParser.NMPMC, 0)

        def Equ_op_QA(self):
            return self.getToken(AmberMRParser.Equ_op_QA, 0)

        def Qstrings(self):
            return self.getToken(AmberMRParser.Qstrings, 0)

        def Comma_QA(self):
            return self.getToken(AmberMRParser.Comma_QA, 0)

        def L_paren_IP(self):
            return self.getToken(AmberMRParser.L_paren_IP, 0)

        def Decimal(self):
            return self.getToken(AmberMRParser.Decimal, 0)

        def R_paren_A(self):
            return self.getToken(AmberMRParser.R_paren_A, 0)

        def IPROT(self):
            return self.getToken(AmberMRParser.IPROT, 0)

        def MLTPRO(self):
            return self.getToken(AmberMRParser.MLTPRO, 0)

        def L_paren_RP(self):
            return self.getToken(AmberMRParser.L_paren_RP, 0)

        def Equ_op_RP(self):
            return self.getToken(AmberMRParser.Equ_op_RP, 0)

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

        def OPTPHI(self):
            return self.getToken(AmberMRParser.OPTPHI, 0)

        def OPTTET(self):
            return self.getToken(AmberMRParser.OPTTET, 0)

        def OPTOMG(self):
            return self.getToken(AmberMRParser.OPTOMG, 0)

        def OPTA1(self):
            return self.getToken(AmberMRParser.OPTA1, 0)

        def OPTA2(self):
            return self.getToken(AmberMRParser.OPTA2, 0)

        def OBS(self):
            return self.getToken(AmberMRParser.OBS, 0)

        def L_paren_RA(self):
            return self.getToken(AmberMRParser.L_paren_RA, 0)

        def Equ_op_RA(self):
            return self.getToken(AmberMRParser.Equ_op_RA, 0)

        def Comma_RA(self):
            return self.getToken(AmberMRParser.Comma_RA, 0)

        def WT(self):
            return self.getToken(AmberMRParser.WT, 0)

        def TOLPRO(self):
            return self.getToken(AmberMRParser.TOLPRO, 0)

        def Reals(self):
            return self.getToken(AmberMRParser.Reals, 0)

        def MultiplicativeReal(self):
            return self.getToken(AmberMRParser.MultiplicativeReal, 0)

        def OPTKON(self):
            return self.getToken(AmberMRParser.OPTKON, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_pcshf_factor

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

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




    def pcshf_factor(self):

        localctx = AmberMRParser.Pcshf_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_pcshf_factor)
        self._la = 0 # Token type
        try:
            self.state = 360
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AmberMRParser.NPROT, AmberMRParser.NME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 319
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.NPROT or _la==AmberMRParser.NME):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 320
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 321
                self.match(AmberMRParser.Integer)
                self.state = 323
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 322
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.NMPMC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 325
                self.match(AmberMRParser.NMPMC)
                self.state = 326
                self.match(AmberMRParser.Equ_op_QA)
                self.state = 327
                self.match(AmberMRParser.Qstrings)
                self.state = 328
                self.match(AmberMRParser.Comma_QA)
                pass
            elif token in [AmberMRParser.IPROT, AmberMRParser.MLTPRO]:
                self.enterOuterAlt(localctx, 3)
                self.state = 329
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.IPROT or _la==AmberMRParser.MLTPRO):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 330
                self.match(AmberMRParser.L_paren_IP)
                self.state = 331
                self.match(AmberMRParser.Decimal)
                self.state = 332
                self.match(AmberMRParser.R_paren_A)
                self.state = 333
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 334
                self.match(AmberMRParser.Integer)
                self.state = 336
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 335
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.OBS, AmberMRParser.OPTPHI, AmberMRParser.OPTTET, AmberMRParser.OPTOMG, AmberMRParser.OPTA1, AmberMRParser.OPTA2]:
                self.enterOuterAlt(localctx, 4)
                self.state = 338
                _la = self._input.LA(1)
                if not(((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (AmberMRParser.OBS - 77)) | (1 << (AmberMRParser.OPTPHI - 77)) | (1 << (AmberMRParser.OPTTET - 77)) | (1 << (AmberMRParser.OPTOMG - 77)) | (1 << (AmberMRParser.OPTA1 - 77)) | (1 << (AmberMRParser.OPTA2 - 77)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 339
                self.match(AmberMRParser.L_paren_RP)
                self.state = 340
                self.match(AmberMRParser.Decimal)
                self.state = 341
                self.match(AmberMRParser.R_paren_A)
                self.state = 342
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 343
                self.match(AmberMRParser.Real)
                self.state = 345
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 344
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.WT, AmberMRParser.TOLPRO]:
                self.enterOuterAlt(localctx, 5)
                self.state = 347
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.WT or _la==AmberMRParser.TOLPRO):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 348
                self.match(AmberMRParser.L_paren_RA)
                self.state = 349
                self.match(AmberMRParser.Decimal)
                self.state = 350
                self.match(AmberMRParser.R_paren_A)
                self.state = 351
                self.match(AmberMRParser.Equ_op_RA)
                self.state = 352
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Reals or _la==AmberMRParser.MultiplicativeReal):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 353
                self.match(AmberMRParser.Comma_RA)
                pass
            elif token in [AmberMRParser.OPTKON]:
                self.enterOuterAlt(localctx, 6)
                self.state = 354
                self.match(AmberMRParser.OPTKON)
                self.state = 355
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 356
                self.match(AmberMRParser.Real)
                self.state = 358
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 357
                    self.match(AmberMRParser.Comma)


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

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

        def align_factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Align_factorContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Align_factorContext,i)


        def getRuleIndex(self):
            return AmberMRParser.RULE_align_statement

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

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




    def align_statement(self):

        localctx = AmberMRParser.Align_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_align_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 365
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (AmberMRParser.NDIP - 96)) | (1 << (AmberMRParser.ID - 96)) | (1 << (AmberMRParser.JD - 96)) | (1 << (AmberMRParser.DOBSL - 96)) | (1 << (AmberMRParser.DOBSU - 96)) | (1 << (AmberMRParser.DWT - 96)) | (1 << (AmberMRParser.DATASET - 96)) | (1 << (AmberMRParser.NUM_DATASET - 96)) | (1 << (AmberMRParser.S11 - 96)) | (1 << (AmberMRParser.S12 - 96)) | (1 << (AmberMRParser.S13 - 96)) | (1 << (AmberMRParser.S22 - 96)) | (1 << (AmberMRParser.S23 - 96)) | (1 << (AmberMRParser.GIGJ - 96)) | (1 << (AmberMRParser.DIJ - 96)) | (1 << (AmberMRParser.DCUT - 96)) | (1 << (AmberMRParser.FREEZEMOL - 96)))) != 0):
                self.state = 362
                self.align_factor()
                self.state = 367
                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 Align_factorContext(ParserRuleContext):

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

        def Equ_op_IP(self):
            return self.getToken(AmberMRParser.Equ_op_IP, 0)

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

        def NDIP(self):
            return self.getToken(AmberMRParser.NDIP, 0)

        def DATASET(self):
            return self.getToken(AmberMRParser.DATASET, 0)

        def NUM_DATASET(self):
            return self.getToken(AmberMRParser.NUM_DATASET, 0)

        def Comma(self):
            return self.getToken(AmberMRParser.Comma, 0)

        def L_paren_IP(self):
            return self.getToken(AmberMRParser.L_paren_IP, 0)

        def Decimal(self):
            return self.getToken(AmberMRParser.Decimal, 0)

        def R_paren_A(self):
            return self.getToken(AmberMRParser.R_paren_A, 0)

        def ID(self):
            return self.getToken(AmberMRParser.ID, 0)

        def JD(self):
            return self.getToken(AmberMRParser.JD, 0)

        def L_paren_RP(self):
            return self.getToken(AmberMRParser.L_paren_RP, 0)

        def Equ_op_RP(self):
            return self.getToken(AmberMRParser.Equ_op_RP, 0)

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

        def DOBSL(self):
            return self.getToken(AmberMRParser.DOBSL, 0)

        def DOBSU(self):
            return self.getToken(AmberMRParser.DOBSU, 0)

        def Equ_op_RA(self):
            return self.getToken(AmberMRParser.Equ_op_RA, 0)

        def Comma_RA(self):
            return self.getToken(AmberMRParser.Comma_RA, 0)

        def DWT(self):
            return self.getToken(AmberMRParser.DWT, 0)

        def GIGJ(self):
            return self.getToken(AmberMRParser.GIGJ, 0)

        def Reals(self):
            return self.getToken(AmberMRParser.Reals, 0)

        def MultiplicativeReal(self):
            return self.getToken(AmberMRParser.MultiplicativeReal, 0)

        def S11(self):
            return self.getToken(AmberMRParser.S11, 0)

        def S12(self):
            return self.getToken(AmberMRParser.S12, 0)

        def S13(self):
            return self.getToken(AmberMRParser.S13, 0)

        def S22(self):
            return self.getToken(AmberMRParser.S22, 0)

        def S23(self):
            return self.getToken(AmberMRParser.S23, 0)

        def DIJ(self):
            return self.getToken(AmberMRParser.DIJ, 0)

        def DCUT(self):
            return self.getToken(AmberMRParser.DCUT, 0)

        def FREEZEMOL(self):
            return self.getToken(AmberMRParser.FREEZEMOL, 0)

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

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

        def getRuleIndex(self):
            return AmberMRParser.RULE_align_factor

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

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




    def align_factor(self):

        localctx = AmberMRParser.Align_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_align_factor)
        self._la = 0 # Token type
        try:
            self.state = 408
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AmberMRParser.NDIP, AmberMRParser.DATASET, AmberMRParser.NUM_DATASET]:
                self.enterOuterAlt(localctx, 1)
                self.state = 368
                _la = self._input.LA(1)
                if not(((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (AmberMRParser.NDIP - 96)) | (1 << (AmberMRParser.DATASET - 96)) | (1 << (AmberMRParser.NUM_DATASET - 96)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 369
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 370
                self.match(AmberMRParser.Integer)
                self.state = 372
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 371
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.ID, AmberMRParser.JD]:
                self.enterOuterAlt(localctx, 2)
                self.state = 374
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.ID or _la==AmberMRParser.JD):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 375
                self.match(AmberMRParser.L_paren_IP)
                self.state = 376
                self.match(AmberMRParser.Decimal)
                self.state = 377
                self.match(AmberMRParser.R_paren_A)
                self.state = 378
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 379
                self.match(AmberMRParser.Integer)
                self.state = 381
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 380
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.DOBSL, AmberMRParser.DOBSU]:
                self.enterOuterAlt(localctx, 3)
                self.state = 383
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.DOBSL or _la==AmberMRParser.DOBSU):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 384
                self.match(AmberMRParser.L_paren_RP)
                self.state = 385
                self.match(AmberMRParser.Decimal)
                self.state = 386
                self.match(AmberMRParser.R_paren_A)
                self.state = 387
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 388
                self.match(AmberMRParser.Real)
                self.state = 390
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 389
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.DWT, AmberMRParser.GIGJ]:
                self.enterOuterAlt(localctx, 4)
                self.state = 392
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.DWT or _la==AmberMRParser.GIGJ):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 393
                self.match(AmberMRParser.Equ_op_RA)
                self.state = 394
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Reals or _la==AmberMRParser.MultiplicativeReal):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 395
                self.match(AmberMRParser.Comma_RA)
                pass
            elif token in [AmberMRParser.S11, AmberMRParser.S12, AmberMRParser.S13, AmberMRParser.S22, AmberMRParser.S23, AmberMRParser.DIJ, AmberMRParser.DCUT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 396
                _la = self._input.LA(1)
                if not(((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & ((1 << (AmberMRParser.S11 - 104)) | (1 << (AmberMRParser.S12 - 104)) | (1 << (AmberMRParser.S13 - 104)) | (1 << (AmberMRParser.S22 - 104)) | (1 << (AmberMRParser.S23 - 104)) | (1 << (AmberMRParser.DIJ - 104)) | (1 << (AmberMRParser.DCUT - 104)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 397
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 398
                self.match(AmberMRParser.Real)
                self.state = 400
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 399
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.FREEZEMOL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 402
                self.match(AmberMRParser.FREEZEMOL)
                self.state = 403
                self.match(AmberMRParser.Equ_op)
                self.state = 404
                self.match(AmberMRParser.Logical)
                self.state = 406
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 405
                    self.match(AmberMRParser.Comma)


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

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

        def csa_factor(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Csa_factorContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Csa_factorContext,i)


        def getRuleIndex(self):
            return AmberMRParser.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 = AmberMRParser.Csa_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_csa_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 114)) & ~0x3f) == 0 and ((1 << (_la - 114)) & ((1 << (AmberMRParser.NCSA - 114)) | (1 << (AmberMRParser.ICSA - 114)) | (1 << (AmberMRParser.JCSA - 114)) | (1 << (AmberMRParser.KCSA - 114)) | (1 << (AmberMRParser.COBSL - 114)) | (1 << (AmberMRParser.COBSU - 114)) | (1 << (AmberMRParser.CWT - 114)) | (1 << (AmberMRParser.DATASETC - 114)) | (1 << (AmberMRParser.FIELD - 114)) | (1 << (AmberMRParser.SIGMA11 - 114)) | (1 << (AmberMRParser.SIGMA12 - 114)) | (1 << (AmberMRParser.SIGMA13 - 114)) | (1 << (AmberMRParser.SIGMA22 - 114)) | (1 << (AmberMRParser.SIGMA23 - 114)) | (1 << (AmberMRParser.CCUT - 114)))) != 0):
                self.state = 410
                self.csa_factor()
                self.state = 415
                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 Csa_factorContext(ParserRuleContext):

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

        def Equ_op_IP(self):
            return self.getToken(AmberMRParser.Equ_op_IP, 0)

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

        def NCSA(self):
            return self.getToken(AmberMRParser.NCSA, 0)

        def DATASETC(self):
            return self.getToken(AmberMRParser.DATASETC, 0)

        def Comma(self):
            return self.getToken(AmberMRParser.Comma, 0)

        def L_paren_IP(self):
            return self.getToken(AmberMRParser.L_paren_IP, 0)

        def Decimal(self):
            return self.getToken(AmberMRParser.Decimal, 0)

        def R_paren_A(self):
            return self.getToken(AmberMRParser.R_paren_A, 0)

        def ICSA(self):
            return self.getToken(AmberMRParser.ICSA, 0)

        def JCSA(self):
            return self.getToken(AmberMRParser.JCSA, 0)

        def KCSA(self):
            return self.getToken(AmberMRParser.KCSA, 0)

        def L_paren_RP(self):
            return self.getToken(AmberMRParser.L_paren_RP, 0)

        def Equ_op_RP(self):
            return self.getToken(AmberMRParser.Equ_op_RP, 0)

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

        def COBSL(self):
            return self.getToken(AmberMRParser.COBSL, 0)

        def COBSU(self):
            return self.getToken(AmberMRParser.COBSU, 0)

        def CWT(self):
            return self.getToken(AmberMRParser.CWT, 0)

        def Equ_op_RA(self):
            return self.getToken(AmberMRParser.Equ_op_RA, 0)

        def Comma_RA(self):
            return self.getToken(AmberMRParser.Comma_RA, 0)

        def Reals(self):
            return self.getToken(AmberMRParser.Reals, 0)

        def MultiplicativeReal(self):
            return self.getToken(AmberMRParser.MultiplicativeReal, 0)

        def SIGMA11(self):
            return self.getToken(AmberMRParser.SIGMA11, 0)

        def SIGMA12(self):
            return self.getToken(AmberMRParser.SIGMA12, 0)

        def SIGMA13(self):
            return self.getToken(AmberMRParser.SIGMA13, 0)

        def SIGMA22(self):
            return self.getToken(AmberMRParser.SIGMA22, 0)

        def SIGMA23(self):
            return self.getToken(AmberMRParser.SIGMA23, 0)

        def FIELD(self):
            return self.getToken(AmberMRParser.FIELD, 0)

        def CCUT(self):
            return self.getToken(AmberMRParser.CCUT, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_csa_factor

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

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




    def csa_factor(self):

        localctx = AmberMRParser.Csa_factorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_csa_factor)
        self._la = 0 # Token type
        try:
            self.state = 450
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AmberMRParser.NCSA, AmberMRParser.DATASETC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 416
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.NCSA or _la==AmberMRParser.DATASETC):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 417
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 418
                self.match(AmberMRParser.Integer)
                self.state = 420
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 419
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.ICSA, AmberMRParser.JCSA, AmberMRParser.KCSA]:
                self.enterOuterAlt(localctx, 2)
                self.state = 422
                _la = self._input.LA(1)
                if not(((((_la - 115)) & ~0x3f) == 0 and ((1 << (_la - 115)) & ((1 << (AmberMRParser.ICSA - 115)) | (1 << (AmberMRParser.JCSA - 115)) | (1 << (AmberMRParser.KCSA - 115)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 423
                self.match(AmberMRParser.L_paren_IP)
                self.state = 424
                self.match(AmberMRParser.Decimal)
                self.state = 425
                self.match(AmberMRParser.R_paren_A)
                self.state = 426
                self.match(AmberMRParser.Equ_op_IP)
                self.state = 427
                self.match(AmberMRParser.Integer)
                self.state = 429
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 428
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.COBSL, AmberMRParser.COBSU]:
                self.enterOuterAlt(localctx, 3)
                self.state = 431
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.COBSL or _la==AmberMRParser.COBSU):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 432
                self.match(AmberMRParser.L_paren_RP)
                self.state = 433
                self.match(AmberMRParser.Decimal)
                self.state = 434
                self.match(AmberMRParser.R_paren_A)
                self.state = 435
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 436
                self.match(AmberMRParser.Real)
                self.state = 438
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 437
                    self.match(AmberMRParser.Comma)


                pass
            elif token in [AmberMRParser.CWT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 440
                self.match(AmberMRParser.CWT)
                self.state = 441
                self.match(AmberMRParser.Equ_op_RA)
                self.state = 442
                _la = self._input.LA(1)
                if not(_la==AmberMRParser.Reals or _la==AmberMRParser.MultiplicativeReal):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 443
                self.match(AmberMRParser.Comma_RA)
                pass
            elif token in [AmberMRParser.FIELD, AmberMRParser.SIGMA11, AmberMRParser.SIGMA12, AmberMRParser.SIGMA13, AmberMRParser.SIGMA22, AmberMRParser.SIGMA23, AmberMRParser.CCUT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 444
                _la = self._input.LA(1)
                if not(((((_la - 122)) & ~0x3f) == 0 and ((1 << (_la - 122)) & ((1 << (AmberMRParser.FIELD - 122)) | (1 << (AmberMRParser.SIGMA11 - 122)) | (1 << (AmberMRParser.SIGMA12 - 122)) | (1 << (AmberMRParser.SIGMA13 - 122)) | (1 << (AmberMRParser.SIGMA22 - 122)) | (1 << (AmberMRParser.SIGMA23 - 122)) | (1 << (AmberMRParser.CCUT - 122)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 445
                self.match(AmberMRParser.Equ_op_RP)
                self.state = 446
                self.match(AmberMRParser.Real)
                self.state = 448
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma:
                    self.state = 447
                    self.match(AmberMRParser.Comma)


                pass
            else:
                raise NoViableAltException(self)

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


    class Distance_rst_func_callContext(ParserRuleContext):

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

        def DISTANCE_F(self):
            return self.getToken(AmberMRParser.DISTANCE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def restraint_func_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Restraint_func_exprContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Restraint_func_exprContext,i)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

        def Comma_F(self):
            return self.getToken(AmberMRParser.Comma_F, 0)

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_distance_rst_func_call

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

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




    def distance_rst_func_call(self):

        localctx = AmberMRParser.Distance_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_distance_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 479
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 452
                self.match(AmberMRParser.DISTANCE_F)
                self.state = 453
                self.match(AmberMRParser.L_paren_F)
                self.state = 454
                self.restraint_func_expr()
                self.state = 456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 455
                    self.match(AmberMRParser.Comma_F)


                self.state = 458
                self.restraint_func_expr()
                self.state = 459
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 461
                self.match(AmberMRParser.DISTANCE_F)
                self.state = 462
                self.match(AmberMRParser.L_brace_F)
                self.state = 463
                self.restraint_func_expr()
                self.state = 465
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 464
                    self.match(AmberMRParser.Comma_F)


                self.state = 467
                self.restraint_func_expr()
                self.state = 468
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 470
                self.match(AmberMRParser.DISTANCE_F)
                self.state = 471
                self.match(AmberMRParser.L_brakt_F)
                self.state = 472
                self.restraint_func_expr()
                self.state = 474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 473
                    self.match(AmberMRParser.Comma_F)


                self.state = 476
                self.restraint_func_expr()
                self.state = 477
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Angle_rst_func_callContext(ParserRuleContext):

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

        def ANGLE_F(self):
            return self.getToken(AmberMRParser.ANGLE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def restraint_func_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Restraint_func_exprContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Restraint_func_exprContext,i)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_angle_rst_func_call

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

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




    def angle_rst_func_call(self):

        localctx = AmberMRParser.Angle_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_angle_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 520
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 481
                self.match(AmberMRParser.ANGLE_F)
                self.state = 482
                self.match(AmberMRParser.L_paren_F)
                self.state = 483
                self.restraint_func_expr()
                self.state = 485
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 484
                    self.match(AmberMRParser.Comma_F)


                self.state = 487
                self.restraint_func_expr()
                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 488
                    self.match(AmberMRParser.Comma_F)


                self.state = 491
                self.restraint_func_expr()
                self.state = 492
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 494
                self.match(AmberMRParser.ANGLE_F)
                self.state = 495
                self.match(AmberMRParser.L_brace_F)
                self.state = 496
                self.restraint_func_expr()
                self.state = 498
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 497
                    self.match(AmberMRParser.Comma_F)


                self.state = 500
                self.restraint_func_expr()
                self.state = 502
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 501
                    self.match(AmberMRParser.Comma_F)


                self.state = 504
                self.restraint_func_expr()
                self.state = 505
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 507
                self.match(AmberMRParser.ANGLE_F)
                self.state = 508
                self.match(AmberMRParser.L_brakt_F)
                self.state = 509
                self.restraint_func_expr()
                self.state = 511
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 510
                    self.match(AmberMRParser.Comma_F)


                self.state = 513
                self.restraint_func_expr()
                self.state = 515
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 514
                    self.match(AmberMRParser.Comma_F)


                self.state = 517
                self.restraint_func_expr()
                self.state = 518
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Plane_point_angle_rst_func_callContext(ParserRuleContext):

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

        def ANGLE_F(self):
            return self.getToken(AmberMRParser.ANGLE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def restraint_func_expr(self):
            return self.getTypedRuleContext(AmberMRParser.Restraint_func_exprContext,0)


        def plane_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Plane_rst_func_callContext,0)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

        def Comma_F(self):
            return self.getToken(AmberMRParser.Comma_F, 0)

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_plane_point_angle_rst_func_call

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

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




    def plane_point_angle_rst_func_call(self):

        localctx = AmberMRParser.Plane_point_angle_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_plane_point_angle_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 576
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 522
                self.match(AmberMRParser.ANGLE_F)
                self.state = 523
                self.match(AmberMRParser.L_paren_F)
                self.state = 524
                self.restraint_func_expr()
                self.state = 526
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 525
                    self.match(AmberMRParser.Comma_F)


                self.state = 528
                self.plane_rst_func_call()
                self.state = 529
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 531
                self.match(AmberMRParser.ANGLE_F)
                self.state = 532
                self.match(AmberMRParser.L_brace_F)
                self.state = 533
                self.restraint_func_expr()
                self.state = 535
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 534
                    self.match(AmberMRParser.Comma_F)


                self.state = 537
                self.plane_rst_func_call()
                self.state = 538
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 540
                self.match(AmberMRParser.ANGLE_F)
                self.state = 541
                self.match(AmberMRParser.L_brakt_F)
                self.state = 542
                self.restraint_func_expr()
                self.state = 544
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 543
                    self.match(AmberMRParser.Comma_F)


                self.state = 546
                self.plane_rst_func_call()
                self.state = 547
                self.match(AmberMRParser.R_brakt_F)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 549
                self.match(AmberMRParser.ANGLE_F)
                self.state = 550
                self.match(AmberMRParser.L_paren_F)
                self.state = 551
                self.plane_rst_func_call()
                self.state = 553
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 552
                    self.match(AmberMRParser.Comma_F)


                self.state = 555
                self.restraint_func_expr()
                self.state = 556
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 558
                self.match(AmberMRParser.ANGLE_F)
                self.state = 559
                self.match(AmberMRParser.L_brace_F)
                self.state = 560
                self.plane_rst_func_call()
                self.state = 562
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 561
                    self.match(AmberMRParser.Comma_F)


                self.state = 564
                self.restraint_func_expr()
                self.state = 565
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 567
                self.match(AmberMRParser.ANGLE_F)
                self.state = 568
                self.match(AmberMRParser.L_brakt_F)
                self.state = 569
                self.plane_rst_func_call()
                self.state = 571
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 570
                    self.match(AmberMRParser.Comma_F)


                self.state = 573
                self.restraint_func_expr()
                self.state = 574
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Plane_plane_angle_rst_func_callContext(ParserRuleContext):

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

        def ANGLE_F(self):
            return self.getToken(AmberMRParser.ANGLE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def plane_rst_func_call(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Plane_rst_func_callContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Plane_rst_func_callContext,i)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

        def Comma_F(self):
            return self.getToken(AmberMRParser.Comma_F, 0)

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_plane_plane_angle_rst_func_call

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

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




    def plane_plane_angle_rst_func_call(self):

        localctx = AmberMRParser.Plane_plane_angle_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_plane_plane_angle_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 605
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 578
                self.match(AmberMRParser.ANGLE_F)
                self.state = 579
                self.match(AmberMRParser.L_paren_F)
                self.state = 580
                self.plane_rst_func_call()
                self.state = 582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 581
                    self.match(AmberMRParser.Comma_F)


                self.state = 584
                self.plane_rst_func_call()
                self.state = 585
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 587
                self.match(AmberMRParser.ANGLE_F)
                self.state = 588
                self.match(AmberMRParser.L_brace_F)
                self.state = 589
                self.plane_rst_func_call()
                self.state = 591
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 590
                    self.match(AmberMRParser.Comma_F)


                self.state = 593
                self.plane_rst_func_call()
                self.state = 594
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 596
                self.match(AmberMRParser.ANGLE_F)
                self.state = 597
                self.match(AmberMRParser.L_brakt_F)
                self.state = 598
                self.plane_rst_func_call()
                self.state = 600
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 599
                    self.match(AmberMRParser.Comma_F)


                self.state = 602
                self.plane_rst_func_call()
                self.state = 603
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Torsion_rst_func_callContext(ParserRuleContext):

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

        def TORSION_F(self):
            return self.getToken(AmberMRParser.TORSION_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def restraint_func_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Restraint_func_exprContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Restraint_func_exprContext,i)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_torsion_rst_func_call

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

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




    def torsion_rst_func_call(self):

        localctx = AmberMRParser.Torsion_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_torsion_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 658
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 607
                self.match(AmberMRParser.TORSION_F)
                self.state = 608
                self.match(AmberMRParser.L_paren_F)
                self.state = 609
                self.restraint_func_expr()
                self.state = 611
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 610
                    self.match(AmberMRParser.Comma_F)


                self.state = 613
                self.restraint_func_expr()
                self.state = 615
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 614
                    self.match(AmberMRParser.Comma_F)


                self.state = 617
                self.restraint_func_expr()
                self.state = 619
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 618
                    self.match(AmberMRParser.Comma_F)


                self.state = 621
                self.restraint_func_expr()
                self.state = 622
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 624
                self.match(AmberMRParser.TORSION_F)
                self.state = 625
                self.match(AmberMRParser.L_brace_F)
                self.state = 626
                self.restraint_func_expr()
                self.state = 628
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 627
                    self.match(AmberMRParser.Comma_F)


                self.state = 630
                self.restraint_func_expr()
                self.state = 632
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 631
                    self.match(AmberMRParser.Comma_F)


                self.state = 634
                self.restraint_func_expr()
                self.state = 636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 635
                    self.match(AmberMRParser.Comma_F)


                self.state = 638
                self.restraint_func_expr()
                self.state = 639
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 641
                self.match(AmberMRParser.TORSION_F)
                self.state = 642
                self.match(AmberMRParser.L_brakt_F)
                self.state = 643
                self.restraint_func_expr()
                self.state = 645
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 644
                    self.match(AmberMRParser.Comma_F)


                self.state = 647
                self.restraint_func_expr()
                self.state = 649
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 648
                    self.match(AmberMRParser.Comma_F)


                self.state = 651
                self.restraint_func_expr()
                self.state = 653
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 652
                    self.match(AmberMRParser.Comma_F)


                self.state = 655
                self.restraint_func_expr()
                self.state = 656
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Coordinate2_rst_func_callContext(ParserRuleContext):

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

        def COORDINATE_F(self):
            return self.getToken(AmberMRParser.COORDINATE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def distance_rst_func_call(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Distance_rst_func_callContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Distance_rst_func_callContext,i)


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

        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_coordinate2_rst_func_call

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

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




    def coordinate2_rst_func_call(self):

        localctx = AmberMRParser.Coordinate2_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_coordinate2_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 711
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 660
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 661
                self.match(AmberMRParser.L_paren_F)
                self.state = 662
                self.distance_rst_func_call()
                self.state = 664
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 663
                    self.match(AmberMRParser.Comma_F)


                self.state = 666
                self.match(AmberMRParser.Real_F)
                self.state = 668
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 667
                    self.match(AmberMRParser.Comma_F)


                self.state = 670
                self.distance_rst_func_call()
                self.state = 672
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 671
                    self.match(AmberMRParser.Comma_F)


                self.state = 674
                self.match(AmberMRParser.Real_F)
                self.state = 675
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 677
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 678
                self.match(AmberMRParser.L_brace_F)
                self.state = 679
                self.distance_rst_func_call()
                self.state = 681
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 680
                    self.match(AmberMRParser.Comma_F)


                self.state = 683
                self.match(AmberMRParser.Real_F)
                self.state = 685
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 684
                    self.match(AmberMRParser.Comma_F)


                self.state = 687
                self.distance_rst_func_call()
                self.state = 689
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 688
                    self.match(AmberMRParser.Comma_F)


                self.state = 691
                self.match(AmberMRParser.Real_F)
                self.state = 692
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 694
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 695
                self.match(AmberMRParser.L_brakt_F)
                self.state = 696
                self.distance_rst_func_call()
                self.state = 698
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 697
                    self.match(AmberMRParser.Comma_F)


                self.state = 700
                self.match(AmberMRParser.Real_F)
                self.state = 702
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 701
                    self.match(AmberMRParser.Comma_F)


                self.state = 704
                self.distance_rst_func_call()
                self.state = 706
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 705
                    self.match(AmberMRParser.Comma_F)


                self.state = 708
                self.match(AmberMRParser.Real_F)
                self.state = 709
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Coordinate3_rst_func_callContext(ParserRuleContext):

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

        def COORDINATE_F(self):
            return self.getToken(AmberMRParser.COORDINATE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def distance_rst_func_call(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Distance_rst_func_callContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Distance_rst_func_callContext,i)


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

        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_coordinate3_rst_func_call

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

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




    def coordinate3_rst_func_call(self):

        localctx = AmberMRParser.Coordinate3_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_coordinate3_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 788
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 713
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 714
                self.match(AmberMRParser.L_paren_F)
                self.state = 715
                self.distance_rst_func_call()
                self.state = 717
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 716
                    self.match(AmberMRParser.Comma_F)


                self.state = 719
                self.match(AmberMRParser.Real_F)
                self.state = 721
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 720
                    self.match(AmberMRParser.Comma_F)


                self.state = 723
                self.distance_rst_func_call()
                self.state = 725
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 724
                    self.match(AmberMRParser.Comma_F)


                self.state = 727
                self.match(AmberMRParser.Real_F)
                self.state = 729
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 728
                    self.match(AmberMRParser.Comma_F)


                self.state = 731
                self.distance_rst_func_call()
                self.state = 733
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 732
                    self.match(AmberMRParser.Comma_F)


                self.state = 735
                self.match(AmberMRParser.Real_F)
                self.state = 736
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 738
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 739
                self.match(AmberMRParser.L_brace_F)
                self.state = 740
                self.distance_rst_func_call()
                self.state = 742
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 741
                    self.match(AmberMRParser.Comma_F)


                self.state = 744
                self.match(AmberMRParser.Real_F)
                self.state = 746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 745
                    self.match(AmberMRParser.Comma_F)


                self.state = 748
                self.distance_rst_func_call()
                self.state = 750
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 749
                    self.match(AmberMRParser.Comma_F)


                self.state = 752
                self.match(AmberMRParser.Real_F)
                self.state = 754
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 753
                    self.match(AmberMRParser.Comma_F)


                self.state = 756
                self.distance_rst_func_call()
                self.state = 758
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 757
                    self.match(AmberMRParser.Comma_F)


                self.state = 760
                self.match(AmberMRParser.Real_F)
                self.state = 761
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 763
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 764
                self.match(AmberMRParser.L_brakt_F)
                self.state = 765
                self.distance_rst_func_call()
                self.state = 767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 766
                    self.match(AmberMRParser.Comma_F)


                self.state = 769
                self.match(AmberMRParser.Real_F)
                self.state = 771
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 770
                    self.match(AmberMRParser.Comma_F)


                self.state = 773
                self.distance_rst_func_call()
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 774
                    self.match(AmberMRParser.Comma_F)


                self.state = 777
                self.match(AmberMRParser.Real_F)
                self.state = 779
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 778
                    self.match(AmberMRParser.Comma_F)


                self.state = 781
                self.distance_rst_func_call()
                self.state = 783
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 782
                    self.match(AmberMRParser.Comma_F)


                self.state = 785
                self.match(AmberMRParser.Real_F)
                self.state = 786
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Coordinate4_rst_func_callContext(ParserRuleContext):

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

        def COORDINATE_F(self):
            return self.getToken(AmberMRParser.COORDINATE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def distance_rst_func_call(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Distance_rst_func_callContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Distance_rst_func_callContext,i)


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

        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_coordinate4_rst_func_call

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

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




    def coordinate4_rst_func_call(self):

        localctx = AmberMRParser.Coordinate4_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_coordinate4_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 889
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 790
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 791
                self.match(AmberMRParser.L_paren_F)
                self.state = 792
                self.distance_rst_func_call()
                self.state = 794
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 793
                    self.match(AmberMRParser.Comma_F)


                self.state = 796
                self.match(AmberMRParser.Real_F)
                self.state = 798
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 797
                    self.match(AmberMRParser.Comma_F)


                self.state = 800
                self.distance_rst_func_call()
                self.state = 802
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 801
                    self.match(AmberMRParser.Comma_F)


                self.state = 804
                self.match(AmberMRParser.Real_F)
                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 805
                    self.match(AmberMRParser.Comma_F)


                self.state = 808
                self.distance_rst_func_call()
                self.state = 810
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 809
                    self.match(AmberMRParser.Comma_F)


                self.state = 812
                self.match(AmberMRParser.Real_F)
                self.state = 814
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 813
                    self.match(AmberMRParser.Comma_F)


                self.state = 816
                self.distance_rst_func_call()
                self.state = 818
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 817
                    self.match(AmberMRParser.Comma_F)


                self.state = 820
                self.match(AmberMRParser.Real_F)
                self.state = 821
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 823
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 824
                self.match(AmberMRParser.L_brace_F)
                self.state = 825
                self.distance_rst_func_call()
                self.state = 827
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 826
                    self.match(AmberMRParser.Comma_F)


                self.state = 829
                self.match(AmberMRParser.Real_F)
                self.state = 831
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 830
                    self.match(AmberMRParser.Comma_F)


                self.state = 833
                self.distance_rst_func_call()
                self.state = 835
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 834
                    self.match(AmberMRParser.Comma_F)


                self.state = 837
                self.match(AmberMRParser.Real_F)
                self.state = 839
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 838
                    self.match(AmberMRParser.Comma_F)


                self.state = 841
                self.distance_rst_func_call()
                self.state = 843
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 842
                    self.match(AmberMRParser.Comma_F)


                self.state = 845
                self.match(AmberMRParser.Real_F)
                self.state = 847
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 846
                    self.match(AmberMRParser.Comma_F)


                self.state = 849
                self.distance_rst_func_call()
                self.state = 851
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 850
                    self.match(AmberMRParser.Comma_F)


                self.state = 853
                self.match(AmberMRParser.Real_F)
                self.state = 854
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 856
                self.match(AmberMRParser.COORDINATE_F)
                self.state = 857
                self.match(AmberMRParser.L_brakt_F)
                self.state = 858
                self.distance_rst_func_call()
                self.state = 860
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 859
                    self.match(AmberMRParser.Comma_F)


                self.state = 862
                self.match(AmberMRParser.Real_F)
                self.state = 864
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 863
                    self.match(AmberMRParser.Comma_F)


                self.state = 866
                self.distance_rst_func_call()
                self.state = 868
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 867
                    self.match(AmberMRParser.Comma_F)


                self.state = 870
                self.match(AmberMRParser.Real_F)
                self.state = 872
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 871
                    self.match(AmberMRParser.Comma_F)


                self.state = 874
                self.distance_rst_func_call()
                self.state = 876
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 875
                    self.match(AmberMRParser.Comma_F)


                self.state = 878
                self.match(AmberMRParser.Real_F)
                self.state = 880
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 879
                    self.match(AmberMRParser.Comma_F)


                self.state = 882
                self.distance_rst_func_call()
                self.state = 884
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 883
                    self.match(AmberMRParser.Comma_F)


                self.state = 886
                self.match(AmberMRParser.Real_F)
                self.state = 887
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Restraint_func_exprContext(ParserRuleContext):

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

        def Integer_F(self):
            return self.getToken(AmberMRParser.Integer_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def Ambmask_F(self):
            return self.getToken(AmberMRParser.Ambmask_F, 0)

        def com_rst_func_call(self):
            return self.getTypedRuleContext(AmberMRParser.Com_rst_func_callContext,0)


        def getRuleIndex(self):
            return AmberMRParser.RULE_restraint_func_expr

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

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




    def restraint_func_expr(self):

        localctx = AmberMRParser.Restraint_func_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_restraint_func_expr)
        try:
            self.state = 912
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,125,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 891
                self.match(AmberMRParser.Integer_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 892
                self.match(AmberMRParser.L_paren_F)
                self.state = 893
                self.match(AmberMRParser.Integer_F)
                self.state = 894
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 895
                self.match(AmberMRParser.L_brace_F)
                self.state = 896
                self.match(AmberMRParser.Integer_F)
                self.state = 897
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 898
                self.match(AmberMRParser.L_brakt_F)
                self.state = 899
                self.match(AmberMRParser.Integer_F)
                self.state = 900
                self.match(AmberMRParser.R_brakt_F)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 901
                self.match(AmberMRParser.Ambmask_F)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 902
                self.match(AmberMRParser.L_paren_F)
                self.state = 903
                self.match(AmberMRParser.Ambmask_F)
                self.state = 904
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 905
                self.match(AmberMRParser.L_brace_F)
                self.state = 906
                self.match(AmberMRParser.Ambmask_F)
                self.state = 907
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 908
                self.match(AmberMRParser.L_brakt_F)
                self.state = 909
                self.match(AmberMRParser.Ambmask_F)
                self.state = 910
                self.match(AmberMRParser.R_brakt_F)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 911
                self.com_rst_func_call()
                pass


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


    class Plane_rst_func_callContext(ParserRuleContext):

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

        def PLANE_F(self):
            return self.getToken(AmberMRParser.PLANE_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def restraint_func_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Restraint_func_exprContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Restraint_func_exprContext,i)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_plane_rst_func_call

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

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




    def plane_rst_func_call(self):

        localctx = AmberMRParser.Plane_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_plane_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 965
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 914
                self.match(AmberMRParser.PLANE_F)
                self.state = 915
                self.match(AmberMRParser.L_paren_F)
                self.state = 916
                self.restraint_func_expr()
                self.state = 918
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 917
                    self.match(AmberMRParser.Comma_F)


                self.state = 920
                self.restraint_func_expr()
                self.state = 922
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 921
                    self.match(AmberMRParser.Comma_F)


                self.state = 924
                self.restraint_func_expr()
                self.state = 926
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 925
                    self.match(AmberMRParser.Comma_F)


                self.state = 928
                self.restraint_func_expr()
                self.state = 929
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 931
                self.match(AmberMRParser.PLANE_F)
                self.state = 932
                self.match(AmberMRParser.L_brace_F)
                self.state = 933
                self.restraint_func_expr()
                self.state = 935
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 934
                    self.match(AmberMRParser.Comma_F)


                self.state = 937
                self.restraint_func_expr()
                self.state = 939
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 938
                    self.match(AmberMRParser.Comma_F)


                self.state = 941
                self.restraint_func_expr()
                self.state = 943
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 942
                    self.match(AmberMRParser.Comma_F)


                self.state = 945
                self.restraint_func_expr()
                self.state = 946
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 948
                self.match(AmberMRParser.PLANE_F)
                self.state = 949
                self.match(AmberMRParser.L_brakt_F)
                self.state = 950
                self.restraint_func_expr()
                self.state = 952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 951
                    self.match(AmberMRParser.Comma_F)


                self.state = 954
                self.restraint_func_expr()
                self.state = 956
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 955
                    self.match(AmberMRParser.Comma_F)


                self.state = 958
                self.restraint_func_expr()
                self.state = 960
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==AmberMRParser.Comma_F:
                    self.state = 959
                    self.match(AmberMRParser.Comma_F)


                self.state = 962
                self.restraint_func_expr()
                self.state = 963
                self.match(AmberMRParser.R_brakt_F)
                pass


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


    class Com_rst_func_callContext(ParserRuleContext):

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

        def COM_F(self):
            return self.getToken(AmberMRParser.COM_F, 0)

        def L_paren_F(self):
            return self.getToken(AmberMRParser.L_paren_F, 0)

        def restraint_func_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberMRParser.Restraint_func_exprContext)
            else:
                return self.getTypedRuleContext(AmberMRParser.Restraint_func_exprContext,i)


        def R_paren_F(self):
            return self.getToken(AmberMRParser.R_paren_F, 0)

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

        def L_brace_F(self):
            return self.getToken(AmberMRParser.L_brace_F, 0)

        def R_brace_F(self):
            return self.getToken(AmberMRParser.R_brace_F, 0)

        def L_brakt_F(self):
            return self.getToken(AmberMRParser.L_brakt_F, 0)

        def R_brakt_F(self):
            return self.getToken(AmberMRParser.R_brakt_F, 0)

        def getRuleIndex(self):
            return AmberMRParser.RULE_com_rst_func_call

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

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




    def com_rst_func_call(self):

        localctx = AmberMRParser.Com_rst_func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_com_rst_func_call)
        self._la = 0 # Token type
        try:
            self.state = 1009
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 967
                self.match(AmberMRParser.COM_F)
                self.state = 968
                self.match(AmberMRParser.L_paren_F)
                self.state = 969
                self.restraint_func_expr()
                self.state = 976
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 190)) & ~0x3f) == 0 and ((1 << (_la - 190)) & ((1 << (AmberMRParser.COM_F - 190)) | (1 << (AmberMRParser.Integer_F - 190)) | (1 << (AmberMRParser.Ambmask_F - 190)) | (1 << (AmberMRParser.Comma_F - 190)) | (1 << (AmberMRParser.L_paren_F - 190)) | (1 << (AmberMRParser.L_brace_F - 190)) | (1 << (AmberMRParser.L_brakt_F - 190)))) != 0):
                    self.state = 971
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==AmberMRParser.Comma_F:
                        self.state = 970
                        self.match(AmberMRParser.Comma_F)


                    self.state = 973
                    self.restraint_func_expr()
                    self.state = 978
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 979
                self.match(AmberMRParser.R_paren_F)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 981
                self.match(AmberMRParser.COM_F)
                self.state = 982
                self.match(AmberMRParser.L_brace_F)
                self.state = 983
                self.restraint_func_expr()
                self.state = 990
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 190)) & ~0x3f) == 0 and ((1 << (_la - 190)) & ((1 << (AmberMRParser.COM_F - 190)) | (1 << (AmberMRParser.Integer_F - 190)) | (1 << (AmberMRParser.Ambmask_F - 190)) | (1 << (AmberMRParser.Comma_F - 190)) | (1 << (AmberMRParser.L_paren_F - 190)) | (1 << (AmberMRParser.L_brace_F - 190)) | (1 << (AmberMRParser.L_brakt_F - 190)))) != 0):
                    self.state = 985
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==AmberMRParser.Comma_F:
                        self.state = 984
                        self.match(AmberMRParser.Comma_F)


                    self.state = 987
                    self.restraint_func_expr()
                    self.state = 992
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 993
                self.match(AmberMRParser.R_brace_F)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 995
                self.match(AmberMRParser.COM_F)
                self.state = 996
                self.match(AmberMRParser.L_brakt_F)
                self.state = 997
                self.restraint_func_expr()
                self.state = 1004
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 190)) & ~0x3f) == 0 and ((1 << (_la - 190)) & ((1 << (AmberMRParser.COM_F - 190)) | (1 << (AmberMRParser.Integer_F - 190)) | (1 << (AmberMRParser.Ambmask_F - 190)) | (1 << (AmberMRParser.Comma_F - 190)) | (1 << (AmberMRParser.L_paren_F - 190)) | (1 << (AmberMRParser.L_brace_F - 190)) | (1 << (AmberMRParser.L_brakt_F - 190)))) != 0):
                    self.state = 999
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==AmberMRParser.Comma_F:
                        self.state = 998
                        self.match(AmberMRParser.Comma_F)


                    self.state = 1001
                    self.restraint_func_expr()
                    self.state = 1006
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1007
                self.match(AmberMRParser.R_brakt_F)
                pass


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





