# Generated from AmberPTParser.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\3J")
        buf.write("\u0283\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\3\2\3\2\5")
        buf.write("\2i\n\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3")
        buf.write("\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2")
        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3")
        buf.write("\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2\u009a\n\2\f\2\16")
        buf.write("\2\u009d\13\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00a7")
        buf.write("\n\3\3\3\3\3\3\4\3\4\3\4\7\4\u00ae\n\4\f\4\16\4\u00b1")
        buf.write("\13\4\3\4\3\4\3\5\3\5\3\5\7\5\u00b8\n\5\f\5\16\5\u00bb")
        buf.write("\13\5\3\5\3\5\3\6\3\6\3\6\7\6\u00c2\n\6\f\6\16\6\u00c5")
        buf.write("\13\6\3\6\3\6\3\7\3\7\3\7\7\7\u00cc\n\7\f\7\16\7\u00cf")
        buf.write("\13\7\3\7\3\7\3\b\3\b\3\b\7\b\u00d6\n\b\f\b\16\b\u00d9")
        buf.write("\13\b\3\b\3\b\3\t\3\t\3\t\7\t\u00e0\n\t\f\t\16\t\u00e3")
        buf.write("\13\t\3\t\3\t\3\n\3\n\3\n\7\n\u00ea\n\n\f\n\16\n\u00ed")
        buf.write("\13\n\3\n\3\n\3\13\3\13\3\13\7\13\u00f4\n\13\f\13\16\13")
        buf.write("\u00f7\13\13\3\13\3\13\3\f\3\f\3\f\7\f\u00fe\n\f\f\f\16")
        buf.write("\f\u0101\13\f\3\f\3\f\3\r\3\r\3\r\7\r\u0108\n\r\f\r\16")
        buf.write("\r\u010b\13\r\3\r\3\r\3\16\3\16\3\16\7\16\u0112\n\16\f")
        buf.write("\16\16\16\u0115\13\16\3\16\3\16\3\17\3\17\3\17\7\17\u011c")
        buf.write("\n\17\f\17\16\17\u011f\13\17\3\17\3\17\3\20\3\20\3\20")
        buf.write("\7\20\u0126\n\20\f\20\16\20\u0129\13\20\3\20\3\20\3\21")
        buf.write("\3\21\3\21\7\21\u0130\n\21\f\21\16\21\u0133\13\21\3\21")
        buf.write("\3\21\3\22\3\22\3\22\7\22\u013a\n\22\f\22\16\22\u013d")
        buf.write("\13\22\3\22\3\22\3\23\3\23\3\23\7\23\u0144\n\23\f\23\16")
        buf.write("\23\u0147\13\23\3\23\3\23\3\24\3\24\3\24\7\24\u014e\n")
        buf.write("\24\f\24\16\24\u0151\13\24\3\24\3\24\3\25\3\25\3\25\7")
        buf.write("\25\u0158\n\25\f\25\16\25\u015b\13\25\3\25\3\25\3\26\3")
        buf.write("\26\3\26\7\26\u0162\n\26\f\26\16\26\u0165\13\26\3\26\3")
        buf.write("\26\3\27\3\27\3\27\7\27\u016c\n\27\f\27\16\27\u016f\13")
        buf.write("\27\3\27\3\27\3\30\3\30\3\30\7\30\u0176\n\30\f\30\16\30")
        buf.write("\u0179\13\30\3\30\3\30\3\31\3\31\3\31\7\31\u0180\n\31")
        buf.write("\f\31\16\31\u0183\13\31\3\31\3\31\3\32\3\32\3\32\7\32")
        buf.write("\u018a\n\32\f\32\16\32\u018d\13\32\3\32\3\32\3\33\3\33")
        buf.write("\3\33\7\33\u0194\n\33\f\33\16\33\u0197\13\33\3\33\3\33")
        buf.write("\3\34\3\34\3\34\7\34\u019e\n\34\f\34\16\34\u01a1\13\34")
        buf.write("\3\34\3\34\3\35\3\35\3\35\7\35\u01a8\n\35\f\35\16\35\u01ab")
        buf.write("\13\35\3\35\3\35\3\36\3\36\3\36\7\36\u01b2\n\36\f\36\16")
        buf.write("\36\u01b5\13\36\3\36\3\36\3\37\3\37\3\37\7\37\u01bc\n")
        buf.write("\37\f\37\16\37\u01bf\13\37\3\37\3\37\3 \3 \3 \7 \u01c6")
        buf.write("\n \f \16 \u01c9\13 \3 \3 \3!\3!\3!\7!\u01d0\n!\f!\16")
        buf.write("!\u01d3\13!\3!\3!\3\"\3\"\3\"\7\"\u01da\n\"\f\"\16\"\u01dd")
        buf.write("\13\"\3\"\3\"\3#\3#\3#\7#\u01e4\n#\f#\16#\u01e7\13#\3")
        buf.write("#\3#\3$\3$\3$\7$\u01ee\n$\f$\16$\u01f1\13$\3$\3$\3%\3")
        buf.write("%\3%\7%\u01f8\n%\f%\16%\u01fb\13%\3%\3%\3&\3&\3&\7&\u0202")
        buf.write("\n&\f&\16&\u0205\13&\3&\3&\3\'\3\'\3\'\7\'\u020c\n\'\f")
        buf.write("\'\16\'\u020f\13\'\3\'\3\'\3(\3(\3(\7(\u0216\n(\f(\16")
        buf.write("(\u0219\13(\3(\3(\3)\3)\3)\7)\u0220\n)\f)\16)\u0223\13")
        buf.write(")\3)\3)\3*\3*\3*\7*\u022a\n*\f*\16*\u022d\13*\3*\3*\3")
        buf.write("+\3+\3+\6+\u0234\n+\r+\16+\u0235\3+\3+\3,\3,\3,\7,\u023d")
        buf.write("\n,\f,\16,\u0240\13,\3,\3,\3-\3-\3-\7-\u0247\n-\f-\16")
        buf.write("-\u024a\13-\3-\3-\3.\3.\3.\7.\u0251\n.\f.\16.\u0254\13")
        buf.write(".\3.\3.\3/\3/\3/\7/\u025b\n/\f/\16/\u025e\13/\3/\3/\3")
        buf.write("\60\3\60\3\60\7\60\u0265\n\60\f\60\16\60\u0268\13\60\3")
        buf.write("\60\3\60\3\61\3\61\3\61\7\61\u026f\n\61\f\61\16\61\u0272")
        buf.write("\13\61\3\61\3\61\3\62\3\62\3\62\7\62\u0279\n\62\f\62\16")
        buf.write("\62\u027c\13\62\3\62\3\62\3\63\3\63\3\63\3\63\2\2\64\2")
        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
        buf.write("\668:<>@BDFHJLNPRTVXZ\\^`bd\2\7\3\3>>\3\3DD\3\3JJ\3\3")
        buf.write("GG\3\2?A\2\u02b0\2h\3\2\2\2\4\u009e\3\2\2\2\6\u00aa\3")
        buf.write("\2\2\2\b\u00b4\3\2\2\2\n\u00be\3\2\2\2\f\u00c8\3\2\2\2")
        buf.write("\16\u00d2\3\2\2\2\20\u00dc\3\2\2\2\22\u00e6\3\2\2\2\24")
        buf.write("\u00f0\3\2\2\2\26\u00fa\3\2\2\2\30\u0104\3\2\2\2\32\u010e")
        buf.write("\3\2\2\2\34\u0118\3\2\2\2\36\u0122\3\2\2\2 \u012c\3\2")
        buf.write("\2\2\"\u0136\3\2\2\2$\u0140\3\2\2\2&\u014a\3\2\2\2(\u0154")
        buf.write("\3\2\2\2*\u015e\3\2\2\2,\u0168\3\2\2\2.\u0172\3\2\2\2")
        buf.write("\60\u017c\3\2\2\2\62\u0186\3\2\2\2\64\u0190\3\2\2\2\66")
        buf.write("\u019a\3\2\2\28\u01a4\3\2\2\2:\u01ae\3\2\2\2<\u01b8\3")
        buf.write("\2\2\2>\u01c2\3\2\2\2@\u01cc\3\2\2\2B\u01d6\3\2\2\2D\u01e0")
        buf.write("\3\2\2\2F\u01ea\3\2\2\2H\u01f4\3\2\2\2J\u01fe\3\2\2\2")
        buf.write("L\u0208\3\2\2\2N\u0212\3\2\2\2P\u021c\3\2\2\2R\u0226\3")
        buf.write("\2\2\2T\u0230\3\2\2\2V\u0239\3\2\2\2X\u0243\3\2\2\2Z\u024d")
        buf.write("\3\2\2\2\\\u0257\3\2\2\2^\u0261\3\2\2\2`\u026b\3\2\2\2")
        buf.write("b\u0275\3\2\2\2d\u027f\3\2\2\2fi\5\4\3\2gi\7\4\2\2hf\3")
        buf.write("\2\2\2hg\3\2\2\2i\u009b\3\2\2\2j\u009a\5\6\4\2k\u009a")
        buf.write("\5\b\5\2l\u009a\5\n\6\2m\u009a\5\f\7\2n\u009a\5\16\b\2")
        buf.write("o\u009a\5\20\t\2p\u009a\5\22\n\2q\u009a\5\24\13\2r\u009a")
        buf.write("\5\26\f\2s\u009a\5\30\r\2t\u009a\5\32\16\2u\u009a\5\34")
        buf.write("\17\2v\u009a\5\36\20\2w\u009a\5 \21\2x\u009a\5\"\22\2")
        buf.write("y\u009a\5$\23\2z\u009a\5&\24\2{\u009a\5(\25\2|\u009a\5")
        buf.write("*\26\2}\u009a\5,\27\2~\u009a\5.\30\2\177\u009a\5\60\31")
        buf.write("\2\u0080\u009a\5\62\32\2\u0081\u009a\5\64\33\2\u0082\u009a")
        buf.write("\5\66\34\2\u0083\u009a\58\35\2\u0084\u009a\5:\36\2\u0085")
        buf.write("\u009a\5<\37\2\u0086\u009a\5> \2\u0087\u009a\5@!\2\u0088")
        buf.write("\u009a\5B\"\2\u0089\u009a\5D#\2\u008a\u009a\5F$\2\u008b")
        buf.write("\u009a\5H%\2\u008c\u009a\5J&\2\u008d\u009a\5L\'\2\u008e")
        buf.write("\u009a\5N(\2\u008f\u009a\5P)\2\u0090\u009a\5R*\2\u0091")
        buf.write("\u009a\5T+\2\u0092\u009a\5V,\2\u0093\u009a\5X-\2\u0094")
        buf.write("\u009a\5Z.\2\u0095\u009a\5\\/\2\u0096\u009a\5^\60\2\u0097")
        buf.write("\u009a\5`\61\2\u0098\u009a\5b\62\2\u0099j\3\2\2\2\u0099")
        buf.write("k\3\2\2\2\u0099l\3\2\2\2\u0099m\3\2\2\2\u0099n\3\2\2\2")
        buf.write("\u0099o\3\2\2\2\u0099p\3\2\2\2\u0099q\3\2\2\2\u0099r\3")
        buf.write("\2\2\2\u0099s\3\2\2\2\u0099t\3\2\2\2\u0099u\3\2\2\2\u0099")
        buf.write("v\3\2\2\2\u0099w\3\2\2\2\u0099x\3\2\2\2\u0099y\3\2\2\2")
        buf.write("\u0099z\3\2\2\2\u0099{\3\2\2\2\u0099|\3\2\2\2\u0099}\3")
        buf.write("\2\2\2\u0099~\3\2\2\2\u0099\177\3\2\2\2\u0099\u0080\3")
        buf.write("\2\2\2\u0099\u0081\3\2\2\2\u0099\u0082\3\2\2\2\u0099\u0083")
        buf.write("\3\2\2\2\u0099\u0084\3\2\2\2\u0099\u0085\3\2\2\2\u0099")
        buf.write("\u0086\3\2\2\2\u0099\u0087\3\2\2\2\u0099\u0088\3\2\2\2")
        buf.write("\u0099\u0089\3\2\2\2\u0099\u008a\3\2\2\2\u0099\u008b\3")
        buf.write("\2\2\2\u0099\u008c\3\2\2\2\u0099\u008d\3\2\2\2\u0099\u008e")
        buf.write("\3\2\2\2\u0099\u008f\3\2\2\2\u0099\u0090\3\2\2\2\u0099")
        buf.write("\u0091\3\2\2\2\u0099\u0092\3\2\2\2\u0099\u0093\3\2\2\2")
        buf.write("\u0099\u0094\3\2\2\2\u0099\u0095\3\2\2\2\u0099\u0096\3")
        buf.write("\2\2\2\u0099\u0097\3\2\2\2\u0099\u0098\3\2\2\2\u009a\u009d")
        buf.write("\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c")
        buf.write("\3\3\2\2\2\u009d\u009b\3\2\2\2\u009e\u009f\7\3\2\2\u009f")
        buf.write("\u00a0\78\2\2\u00a0\u00a1\7:\2\2\u00a1\u00a2\7;\2\2\u00a2")
        buf.write("\u00a3\79\2\2\u00a3\u00a4\7:\2\2\u00a4\u00a6\7<\2\2\u00a5")
        buf.write("\u00a7\7<\2\2\u00a6\u00a5\3\2\2\2\u00a6\u00a7\3\2\2\2")
        buf.write("\u00a7\u00a8\3\2\2\2\u00a8\u00a9\t\2\2\2\u00a9\5\3\2\2")
        buf.write("\2\u00aa\u00ab\7\5\2\2\u00ab\u00af\5d\63\2\u00ac\u00ae")
        buf.write("\7B\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af")
        buf.write("\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b2\3\2\2\2")
        buf.write("\u00b1\u00af\3\2\2\2\u00b2\u00b3\t\3\2\2\u00b3\7\3\2\2")
        buf.write("\2\u00b4\u00b5\7\6\2\2\u00b5\u00b9\5d\63\2\u00b6\u00b8")
        buf.write("\7H\2\2\u00b7\u00b6\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9")
        buf.write("\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bc\3\2\2\2")
        buf.write("\u00bb\u00b9\3\2\2\2\u00bc\u00bd\t\4\2\2\u00bd\t\3\2\2")
        buf.write("\2\u00be\u00bf\7\7\2\2\u00bf\u00c3\5d\63\2\u00c0\u00c2")
        buf.write("\7H\2\2\u00c1\u00c0\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3")
        buf.write("\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c6\3\2\2\2")
        buf.write("\u00c5\u00c3\3\2\2\2\u00c6\u00c7\t\4\2\2\u00c7\13\3\2")
        buf.write("\2\2\u00c8\u00c9\7\b\2\2\u00c9\u00cd\5d\63\2\u00ca\u00cc")
        buf.write("\7E\2\2\u00cb\u00ca\3\2\2\2\u00cc\u00cf\3\2\2\2\u00cd")
        buf.write("\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d0\3\2\2\2")
        buf.write("\u00cf\u00cd\3\2\2\2\u00d0\u00d1\t\5\2\2\u00d1\r\3\2\2")
        buf.write("\2\u00d2\u00d3\7\t\2\2\u00d3\u00d7\5d\63\2\u00d4\u00d6")
        buf.write("\7E\2\2\u00d5\u00d4\3\2\2\2\u00d6\u00d9\3\2\2\2\u00d7")
        buf.write("\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\u00da\3\2\2\2")
        buf.write("\u00d9\u00d7\3\2\2\2\u00da\u00db\t\5\2\2\u00db\17\3\2")
        buf.write("\2\2\u00dc\u00dd\7\n\2\2\u00dd\u00e1\5d\63\2\u00de\u00e0")
        buf.write("\7E\2\2\u00df\u00de\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1")
        buf.write("\u00df\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2\u00e4\3\2\2\2")
        buf.write("\u00e3\u00e1\3\2\2\2\u00e4\u00e5\t\5\2\2\u00e5\21\3\2")
        buf.write("\2\2\u00e6\u00e7\7\13\2\2\u00e7\u00eb\5d\63\2\u00e8\u00ea")
        buf.write("\7B\2\2\u00e9\u00e8\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb")
        buf.write("\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ee\3\2\2\2")
        buf.write("\u00ed\u00eb\3\2\2\2\u00ee\u00ef\t\3\2\2\u00ef\23\3\2")
        buf.write("\2\2\u00f0\u00f1\7\f\2\2\u00f1\u00f5\5d\63\2\u00f2\u00f4")
        buf.write("\7E\2\2\u00f3\u00f2\3\2\2\2\u00f4\u00f7\3\2\2\2\u00f5")
        buf.write("\u00f3\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f8\3\2\2\2")
        buf.write("\u00f7\u00f5\3\2\2\2\u00f8\u00f9\t\5\2\2\u00f9\25\3\2")
        buf.write("\2\2\u00fa\u00fb\7\r\2\2\u00fb\u00ff\5d\63\2\u00fc\u00fe")
        buf.write("\7E\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0101\3\2\2\2\u00ff")
        buf.write("\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0102\3\2\2\2")
        buf.write("\u0101\u00ff\3\2\2\2\u0102\u0103\t\5\2\2\u0103\27\3\2")
        buf.write("\2\2\u0104\u0105\7\16\2\2\u0105\u0109\5d\63\2\u0106\u0108")
        buf.write("\7H\2\2\u0107\u0106\3\2\2\2\u0108\u010b\3\2\2\2\u0109")
        buf.write("\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u010c\3\2\2\2")
        buf.write("\u010b\u0109\3\2\2\2\u010c\u010d\t\4\2\2\u010d\31\3\2")
        buf.write("\2\2\u010e\u010f\7\17\2\2\u010f\u0113\5d\63\2\u0110\u0112")
        buf.write("\7H\2\2\u0111\u0110\3\2\2\2\u0112\u0115\3\2\2\2\u0113")
        buf.write("\u0111\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0116\3\2\2\2")
        buf.write("\u0115\u0113\3\2\2\2\u0116\u0117\t\4\2\2\u0117\33\3\2")
        buf.write("\2\2\u0118\u0119\7\20\2\2\u0119\u011d\5d\63\2\u011a\u011c")
        buf.write("\7E\2\2\u011b\u011a\3\2\2\2\u011c\u011f\3\2\2\2\u011d")
        buf.write("\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u0120\3\2\2\2")
        buf.write("\u011f\u011d\3\2\2\2\u0120\u0121\t\5\2\2\u0121\35\3\2")
        buf.write("\2\2\u0122\u0123\7\21\2\2\u0123\u0127\5d\63\2\u0124\u0126")
        buf.write("\7E\2\2\u0125\u0124\3\2\2\2\u0126\u0129\3\2\2\2\u0127")
        buf.write("\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2")
        buf.write("\u0129\u0127\3\2\2\2\u012a\u012b\t\5\2\2\u012b\37\3\2")
        buf.write("\2\2\u012c\u012d\7\22\2\2\u012d\u0131\5d\63\2\u012e\u0130")
        buf.write("\7H\2\2\u012f\u012e\3\2\2\2\u0130\u0133\3\2\2\2\u0131")
        buf.write("\u012f\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0134\3\2\2\2")
        buf.write("\u0133\u0131\3\2\2\2\u0134\u0135\t\4\2\2\u0135!\3\2\2")
        buf.write("\2\u0136\u0137\7\23\2\2\u0137\u013b\5d\63\2\u0138\u013a")
        buf.write("\7E\2\2\u0139\u0138\3\2\2\2\u013a\u013d\3\2\2\2\u013b")
        buf.write("\u0139\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013e\3\2\2\2")
        buf.write("\u013d\u013b\3\2\2\2\u013e\u013f\t\5\2\2\u013f#\3\2\2")
        buf.write("\2\u0140\u0141\7\24\2\2\u0141\u0145\5d\63\2\u0142\u0144")
        buf.write("\7H\2\2\u0143\u0142\3\2\2\2\u0144\u0147\3\2\2\2\u0145")
        buf.write("\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0148\3\2\2\2")
        buf.write("\u0147\u0145\3\2\2\2\u0148\u0149\t\4\2\2\u0149%\3\2\2")
        buf.write("\2\u014a\u014b\7\25\2\2\u014b\u014f\5d\63\2\u014c\u014e")
        buf.write("\7H\2\2\u014d\u014c\3\2\2\2\u014e\u0151\3\2\2\2\u014f")
        buf.write("\u014d\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152\3\2\2\2")
        buf.write("\u0151\u014f\3\2\2\2\u0152\u0153\t\4\2\2\u0153\'\3\2\2")
        buf.write("\2\u0154\u0155\7\26\2\2\u0155\u0159\5d\63\2\u0156\u0158")
        buf.write("\7H\2\2\u0157\u0156\3\2\2\2\u0158\u015b\3\2\2\2\u0159")
        buf.write("\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015c\3\2\2\2")
        buf.write("\u015b\u0159\3\2\2\2\u015c\u015d\t\4\2\2\u015d)\3\2\2")
        buf.write("\2\u015e\u015f\7\27\2\2\u015f\u0163\5d\63\2\u0160\u0162")
        buf.write("\7H\2\2\u0161\u0160\3\2\2\2\u0162\u0165\3\2\2\2\u0163")
        buf.write("\u0161\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0166\3\2\2\2")
        buf.write("\u0165\u0163\3\2\2\2\u0166\u0167\t\4\2\2\u0167+\3\2\2")
        buf.write("\2\u0168\u0169\7\30\2\2\u0169\u016d\5d\63\2\u016a\u016c")
        buf.write("\7H\2\2\u016b\u016a\3\2\2\2\u016c\u016f\3\2\2\2\u016d")
        buf.write("\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0170\3\2\2\2")
        buf.write("\u016f\u016d\3\2\2\2\u0170\u0171\t\4\2\2\u0171-\3\2\2")
        buf.write("\2\u0172\u0173\7\31\2\2\u0173\u0177\5d\63\2\u0174\u0176")
        buf.write("\7E\2\2\u0175\u0174\3\2\2\2\u0176\u0179\3\2\2\2\u0177")
        buf.write("\u0175\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u017a\3\2\2\2")
        buf.write("\u0179\u0177\3\2\2\2\u017a\u017b\t\5\2\2\u017b/\3\2\2")
        buf.write("\2\u017c\u017d\7\32\2\2\u017d\u0181\5d\63\2\u017e\u0180")
        buf.write("\7E\2\2\u017f\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181")
        buf.write("\u017f\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0184\3\2\2\2")
        buf.write("\u0183\u0181\3\2\2\2\u0184\u0185\t\5\2\2\u0185\61\3\2")
        buf.write("\2\2\u0186\u0187\7\33\2\2\u0187\u018b\5d\63\2\u0188\u018a")
        buf.write("\7E\2\2\u0189\u0188\3\2\2\2\u018a\u018d\3\2\2\2\u018b")
        buf.write("\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018e\3\2\2\2")
        buf.write("\u018d\u018b\3\2\2\2\u018e\u018f\t\5\2\2\u018f\63\3\2")
        buf.write("\2\2\u0190\u0191\7\34\2\2\u0191\u0195\5d\63\2\u0192\u0194")
        buf.write("\7H\2\2\u0193\u0192\3\2\2\2\u0194\u0197\3\2\2\2\u0195")
        buf.write("\u0193\3\2\2\2\u0195\u0196\3\2\2\2\u0196\u0198\3\2\2\2")
        buf.write("\u0197\u0195\3\2\2\2\u0198\u0199\t\4\2\2\u0199\65\3\2")
        buf.write("\2\2\u019a\u019b\7\35\2\2\u019b\u019f\5d\63\2\u019c\u019e")
        buf.write("\7H\2\2\u019d\u019c\3\2\2\2\u019e\u01a1\3\2\2\2\u019f")
        buf.write("\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2\2")
        buf.write("\u01a1\u019f\3\2\2\2\u01a2\u01a3\t\4\2\2\u01a3\67\3\2")
        buf.write("\2\2\u01a4\u01a5\7\36\2\2\u01a5\u01a9\5d\63\2\u01a6\u01a8")
        buf.write("\7H\2\2\u01a7\u01a6\3\2\2\2\u01a8\u01ab\3\2\2\2\u01a9")
        buf.write("\u01a7\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ac\3\2\2\2")
        buf.write("\u01ab\u01a9\3\2\2\2\u01ac\u01ad\t\4\2\2\u01ad9\3\2\2")
        buf.write("\2\u01ae\u01af\7\37\2\2\u01af\u01b3\5d\63\2\u01b0\u01b2")
        buf.write("\7E\2\2\u01b1\u01b0\3\2\2\2\u01b2\u01b5\3\2\2\2\u01b3")
        buf.write("\u01b1\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b6\3\2\2\2")
        buf.write("\u01b5\u01b3\3\2\2\2\u01b6\u01b7\t\5\2\2\u01b7;\3\2\2")
        buf.write("\2\u01b8\u01b9\7 \2\2\u01b9\u01bd\5d\63\2\u01ba\u01bc")
        buf.write("\7E\2\2\u01bb\u01ba\3\2\2\2\u01bc\u01bf\3\2\2\2\u01bd")
        buf.write("\u01bb\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01c0\3\2\2\2")
        buf.write("\u01bf\u01bd\3\2\2\2\u01c0\u01c1\t\5\2\2\u01c1=\3\2\2")
        buf.write("\2\u01c2\u01c3\7!\2\2\u01c3\u01c7\5d\63\2\u01c4\u01c6")
        buf.write("\7E\2\2\u01c5\u01c4\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7")
        buf.write("\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01ca\3\2\2\2")
        buf.write("\u01c9\u01c7\3\2\2\2\u01ca\u01cb\t\5\2\2\u01cb?\3\2\2")
        buf.write("\2\u01cc\u01cd\7\"\2\2\u01cd\u01d1\5d\63\2\u01ce\u01d0")
        buf.write("\7H\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1")
        buf.write("\u01cf\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2")
        buf.write("\u01d3\u01d1\3\2\2\2\u01d4\u01d5\t\4\2\2\u01d5A\3\2\2")
        buf.write("\2\u01d6\u01d7\7#\2\2\u01d7\u01db\5d\63\2\u01d8\u01da")
        buf.write("\7H\2\2\u01d9\u01d8\3\2\2\2\u01da\u01dd\3\2\2\2\u01db")
        buf.write("\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2\2\2")
        buf.write("\u01dd\u01db\3\2\2\2\u01de\u01df\t\4\2\2\u01dfC\3\2\2")
        buf.write("\2\u01e0\u01e1\7$\2\2\u01e1\u01e5\5d\63\2\u01e2\u01e4")
        buf.write("\7H\2\2\u01e3\u01e2\3\2\2\2\u01e4\u01e7\3\2\2\2\u01e5")
        buf.write("\u01e3\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\u01e8\3\2\2\2")
        buf.write("\u01e7\u01e5\3\2\2\2\u01e8\u01e9\t\4\2\2\u01e9E\3\2\2")
        buf.write("\2\u01ea\u01eb\7%\2\2\u01eb\u01ef\5d\63\2\u01ec\u01ee")
        buf.write("\7E\2\2\u01ed\u01ec\3\2\2\2\u01ee\u01f1\3\2\2\2\u01ef")
        buf.write("\u01ed\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f2\3\2\2\2")
        buf.write("\u01f1\u01ef\3\2\2\2\u01f2\u01f3\t\5\2\2\u01f3G\3\2\2")
        buf.write("\2\u01f4\u01f5\7&\2\2\u01f5\u01f9\5d\63\2\u01f6\u01f8")
        buf.write("\7E\2\2\u01f7\u01f6\3\2\2\2\u01f8\u01fb\3\2\2\2\u01f9")
        buf.write("\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fc\3\2\2\2")
        buf.write("\u01fb\u01f9\3\2\2\2\u01fc\u01fd\t\5\2\2\u01fdI\3\2\2")
        buf.write("\2\u01fe\u01ff\7\'\2\2\u01ff\u0203\5d\63\2\u0200\u0202")
        buf.write("\7E\2\2\u0201\u0200\3\2\2\2\u0202\u0205\3\2\2\2\u0203")
        buf.write("\u0201\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u0206\3\2\2\2")
        buf.write("\u0205\u0203\3\2\2\2\u0206\u0207\t\5\2\2\u0207K\3\2\2")
        buf.write("\2\u0208\u0209\7(\2\2\u0209\u020d\5d\63\2\u020a\u020c")
        buf.write("\7H\2\2\u020b\u020a\3\2\2\2\u020c\u020f\3\2\2\2\u020d")
        buf.write("\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2\2\2")
        buf.write("\u020f\u020d\3\2\2\2\u0210\u0211\t\4\2\2\u0211M\3\2\2")
        buf.write("\2\u0212\u0213\7)\2\2\u0213\u0217\5d\63\2\u0214\u0216")
        buf.write("\7H\2\2\u0215\u0214\3\2\2\2\u0216\u0219\3\2\2\2\u0217")
        buf.write("\u0215\3\2\2\2\u0217\u0218\3\2\2\2\u0218\u021a\3\2\2\2")
        buf.write("\u0219\u0217\3\2\2\2\u021a\u021b\t\4\2\2\u021bO\3\2\2")
        buf.write("\2\u021c\u021d\7*\2\2\u021d\u0221\5d\63\2\u021e\u0220")
        buf.write("\7B\2\2\u021f\u021e\3\2\2\2\u0220\u0223\3\2\2\2\u0221")
        buf.write("\u021f\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0224\3\2\2\2")
        buf.write("\u0223\u0221\3\2\2\2\u0224\u0225\t\3\2\2\u0225Q\3\2\2")
        buf.write("\2\u0226\u0227\7+\2\2\u0227\u022b\5d\63\2\u0228\u022a")
        buf.write("\7B\2\2\u0229\u0228\3\2\2\2\u022a\u022d\3\2\2\2\u022b")
        buf.write("\u0229\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022e\3\2\2\2")
        buf.write("\u022d\u022b\3\2\2\2\u022e\u022f\t\3\2\2\u022fS\3\2\2")
        buf.write("\2\u0230\u0231\7,\2\2\u0231\u0233\5d\63\2\u0232\u0234")
        buf.write("\7E\2\2\u0233\u0232\3\2\2\2\u0234\u0235\3\2\2\2\u0235")
        buf.write("\u0233\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237\3\2\2\2")
        buf.write("\u0237\u0238\t\5\2\2\u0238U\3\2\2\2\u0239\u023a\7-\2\2")
        buf.write("\u023a\u023e\5d\63\2\u023b\u023d\7H\2\2\u023c\u023b\3")
        buf.write("\2\2\2\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023e\u023f")
        buf.write("\3\2\2\2\u023f\u0241\3\2\2\2\u0240\u023e\3\2\2\2\u0241")
        buf.write("\u0242\t\4\2\2\u0242W\3\2\2\2\u0243\u0244\7.\2\2\u0244")
        buf.write("\u0248\5d\63\2\u0245\u0247\7H\2\2\u0246\u0245\3\2\2\2")
        buf.write("\u0247\u024a\3\2\2\2\u0248\u0246\3\2\2\2\u0248\u0249\3")
        buf.write("\2\2\2\u0249\u024b\3\2\2\2\u024a\u0248\3\2\2\2\u024b\u024c")
        buf.write("\t\4\2\2\u024cY\3\2\2\2\u024d\u024e\7/\2\2\u024e\u0252")
        buf.write("\5d\63\2\u024f\u0251\7H\2\2\u0250\u024f\3\2\2\2\u0251")
        buf.write("\u0254\3\2\2\2\u0252\u0250\3\2\2\2\u0252\u0253\3\2\2\2")
        buf.write("\u0253\u0255\3\2\2\2\u0254\u0252\3\2\2\2\u0255\u0256\t")
        buf.write("\4\2\2\u0256[\3\2\2\2\u0257\u0258\7\60\2\2\u0258\u025c")
        buf.write("\5d\63\2\u0259\u025b\7H\2\2\u025a\u0259\3\2\2\2\u025b")
        buf.write("\u025e\3\2\2\2\u025c\u025a\3\2\2\2\u025c\u025d\3\2\2\2")
        buf.write("\u025d\u025f\3\2\2\2\u025e\u025c\3\2\2\2\u025f\u0260\t")
        buf.write("\4\2\2\u0260]\3\2\2\2\u0261\u0262\7\61\2\2\u0262\u0266")
        buf.write("\5d\63\2\u0263\u0265\7E\2\2\u0264\u0263\3\2\2\2\u0265")
        buf.write("\u0268\3\2\2\2\u0266\u0264\3\2\2\2\u0266\u0267\3\2\2\2")
        buf.write("\u0267\u0269\3\2\2\2\u0268\u0266\3\2\2\2\u0269\u026a\t")
        buf.write("\5\2\2\u026a_\3\2\2\2\u026b\u026c\7\62\2\2\u026c\u0270")
        buf.write("\5d\63\2\u026d\u026f\7B\2\2\u026e\u026d\3\2\2\2\u026f")
        buf.write("\u0272\3\2\2\2\u0270\u026e\3\2\2\2\u0270\u0271\3\2\2\2")
        buf.write("\u0271\u0273\3\2\2\2\u0272\u0270\3\2\2\2\u0273\u0274\t")
        buf.write("\3\2\2\u0274a\3\2\2\2\u0275\u0276\7\63\2\2\u0276\u027a")
        buf.write("\5d\63\2\u0277\u0279\7B\2\2\u0278\u0277\3\2\2\2\u0279")
        buf.write("\u027c\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2\2\2")
        buf.write("\u027b\u027d\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u027e\t")
        buf.write("\3\2\2\u027ec\3\2\2\2\u027f\u0280\7\64\2\2\u0280\u0281")
        buf.write("\t\6\2\2\u0281e\3\2\2\2\65h\u0099\u009b\u00a6\u00af\u00b9")
        buf.write("\u00c3\u00cd\u00d7\u00e1\u00eb\u00f5\u00ff\u0109\u0113")
        buf.write("\u011d\u0127\u0131\u013b\u0145\u014f\u0159\u0163\u016d")
        buf.write("\u0177\u0181\u018b\u0195\u019f\u01a9\u01b3\u01bd\u01c7")
        buf.write("\u01d1\u01db\u01e5\u01ef\u01f9\u0203\u020d\u0217\u0221")
        buf.write("\u022b\u0235\u023e\u0248\u0252\u025c\u0266\u0270\u027a")
        return buf.getvalue()


class AmberPTParser ( Parser ):

    grammarFileName = "AmberPTParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'%VERSION'", "<INVALID>", "'AMBER_ATOM_TYPE'", 
                     "'ANGLE_EQUIL_VALUE'", "'ANGLE_FORCE_CONSTANT'", "'ANGLES_INC_HYDROGEN'", 
                     "'ANGLES_WITHOUT_HYDROGEN'", "'ATOMIC_NUMBER'", "'ATOM_NAME'", 
                     "'ATOM_TYPE_INDEX'", "'ATOMS_PER_MOLECULE'", "'BOND_EQUIL_VALUE'", 
                     "'BOND_FORCE_CONSTANT'", "'BONDS_INC_HYDROGEN'", "'BONDS_WITHOUT_HYDROGEN'", 
                     "'BOX_DIMENSIONS'", "'CAP_INFO'", "'CAP_INFO2'", "'CHARGE'", 
                     "'DIHEDRAL_FORCE_CONSTANT'", "'DIHEDRAL_PERIODICITY'", 
                     "'DIHEDRAL_PHASE'", "'DIHEDRALS_INC_HYDROGEN'", "'DIHEDRALS_WITHOUT_HYDROGEN'", 
                     "'EXCLUDED_ATOMS_LIST'", "'HBCUT'", "'HBOND_ACOEF'", 
                     "'HBOND_BCOEF'", "'IPOL'", "'IROTAT'", "'JOIN_ARRAY'", 
                     "'LENNARD_JONES_ACOEF'", "'LENNARD_JONES_BCOEF'", "'MASS'", 
                     "'NONBONDED_PARM_INDEX'", "'NUMBER_EXCLUDED_ATOMS'", 
                     "'POINTERS'", "'POLARIZABILITY'", "'RADII'", "'RADIUS_SET'", 
                     "'RESIDUE_LABEL'", "'RESIDUE_POINTER'", "'SCEE_SCALE_FACTOR'", 
                     "'SCNB_SCALE_FACTOR'", "'SCREEN'", "'SOLTY'", "'SOLVENT_POINTERS'", 
                     "'TITLE'", "'TREE_CHAIN_CLASSIFICATION'", "'%FORMAT'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'VERSION_STAMP'", 
                     "'DATE'", "'='" ]

    symbolicNames = [ "<INVALID>", "VERSION", "FLAG", "AMBER_ATOM_TYPE", 
                      "ANGLE_EQUIL_VALUE", "ANGLE_FORCE_CONSTANT", "ANGLES_INC_HYDROGEN", 
                      "ANGLES_WITHOUT_HYDROGEN", "ATOMIC_NUMBER", "ATOM_NAME", 
                      "ATOM_TYPE_INDEX", "ATOMS_PER_MOLECULE", "BOND_EQUIL_VALUE", 
                      "BOND_FORCE_CONSTANT", "BONDS_INC_HYDROGEN", "BONDS_WITHOUT_HYDROGEN", 
                      "BOX_DIMENSIONS", "CAP_INFO", "CAP_INFO2", "CHARGE", 
                      "DIHEDRAL_FORCE_CONSTANT", "DIHEDRAL_PERIODICITY", 
                      "DIHEDRAL_PHASE", "DIHEDRALS_INC_HYDROGEN", "DIHEDRALS_WITHOUT_HYDROGEN", 
                      "EXCLUDED_ATOMS_LIST", "HBCUT", "HBOND_ACOEF", "HBOND_BCOEF", 
                      "IPOL", "IROTAT", "JOIN_ARRAY", "LENNARD_JONES_ACOEF", 
                      "LENNARD_JONES_BCOEF", "MASS", "NONBONDED_PARM_INDEX", 
                      "NUMBER_EXCLUDED_ATOMS", "POINTERS", "POLARIZABILITY", 
                      "RADII", "RADIUS_SET", "RESIDUE_LABEL", "RESIDUE_POINTER", 
                      "SCEE_SCALE_FACTOR", "SCNB_SCALE_FACTOR", "SCREEN", 
                      "SOLTY", "SOLVENT_POINTERS", "TITLE", "TREE_CHAIN_CLASSIFICATION", 
                      "FORMAT", "SPACE", "COMMENT", "LINE_COMMENT", "VERSION_STAMP", 
                      "DATE", "Equ_op", "Version", "Date_time", "SPACE_V", 
                      "FLAG_V", "Fortran_format_A", "Fortran_format_I", 
                      "Fortran_format_E", "Simple_name", "SPACE_A", "FLAG_A", 
                      "Integer", "SPACE_I", "FLAG_I", "Real", "SPACE_E", 
                      "FLAG_E" ]

    RULE_amber_pt = 0
    RULE_version_statement = 1
    RULE_amber_atom_type_statement = 2
    RULE_angle_equil_value_statement = 3
    RULE_angle_force_constant_statement = 4
    RULE_angles_inc_hydrogen_statement = 5
    RULE_angles_without_hydrogen_statement = 6
    RULE_atomic_number_statement = 7
    RULE_atom_name_statement = 8
    RULE_atom_type_index_statement = 9
    RULE_atoms_per_molecule_statement = 10
    RULE_bond_equil_value_statement = 11
    RULE_bond_force_constant_statement = 12
    RULE_bonds_inc_hydrogen_statement = 13
    RULE_bonds_without_hydrogen_statement = 14
    RULE_box_dimensions_statement = 15
    RULE_cap_info_statement = 16
    RULE_cap_info2_statement = 17
    RULE_charge_statement = 18
    RULE_dihedral_force_constant_statement = 19
    RULE_dihedral_periodicity_statement = 20
    RULE_dihedral_phase_statement = 21
    RULE_dihedrals_inc_hydrogen_statement = 22
    RULE_dihedrals_without_hydrogen_statement = 23
    RULE_excluded_atoms_list_statement = 24
    RULE_hbcut_statement = 25
    RULE_hbond_acoef_statement = 26
    RULE_hbond_bcoef_statement = 27
    RULE_ipol_statement = 28
    RULE_irotat_statement = 29
    RULE_join_array_statement = 30
    RULE_lennard_jones_acoef_statement = 31
    RULE_lennard_jones_bcoef_statement = 32
    RULE_mass_statement = 33
    RULE_nonbonded_parm_index_statement = 34
    RULE_number_excluded_atoms_statement = 35
    RULE_pointers_statement = 36
    RULE_polarizability_statement = 37
    RULE_radii_statement = 38
    RULE_radius_set_statement = 39
    RULE_residue_label_statement = 40
    RULE_residue_pointer_statement = 41
    RULE_scee_scale_factor_statement = 42
    RULE_scnb_scale_factor_statement = 43
    RULE_screen_statement = 44
    RULE_solty_statement = 45
    RULE_solvent_pointers_statement = 46
    RULE_title_statement = 47
    RULE_tree_chain_classification_statement = 48
    RULE_format_function = 49

    ruleNames =  [ "amber_pt", "version_statement", "amber_atom_type_statement", 
                   "angle_equil_value_statement", "angle_force_constant_statement", 
                   "angles_inc_hydrogen_statement", "angles_without_hydrogen_statement", 
                   "atomic_number_statement", "atom_name_statement", "atom_type_index_statement", 
                   "atoms_per_molecule_statement", "bond_equil_value_statement", 
                   "bond_force_constant_statement", "bonds_inc_hydrogen_statement", 
                   "bonds_without_hydrogen_statement", "box_dimensions_statement", 
                   "cap_info_statement", "cap_info2_statement", "charge_statement", 
                   "dihedral_force_constant_statement", "dihedral_periodicity_statement", 
                   "dihedral_phase_statement", "dihedrals_inc_hydrogen_statement", 
                   "dihedrals_without_hydrogen_statement", "excluded_atoms_list_statement", 
                   "hbcut_statement", "hbond_acoef_statement", "hbond_bcoef_statement", 
                   "ipol_statement", "irotat_statement", "join_array_statement", 
                   "lennard_jones_acoef_statement", "lennard_jones_bcoef_statement", 
                   "mass_statement", "nonbonded_parm_index_statement", "number_excluded_atoms_statement", 
                   "pointers_statement", "polarizability_statement", "radii_statement", 
                   "radius_set_statement", "residue_label_statement", "residue_pointer_statement", 
                   "scee_scale_factor_statement", "scnb_scale_factor_statement", 
                   "screen_statement", "solty_statement", "solvent_pointers_statement", 
                   "title_statement", "tree_chain_classification_statement", 
                   "format_function" ]

    EOF = Token.EOF
    VERSION=1
    FLAG=2
    AMBER_ATOM_TYPE=3
    ANGLE_EQUIL_VALUE=4
    ANGLE_FORCE_CONSTANT=5
    ANGLES_INC_HYDROGEN=6
    ANGLES_WITHOUT_HYDROGEN=7
    ATOMIC_NUMBER=8
    ATOM_NAME=9
    ATOM_TYPE_INDEX=10
    ATOMS_PER_MOLECULE=11
    BOND_EQUIL_VALUE=12
    BOND_FORCE_CONSTANT=13
    BONDS_INC_HYDROGEN=14
    BONDS_WITHOUT_HYDROGEN=15
    BOX_DIMENSIONS=16
    CAP_INFO=17
    CAP_INFO2=18
    CHARGE=19
    DIHEDRAL_FORCE_CONSTANT=20
    DIHEDRAL_PERIODICITY=21
    DIHEDRAL_PHASE=22
    DIHEDRALS_INC_HYDROGEN=23
    DIHEDRALS_WITHOUT_HYDROGEN=24
    EXCLUDED_ATOMS_LIST=25
    HBCUT=26
    HBOND_ACOEF=27
    HBOND_BCOEF=28
    IPOL=29
    IROTAT=30
    JOIN_ARRAY=31
    LENNARD_JONES_ACOEF=32
    LENNARD_JONES_BCOEF=33
    MASS=34
    NONBONDED_PARM_INDEX=35
    NUMBER_EXCLUDED_ATOMS=36
    POINTERS=37
    POLARIZABILITY=38
    RADII=39
    RADIUS_SET=40
    RESIDUE_LABEL=41
    RESIDUE_POINTER=42
    SCEE_SCALE_FACTOR=43
    SCNB_SCALE_FACTOR=44
    SCREEN=45
    SOLTY=46
    SOLVENT_POINTERS=47
    TITLE=48
    TREE_CHAIN_CLASSIFICATION=49
    FORMAT=50
    SPACE=51
    COMMENT=52
    LINE_COMMENT=53
    VERSION_STAMP=54
    DATE=55
    Equ_op=56
    Version=57
    Date_time=58
    SPACE_V=59
    FLAG_V=60
    Fortran_format_A=61
    Fortran_format_I=62
    Fortran_format_E=63
    Simple_name=64
    SPACE_A=65
    FLAG_A=66
    Integer=67
    SPACE_I=68
    FLAG_I=69
    Real=70
    SPACE_E=71
    FLAG_E=72

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

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

        def version_statement(self):
            return self.getTypedRuleContext(AmberPTParser.Version_statementContext,0)


        def FLAG(self):
            return self.getToken(AmberPTParser.FLAG, 0)

        def amber_atom_type_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Amber_atom_type_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Amber_atom_type_statementContext,i)


        def angle_equil_value_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Angle_equil_value_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Angle_equil_value_statementContext,i)


        def angle_force_constant_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Angle_force_constant_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Angle_force_constant_statementContext,i)


        def angles_inc_hydrogen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Angles_inc_hydrogen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Angles_inc_hydrogen_statementContext,i)


        def angles_without_hydrogen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Angles_without_hydrogen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Angles_without_hydrogen_statementContext,i)


        def atomic_number_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Atomic_number_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Atomic_number_statementContext,i)


        def atom_name_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Atom_name_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Atom_name_statementContext,i)


        def atom_type_index_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Atom_type_index_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Atom_type_index_statementContext,i)


        def atoms_per_molecule_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Atoms_per_molecule_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Atoms_per_molecule_statementContext,i)


        def bond_equil_value_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Bond_equil_value_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Bond_equil_value_statementContext,i)


        def bond_force_constant_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Bond_force_constant_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Bond_force_constant_statementContext,i)


        def bonds_inc_hydrogen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Bonds_inc_hydrogen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Bonds_inc_hydrogen_statementContext,i)


        def bonds_without_hydrogen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Bonds_without_hydrogen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Bonds_without_hydrogen_statementContext,i)


        def box_dimensions_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Box_dimensions_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Box_dimensions_statementContext,i)


        def cap_info_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Cap_info_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Cap_info_statementContext,i)


        def cap_info2_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Cap_info2_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Cap_info2_statementContext,i)


        def charge_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Charge_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Charge_statementContext,i)


        def dihedral_force_constant_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Dihedral_force_constant_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Dihedral_force_constant_statementContext,i)


        def dihedral_periodicity_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Dihedral_periodicity_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Dihedral_periodicity_statementContext,i)


        def dihedral_phase_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Dihedral_phase_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Dihedral_phase_statementContext,i)


        def dihedrals_inc_hydrogen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Dihedrals_inc_hydrogen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Dihedrals_inc_hydrogen_statementContext,i)


        def dihedrals_without_hydrogen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Dihedrals_without_hydrogen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Dihedrals_without_hydrogen_statementContext,i)


        def excluded_atoms_list_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Excluded_atoms_list_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Excluded_atoms_list_statementContext,i)


        def hbcut_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Hbcut_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Hbcut_statementContext,i)


        def hbond_acoef_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Hbond_acoef_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Hbond_acoef_statementContext,i)


        def hbond_bcoef_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Hbond_bcoef_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Hbond_bcoef_statementContext,i)


        def ipol_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Ipol_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Ipol_statementContext,i)


        def irotat_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Irotat_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Irotat_statementContext,i)


        def join_array_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Join_array_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Join_array_statementContext,i)


        def lennard_jones_acoef_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Lennard_jones_acoef_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Lennard_jones_acoef_statementContext,i)


        def lennard_jones_bcoef_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Lennard_jones_bcoef_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Lennard_jones_bcoef_statementContext,i)


        def mass_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Mass_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Mass_statementContext,i)


        def nonbonded_parm_index_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Nonbonded_parm_index_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Nonbonded_parm_index_statementContext,i)


        def number_excluded_atoms_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Number_excluded_atoms_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Number_excluded_atoms_statementContext,i)


        def pointers_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Pointers_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Pointers_statementContext,i)


        def polarizability_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Polarizability_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Polarizability_statementContext,i)


        def radii_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Radii_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Radii_statementContext,i)


        def radius_set_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Radius_set_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Radius_set_statementContext,i)


        def residue_label_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Residue_label_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Residue_label_statementContext,i)


        def residue_pointer_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Residue_pointer_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Residue_pointer_statementContext,i)


        def scee_scale_factor_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Scee_scale_factor_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Scee_scale_factor_statementContext,i)


        def scnb_scale_factor_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Scnb_scale_factor_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Scnb_scale_factor_statementContext,i)


        def screen_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Screen_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Screen_statementContext,i)


        def solty_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Solty_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Solty_statementContext,i)


        def solvent_pointers_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Solvent_pointers_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Solvent_pointers_statementContext,i)


        def title_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Title_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Title_statementContext,i)


        def tree_chain_classification_statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(AmberPTParser.Tree_chain_classification_statementContext)
            else:
                return self.getTypedRuleContext(AmberPTParser.Tree_chain_classification_statementContext,i)


        def getRuleIndex(self):
            return AmberPTParser.RULE_amber_pt

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

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




    def amber_pt(self):

        localctx = AmberPTParser.Amber_ptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_amber_pt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 102
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [AmberPTParser.VERSION]:
                self.state = 100
                self.version_statement()
                pass
            elif token in [AmberPTParser.FLAG]:
                self.state = 101
                self.match(AmberPTParser.FLAG)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 153
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberPTParser.AMBER_ATOM_TYPE) | (1 << AmberPTParser.ANGLE_EQUIL_VALUE) | (1 << AmberPTParser.ANGLE_FORCE_CONSTANT) | (1 << AmberPTParser.ANGLES_INC_HYDROGEN) | (1 << AmberPTParser.ANGLES_WITHOUT_HYDROGEN) | (1 << AmberPTParser.ATOMIC_NUMBER) | (1 << AmberPTParser.ATOM_NAME) | (1 << AmberPTParser.ATOM_TYPE_INDEX) | (1 << AmberPTParser.ATOMS_PER_MOLECULE) | (1 << AmberPTParser.BOND_EQUIL_VALUE) | (1 << AmberPTParser.BOND_FORCE_CONSTANT) | (1 << AmberPTParser.BONDS_INC_HYDROGEN) | (1 << AmberPTParser.BONDS_WITHOUT_HYDROGEN) | (1 << AmberPTParser.BOX_DIMENSIONS) | (1 << AmberPTParser.CAP_INFO) | (1 << AmberPTParser.CAP_INFO2) | (1 << AmberPTParser.CHARGE) | (1 << AmberPTParser.DIHEDRAL_FORCE_CONSTANT) | (1 << AmberPTParser.DIHEDRAL_PERIODICITY) | (1 << AmberPTParser.DIHEDRAL_PHASE) | (1 << AmberPTParser.DIHEDRALS_INC_HYDROGEN) | (1 << AmberPTParser.DIHEDRALS_WITHOUT_HYDROGEN) | (1 << AmberPTParser.EXCLUDED_ATOMS_LIST) | (1 << AmberPTParser.HBCUT) | (1 << AmberPTParser.HBOND_ACOEF) | (1 << AmberPTParser.HBOND_BCOEF) | (1 << AmberPTParser.IPOL) | (1 << AmberPTParser.IROTAT) | (1 << AmberPTParser.JOIN_ARRAY) | (1 << AmberPTParser.LENNARD_JONES_ACOEF) | (1 << AmberPTParser.LENNARD_JONES_BCOEF) | (1 << AmberPTParser.MASS) | (1 << AmberPTParser.NONBONDED_PARM_INDEX) | (1 << AmberPTParser.NUMBER_EXCLUDED_ATOMS) | (1 << AmberPTParser.POINTERS) | (1 << AmberPTParser.POLARIZABILITY) | (1 << AmberPTParser.RADII) | (1 << AmberPTParser.RADIUS_SET) | (1 << AmberPTParser.RESIDUE_LABEL) | (1 << AmberPTParser.RESIDUE_POINTER) | (1 << AmberPTParser.SCEE_SCALE_FACTOR) | (1 << AmberPTParser.SCNB_SCALE_FACTOR) | (1 << AmberPTParser.SCREEN) | (1 << AmberPTParser.SOLTY) | (1 << AmberPTParser.SOLVENT_POINTERS) | (1 << AmberPTParser.TITLE) | (1 << AmberPTParser.TREE_CHAIN_CLASSIFICATION))) != 0):
                self.state = 151
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [AmberPTParser.AMBER_ATOM_TYPE]:
                    self.state = 104
                    self.amber_atom_type_statement()
                    pass
                elif token in [AmberPTParser.ANGLE_EQUIL_VALUE]:
                    self.state = 105
                    self.angle_equil_value_statement()
                    pass
                elif token in [AmberPTParser.ANGLE_FORCE_CONSTANT]:
                    self.state = 106
                    self.angle_force_constant_statement()
                    pass
                elif token in [AmberPTParser.ANGLES_INC_HYDROGEN]:
                    self.state = 107
                    self.angles_inc_hydrogen_statement()
                    pass
                elif token in [AmberPTParser.ANGLES_WITHOUT_HYDROGEN]:
                    self.state = 108
                    self.angles_without_hydrogen_statement()
                    pass
                elif token in [AmberPTParser.ATOMIC_NUMBER]:
                    self.state = 109
                    self.atomic_number_statement()
                    pass
                elif token in [AmberPTParser.ATOM_NAME]:
                    self.state = 110
                    self.atom_name_statement()
                    pass
                elif token in [AmberPTParser.ATOM_TYPE_INDEX]:
                    self.state = 111
                    self.atom_type_index_statement()
                    pass
                elif token in [AmberPTParser.ATOMS_PER_MOLECULE]:
                    self.state = 112
                    self.atoms_per_molecule_statement()
                    pass
                elif token in [AmberPTParser.BOND_EQUIL_VALUE]:
                    self.state = 113
                    self.bond_equil_value_statement()
                    pass
                elif token in [AmberPTParser.BOND_FORCE_CONSTANT]:
                    self.state = 114
                    self.bond_force_constant_statement()
                    pass
                elif token in [AmberPTParser.BONDS_INC_HYDROGEN]:
                    self.state = 115
                    self.bonds_inc_hydrogen_statement()
                    pass
                elif token in [AmberPTParser.BONDS_WITHOUT_HYDROGEN]:
                    self.state = 116
                    self.bonds_without_hydrogen_statement()
                    pass
                elif token in [AmberPTParser.BOX_DIMENSIONS]:
                    self.state = 117
                    self.box_dimensions_statement()
                    pass
                elif token in [AmberPTParser.CAP_INFO]:
                    self.state = 118
                    self.cap_info_statement()
                    pass
                elif token in [AmberPTParser.CAP_INFO2]:
                    self.state = 119
                    self.cap_info2_statement()
                    pass
                elif token in [AmberPTParser.CHARGE]:
                    self.state = 120
                    self.charge_statement()
                    pass
                elif token in [AmberPTParser.DIHEDRAL_FORCE_CONSTANT]:
                    self.state = 121
                    self.dihedral_force_constant_statement()
                    pass
                elif token in [AmberPTParser.DIHEDRAL_PERIODICITY]:
                    self.state = 122
                    self.dihedral_periodicity_statement()
                    pass
                elif token in [AmberPTParser.DIHEDRAL_PHASE]:
                    self.state = 123
                    self.dihedral_phase_statement()
                    pass
                elif token in [AmberPTParser.DIHEDRALS_INC_HYDROGEN]:
                    self.state = 124
                    self.dihedrals_inc_hydrogen_statement()
                    pass
                elif token in [AmberPTParser.DIHEDRALS_WITHOUT_HYDROGEN]:
                    self.state = 125
                    self.dihedrals_without_hydrogen_statement()
                    pass
                elif token in [AmberPTParser.EXCLUDED_ATOMS_LIST]:
                    self.state = 126
                    self.excluded_atoms_list_statement()
                    pass
                elif token in [AmberPTParser.HBCUT]:
                    self.state = 127
                    self.hbcut_statement()
                    pass
                elif token in [AmberPTParser.HBOND_ACOEF]:
                    self.state = 128
                    self.hbond_acoef_statement()
                    pass
                elif token in [AmberPTParser.HBOND_BCOEF]:
                    self.state = 129
                    self.hbond_bcoef_statement()
                    pass
                elif token in [AmberPTParser.IPOL]:
                    self.state = 130
                    self.ipol_statement()
                    pass
                elif token in [AmberPTParser.IROTAT]:
                    self.state = 131
                    self.irotat_statement()
                    pass
                elif token in [AmberPTParser.JOIN_ARRAY]:
                    self.state = 132
                    self.join_array_statement()
                    pass
                elif token in [AmberPTParser.LENNARD_JONES_ACOEF]:
                    self.state = 133
                    self.lennard_jones_acoef_statement()
                    pass
                elif token in [AmberPTParser.LENNARD_JONES_BCOEF]:
                    self.state = 134
                    self.lennard_jones_bcoef_statement()
                    pass
                elif token in [AmberPTParser.MASS]:
                    self.state = 135
                    self.mass_statement()
                    pass
                elif token in [AmberPTParser.NONBONDED_PARM_INDEX]:
                    self.state = 136
                    self.nonbonded_parm_index_statement()
                    pass
                elif token in [AmberPTParser.NUMBER_EXCLUDED_ATOMS]:
                    self.state = 137
                    self.number_excluded_atoms_statement()
                    pass
                elif token in [AmberPTParser.POINTERS]:
                    self.state = 138
                    self.pointers_statement()
                    pass
                elif token in [AmberPTParser.POLARIZABILITY]:
                    self.state = 139
                    self.polarizability_statement()
                    pass
                elif token in [AmberPTParser.RADII]:
                    self.state = 140
                    self.radii_statement()
                    pass
                elif token in [AmberPTParser.RADIUS_SET]:
                    self.state = 141
                    self.radius_set_statement()
                    pass
                elif token in [AmberPTParser.RESIDUE_LABEL]:
                    self.state = 142
                    self.residue_label_statement()
                    pass
                elif token in [AmberPTParser.RESIDUE_POINTER]:
                    self.state = 143
                    self.residue_pointer_statement()
                    pass
                elif token in [AmberPTParser.SCEE_SCALE_FACTOR]:
                    self.state = 144
                    self.scee_scale_factor_statement()
                    pass
                elif token in [AmberPTParser.SCNB_SCALE_FACTOR]:
                    self.state = 145
                    self.scnb_scale_factor_statement()
                    pass
                elif token in [AmberPTParser.SCREEN]:
                    self.state = 146
                    self.screen_statement()
                    pass
                elif token in [AmberPTParser.SOLTY]:
                    self.state = 147
                    self.solty_statement()
                    pass
                elif token in [AmberPTParser.SOLVENT_POINTERS]:
                    self.state = 148
                    self.solvent_pointers_statement()
                    pass
                elif token in [AmberPTParser.TITLE]:
                    self.state = 149
                    self.title_statement()
                    pass
                elif token in [AmberPTParser.TREE_CHAIN_CLASSIFICATION]:
                    self.state = 150
                    self.tree_chain_classification_statement()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 155
                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 Version_statementContext(ParserRuleContext):

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

        def VERSION(self):
            return self.getToken(AmberPTParser.VERSION, 0)

        def VERSION_STAMP(self):
            return self.getToken(AmberPTParser.VERSION_STAMP, 0)

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

        def Version(self):
            return self.getToken(AmberPTParser.Version, 0)

        def DATE(self):
            return self.getToken(AmberPTParser.DATE, 0)

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

        def FLAG_V(self):
            return self.getToken(AmberPTParser.FLAG_V, 0)

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_version_statement

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

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




    def version_statement(self):

        localctx = AmberPTParser.Version_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_version_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 156
            self.match(AmberPTParser.VERSION)
            self.state = 157
            self.match(AmberPTParser.VERSION_STAMP)
            self.state = 158
            self.match(AmberPTParser.Equ_op)
            self.state = 159
            self.match(AmberPTParser.Version)
            self.state = 160
            self.match(AmberPTParser.DATE)
            self.state = 161
            self.match(AmberPTParser.Equ_op)
            self.state = 162
            self.match(AmberPTParser.Date_time)
            self.state = 164
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==AmberPTParser.Date_time:
                self.state = 163
                self.match(AmberPTParser.Date_time)


            self.state = 166
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_V):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Amber_atom_type_statementContext(ParserRuleContext):

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

        def AMBER_ATOM_TYPE(self):
            return self.getToken(AmberPTParser.AMBER_ATOM_TYPE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_A(self):
            return self.getToken(AmberPTParser.FLAG_A, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_amber_atom_type_statement

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

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




    def amber_atom_type_statement(self):

        localctx = AmberPTParser.Amber_atom_type_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_amber_atom_type_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 168
            self.match(AmberPTParser.AMBER_ATOM_TYPE)
            self.state = 169
            self.format_function()
            self.state = 173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Simple_name:
                self.state = 170
                self.match(AmberPTParser.Simple_name)
                self.state = 175
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 176
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_A):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angle_equil_value_statementContext(ParserRuleContext):

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

        def ANGLE_EQUIL_VALUE(self):
            return self.getToken(AmberPTParser.ANGLE_EQUIL_VALUE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_angle_equil_value_statement

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

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




    def angle_equil_value_statement(self):

        localctx = AmberPTParser.Angle_equil_value_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_angle_equil_value_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 178
            self.match(AmberPTParser.ANGLE_EQUIL_VALUE)
            self.state = 179
            self.format_function()
            self.state = 183
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 180
                self.match(AmberPTParser.Real)
                self.state = 185
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 186
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angle_force_constant_statementContext(ParserRuleContext):

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

        def ANGLE_FORCE_CONSTANT(self):
            return self.getToken(AmberPTParser.ANGLE_FORCE_CONSTANT, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_angle_force_constant_statement

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

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




    def angle_force_constant_statement(self):

        localctx = AmberPTParser.Angle_force_constant_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_angle_force_constant_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 188
            self.match(AmberPTParser.ANGLE_FORCE_CONSTANT)
            self.state = 189
            self.format_function()
            self.state = 193
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 190
                self.match(AmberPTParser.Real)
                self.state = 195
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 196
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angles_inc_hydrogen_statementContext(ParserRuleContext):

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

        def ANGLES_INC_HYDROGEN(self):
            return self.getToken(AmberPTParser.ANGLES_INC_HYDROGEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_angles_inc_hydrogen_statement

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

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




    def angles_inc_hydrogen_statement(self):

        localctx = AmberPTParser.Angles_inc_hydrogen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_angles_inc_hydrogen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 198
            self.match(AmberPTParser.ANGLES_INC_HYDROGEN)
            self.state = 199
            self.format_function()
            self.state = 203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 200
                self.match(AmberPTParser.Integer)
                self.state = 205
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 206
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Angles_without_hydrogen_statementContext(ParserRuleContext):

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

        def ANGLES_WITHOUT_HYDROGEN(self):
            return self.getToken(AmberPTParser.ANGLES_WITHOUT_HYDROGEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_angles_without_hydrogen_statement

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

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




    def angles_without_hydrogen_statement(self):

        localctx = AmberPTParser.Angles_without_hydrogen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_angles_without_hydrogen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 208
            self.match(AmberPTParser.ANGLES_WITHOUT_HYDROGEN)
            self.state = 209
            self.format_function()
            self.state = 213
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 210
                self.match(AmberPTParser.Integer)
                self.state = 215
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 216
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Atomic_number_statementContext(ParserRuleContext):

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

        def ATOMIC_NUMBER(self):
            return self.getToken(AmberPTParser.ATOMIC_NUMBER, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_atomic_number_statement

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

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




    def atomic_number_statement(self):

        localctx = AmberPTParser.Atomic_number_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_atomic_number_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 218
            self.match(AmberPTParser.ATOMIC_NUMBER)
            self.state = 219
            self.format_function()
            self.state = 223
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 220
                self.match(AmberPTParser.Integer)
                self.state = 225
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 226
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Atom_name_statementContext(ParserRuleContext):

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

        def ATOM_NAME(self):
            return self.getToken(AmberPTParser.ATOM_NAME, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_A(self):
            return self.getToken(AmberPTParser.FLAG_A, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_atom_name_statement

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

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




    def atom_name_statement(self):

        localctx = AmberPTParser.Atom_name_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_atom_name_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 228
            self.match(AmberPTParser.ATOM_NAME)
            self.state = 229
            self.format_function()
            self.state = 233
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Simple_name:
                self.state = 230
                self.match(AmberPTParser.Simple_name)
                self.state = 235
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 236
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_A):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Atom_type_index_statementContext(ParserRuleContext):

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

        def ATOM_TYPE_INDEX(self):
            return self.getToken(AmberPTParser.ATOM_TYPE_INDEX, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_atom_type_index_statement

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

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




    def atom_type_index_statement(self):

        localctx = AmberPTParser.Atom_type_index_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_atom_type_index_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self.match(AmberPTParser.ATOM_TYPE_INDEX)
            self.state = 239
            self.format_function()
            self.state = 243
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 240
                self.match(AmberPTParser.Integer)
                self.state = 245
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 246
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Atoms_per_molecule_statementContext(ParserRuleContext):

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

        def ATOMS_PER_MOLECULE(self):
            return self.getToken(AmberPTParser.ATOMS_PER_MOLECULE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_atoms_per_molecule_statement

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

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




    def atoms_per_molecule_statement(self):

        localctx = AmberPTParser.Atoms_per_molecule_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_atoms_per_molecule_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.match(AmberPTParser.ATOMS_PER_MOLECULE)
            self.state = 249
            self.format_function()
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 250
                self.match(AmberPTParser.Integer)
                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 256
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bond_equil_value_statementContext(ParserRuleContext):

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

        def BOND_EQUIL_VALUE(self):
            return self.getToken(AmberPTParser.BOND_EQUIL_VALUE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_bond_equil_value_statement

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

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




    def bond_equil_value_statement(self):

        localctx = AmberPTParser.Bond_equil_value_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_bond_equil_value_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            self.match(AmberPTParser.BOND_EQUIL_VALUE)
            self.state = 259
            self.format_function()
            self.state = 263
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 260
                self.match(AmberPTParser.Real)
                self.state = 265
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 266
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bond_force_constant_statementContext(ParserRuleContext):

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

        def BOND_FORCE_CONSTANT(self):
            return self.getToken(AmberPTParser.BOND_FORCE_CONSTANT, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_bond_force_constant_statement

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

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




    def bond_force_constant_statement(self):

        localctx = AmberPTParser.Bond_force_constant_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_bond_force_constant_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 268
            self.match(AmberPTParser.BOND_FORCE_CONSTANT)
            self.state = 269
            self.format_function()
            self.state = 273
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 270
                self.match(AmberPTParser.Real)
                self.state = 275
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 276
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bonds_inc_hydrogen_statementContext(ParserRuleContext):

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

        def BONDS_INC_HYDROGEN(self):
            return self.getToken(AmberPTParser.BONDS_INC_HYDROGEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_bonds_inc_hydrogen_statement

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

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




    def bonds_inc_hydrogen_statement(self):

        localctx = AmberPTParser.Bonds_inc_hydrogen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_bonds_inc_hydrogen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 278
            self.match(AmberPTParser.BONDS_INC_HYDROGEN)
            self.state = 279
            self.format_function()
            self.state = 283
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 280
                self.match(AmberPTParser.Integer)
                self.state = 285
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 286
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bonds_without_hydrogen_statementContext(ParserRuleContext):

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

        def BONDS_WITHOUT_HYDROGEN(self):
            return self.getToken(AmberPTParser.BONDS_WITHOUT_HYDROGEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_bonds_without_hydrogen_statement

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

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




    def bonds_without_hydrogen_statement(self):

        localctx = AmberPTParser.Bonds_without_hydrogen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_bonds_without_hydrogen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 288
            self.match(AmberPTParser.BONDS_WITHOUT_HYDROGEN)
            self.state = 289
            self.format_function()
            self.state = 293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 290
                self.match(AmberPTParser.Integer)
                self.state = 295
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 296
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Box_dimensions_statementContext(ParserRuleContext):

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

        def BOX_DIMENSIONS(self):
            return self.getToken(AmberPTParser.BOX_DIMENSIONS, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_box_dimensions_statement

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

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




    def box_dimensions_statement(self):

        localctx = AmberPTParser.Box_dimensions_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_box_dimensions_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.match(AmberPTParser.BOX_DIMENSIONS)
            self.state = 299
            self.format_function()
            self.state = 303
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 300
                self.match(AmberPTParser.Real)
                self.state = 305
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 306
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Cap_info_statementContext(ParserRuleContext):

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

        def CAP_INFO(self):
            return self.getToken(AmberPTParser.CAP_INFO, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_cap_info_statement

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

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




    def cap_info_statement(self):

        localctx = AmberPTParser.Cap_info_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_cap_info_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.match(AmberPTParser.CAP_INFO)
            self.state = 309
            self.format_function()
            self.state = 313
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 310
                self.match(AmberPTParser.Integer)
                self.state = 315
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 316
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Cap_info2_statementContext(ParserRuleContext):

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

        def CAP_INFO2(self):
            return self.getToken(AmberPTParser.CAP_INFO2, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_cap_info2_statement

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

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




    def cap_info2_statement(self):

        localctx = AmberPTParser.Cap_info2_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_cap_info2_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 318
            self.match(AmberPTParser.CAP_INFO2)
            self.state = 319
            self.format_function()
            self.state = 323
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 320
                self.match(AmberPTParser.Real)
                self.state = 325
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 326
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Charge_statementContext(ParserRuleContext):

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

        def CHARGE(self):
            return self.getToken(AmberPTParser.CHARGE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_charge_statement

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

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




    def charge_statement(self):

        localctx = AmberPTParser.Charge_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_charge_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 328
            self.match(AmberPTParser.CHARGE)
            self.state = 329
            self.format_function()
            self.state = 333
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 330
                self.match(AmberPTParser.Real)
                self.state = 335
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 336
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedral_force_constant_statementContext(ParserRuleContext):

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

        def DIHEDRAL_FORCE_CONSTANT(self):
            return self.getToken(AmberPTParser.DIHEDRAL_FORCE_CONSTANT, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_dihedral_force_constant_statement

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

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




    def dihedral_force_constant_statement(self):

        localctx = AmberPTParser.Dihedral_force_constant_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_dihedral_force_constant_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 338
            self.match(AmberPTParser.DIHEDRAL_FORCE_CONSTANT)
            self.state = 339
            self.format_function()
            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 340
                self.match(AmberPTParser.Real)
                self.state = 345
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 346
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedral_periodicity_statementContext(ParserRuleContext):

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

        def DIHEDRAL_PERIODICITY(self):
            return self.getToken(AmberPTParser.DIHEDRAL_PERIODICITY, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_dihedral_periodicity_statement

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

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




    def dihedral_periodicity_statement(self):

        localctx = AmberPTParser.Dihedral_periodicity_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_dihedral_periodicity_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 348
            self.match(AmberPTParser.DIHEDRAL_PERIODICITY)
            self.state = 349
            self.format_function()
            self.state = 353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 350
                self.match(AmberPTParser.Real)
                self.state = 355
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 356
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedral_phase_statementContext(ParserRuleContext):

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

        def DIHEDRAL_PHASE(self):
            return self.getToken(AmberPTParser.DIHEDRAL_PHASE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_dihedral_phase_statement

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

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




    def dihedral_phase_statement(self):

        localctx = AmberPTParser.Dihedral_phase_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_dihedral_phase_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 358
            self.match(AmberPTParser.DIHEDRAL_PHASE)
            self.state = 359
            self.format_function()
            self.state = 363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 360
                self.match(AmberPTParser.Real)
                self.state = 365
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 366
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedrals_inc_hydrogen_statementContext(ParserRuleContext):

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

        def DIHEDRALS_INC_HYDROGEN(self):
            return self.getToken(AmberPTParser.DIHEDRALS_INC_HYDROGEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_dihedrals_inc_hydrogen_statement

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

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




    def dihedrals_inc_hydrogen_statement(self):

        localctx = AmberPTParser.Dihedrals_inc_hydrogen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_dihedrals_inc_hydrogen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 368
            self.match(AmberPTParser.DIHEDRALS_INC_HYDROGEN)
            self.state = 369
            self.format_function()
            self.state = 373
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 370
                self.match(AmberPTParser.Integer)
                self.state = 375
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 376
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dihedrals_without_hydrogen_statementContext(ParserRuleContext):

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

        def DIHEDRALS_WITHOUT_HYDROGEN(self):
            return self.getToken(AmberPTParser.DIHEDRALS_WITHOUT_HYDROGEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_dihedrals_without_hydrogen_statement

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

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




    def dihedrals_without_hydrogen_statement(self):

        localctx = AmberPTParser.Dihedrals_without_hydrogen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_dihedrals_without_hydrogen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self.match(AmberPTParser.DIHEDRALS_WITHOUT_HYDROGEN)
            self.state = 379
            self.format_function()
            self.state = 383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 380
                self.match(AmberPTParser.Integer)
                self.state = 385
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 386
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Excluded_atoms_list_statementContext(ParserRuleContext):

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

        def EXCLUDED_ATOMS_LIST(self):
            return self.getToken(AmberPTParser.EXCLUDED_ATOMS_LIST, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_excluded_atoms_list_statement

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

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




    def excluded_atoms_list_statement(self):

        localctx = AmberPTParser.Excluded_atoms_list_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_excluded_atoms_list_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 388
            self.match(AmberPTParser.EXCLUDED_ATOMS_LIST)
            self.state = 389
            self.format_function()
            self.state = 393
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 390
                self.match(AmberPTParser.Integer)
                self.state = 395
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 396
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbcut_statementContext(ParserRuleContext):

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

        def HBCUT(self):
            return self.getToken(AmberPTParser.HBCUT, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_hbcut_statement

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

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




    def hbcut_statement(self):

        localctx = AmberPTParser.Hbcut_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_hbcut_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 398
            self.match(AmberPTParser.HBCUT)
            self.state = 399
            self.format_function()
            self.state = 403
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 400
                self.match(AmberPTParser.Real)
                self.state = 405
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 406
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_acoef_statementContext(ParserRuleContext):

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

        def HBOND_ACOEF(self):
            return self.getToken(AmberPTParser.HBOND_ACOEF, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_hbond_acoef_statement

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

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




    def hbond_acoef_statement(self):

        localctx = AmberPTParser.Hbond_acoef_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_hbond_acoef_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.match(AmberPTParser.HBOND_ACOEF)
            self.state = 409
            self.format_function()
            self.state = 413
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 410
                self.match(AmberPTParser.Real)
                self.state = 415
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 416
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Hbond_bcoef_statementContext(ParserRuleContext):

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

        def HBOND_BCOEF(self):
            return self.getToken(AmberPTParser.HBOND_BCOEF, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_hbond_bcoef_statement

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

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




    def hbond_bcoef_statement(self):

        localctx = AmberPTParser.Hbond_bcoef_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_hbond_bcoef_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 418
            self.match(AmberPTParser.HBOND_BCOEF)
            self.state = 419
            self.format_function()
            self.state = 423
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 420
                self.match(AmberPTParser.Real)
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 426
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ipol_statementContext(ParserRuleContext):

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

        def IPOL(self):
            return self.getToken(AmberPTParser.IPOL, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_ipol_statement

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

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




    def ipol_statement(self):

        localctx = AmberPTParser.Ipol_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_ipol_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self.match(AmberPTParser.IPOL)
            self.state = 429
            self.format_function()
            self.state = 433
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 430
                self.match(AmberPTParser.Integer)
                self.state = 435
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 436
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Irotat_statementContext(ParserRuleContext):

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

        def IROTAT(self):
            return self.getToken(AmberPTParser.IROTAT, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_irotat_statement

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

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




    def irotat_statement(self):

        localctx = AmberPTParser.Irotat_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_irotat_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 438
            self.match(AmberPTParser.IROTAT)
            self.state = 439
            self.format_function()
            self.state = 443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 440
                self.match(AmberPTParser.Integer)
                self.state = 445
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 446
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Join_array_statementContext(ParserRuleContext):

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

        def JOIN_ARRAY(self):
            return self.getToken(AmberPTParser.JOIN_ARRAY, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_join_array_statement

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

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




    def join_array_statement(self):

        localctx = AmberPTParser.Join_array_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_join_array_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 448
            self.match(AmberPTParser.JOIN_ARRAY)
            self.state = 449
            self.format_function()
            self.state = 453
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 450
                self.match(AmberPTParser.Integer)
                self.state = 455
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 456
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lennard_jones_acoef_statementContext(ParserRuleContext):

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

        def LENNARD_JONES_ACOEF(self):
            return self.getToken(AmberPTParser.LENNARD_JONES_ACOEF, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_lennard_jones_acoef_statement

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

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




    def lennard_jones_acoef_statement(self):

        localctx = AmberPTParser.Lennard_jones_acoef_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_lennard_jones_acoef_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 458
            self.match(AmberPTParser.LENNARD_JONES_ACOEF)
            self.state = 459
            self.format_function()
            self.state = 463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 460
                self.match(AmberPTParser.Real)
                self.state = 465
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 466
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lennard_jones_bcoef_statementContext(ParserRuleContext):

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

        def LENNARD_JONES_BCOEF(self):
            return self.getToken(AmberPTParser.LENNARD_JONES_BCOEF, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_lennard_jones_bcoef_statement

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

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




    def lennard_jones_bcoef_statement(self):

        localctx = AmberPTParser.Lennard_jones_bcoef_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_lennard_jones_bcoef_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 468
            self.match(AmberPTParser.LENNARD_JONES_BCOEF)
            self.state = 469
            self.format_function()
            self.state = 473
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 470
                self.match(AmberPTParser.Real)
                self.state = 475
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 476
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Mass_statementContext(ParserRuleContext):

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

        def MASS(self):
            return self.getToken(AmberPTParser.MASS, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_mass_statement

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

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




    def mass_statement(self):

        localctx = AmberPTParser.Mass_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_mass_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 478
            self.match(AmberPTParser.MASS)
            self.state = 479
            self.format_function()
            self.state = 483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 480
                self.match(AmberPTParser.Real)
                self.state = 485
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 486
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Nonbonded_parm_index_statementContext(ParserRuleContext):

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

        def NONBONDED_PARM_INDEX(self):
            return self.getToken(AmberPTParser.NONBONDED_PARM_INDEX, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_nonbonded_parm_index_statement

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

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




    def nonbonded_parm_index_statement(self):

        localctx = AmberPTParser.Nonbonded_parm_index_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_nonbonded_parm_index_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 488
            self.match(AmberPTParser.NONBONDED_PARM_INDEX)
            self.state = 489
            self.format_function()
            self.state = 493
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 490
                self.match(AmberPTParser.Integer)
                self.state = 495
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 496
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Number_excluded_atoms_statementContext(ParserRuleContext):

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

        def NUMBER_EXCLUDED_ATOMS(self):
            return self.getToken(AmberPTParser.NUMBER_EXCLUDED_ATOMS, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_number_excluded_atoms_statement

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

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




    def number_excluded_atoms_statement(self):

        localctx = AmberPTParser.Number_excluded_atoms_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_number_excluded_atoms_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 498
            self.match(AmberPTParser.NUMBER_EXCLUDED_ATOMS)
            self.state = 499
            self.format_function()
            self.state = 503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 500
                self.match(AmberPTParser.Integer)
                self.state = 505
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 506
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pointers_statementContext(ParserRuleContext):

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

        def POINTERS(self):
            return self.getToken(AmberPTParser.POINTERS, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_pointers_statement

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

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




    def pointers_statement(self):

        localctx = AmberPTParser.Pointers_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_pointers_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 508
            self.match(AmberPTParser.POINTERS)
            self.state = 509
            self.format_function()
            self.state = 513
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 510
                self.match(AmberPTParser.Integer)
                self.state = 515
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 516
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Polarizability_statementContext(ParserRuleContext):

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

        def POLARIZABILITY(self):
            return self.getToken(AmberPTParser.POLARIZABILITY, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_polarizability_statement

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

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




    def polarizability_statement(self):

        localctx = AmberPTParser.Polarizability_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_polarizability_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 518
            self.match(AmberPTParser.POLARIZABILITY)
            self.state = 519
            self.format_function()
            self.state = 523
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 520
                self.match(AmberPTParser.Real)
                self.state = 525
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 526
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Radii_statementContext(ParserRuleContext):

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

        def RADII(self):
            return self.getToken(AmberPTParser.RADII, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_radii_statement

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

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




    def radii_statement(self):

        localctx = AmberPTParser.Radii_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_radii_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 528
            self.match(AmberPTParser.RADII)
            self.state = 529
            self.format_function()
            self.state = 533
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 530
                self.match(AmberPTParser.Real)
                self.state = 535
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 536
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Radius_set_statementContext(ParserRuleContext):

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

        def RADIUS_SET(self):
            return self.getToken(AmberPTParser.RADIUS_SET, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_A(self):
            return self.getToken(AmberPTParser.FLAG_A, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_radius_set_statement

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

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




    def radius_set_statement(self):

        localctx = AmberPTParser.Radius_set_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_radius_set_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self.match(AmberPTParser.RADIUS_SET)
            self.state = 539
            self.format_function()
            self.state = 543
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Simple_name:
                self.state = 540
                self.match(AmberPTParser.Simple_name)
                self.state = 545
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 546
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_A):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Residue_label_statementContext(ParserRuleContext):

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

        def RESIDUE_LABEL(self):
            return self.getToken(AmberPTParser.RESIDUE_LABEL, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_A(self):
            return self.getToken(AmberPTParser.FLAG_A, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_residue_label_statement

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

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




    def residue_label_statement(self):

        localctx = AmberPTParser.Residue_label_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_residue_label_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 548
            self.match(AmberPTParser.RESIDUE_LABEL)
            self.state = 549
            self.format_function()
            self.state = 553
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Simple_name:
                self.state = 550
                self.match(AmberPTParser.Simple_name)
                self.state = 555
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 556
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_A):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Residue_pointer_statementContext(ParserRuleContext):

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

        def RESIDUE_POINTER(self):
            return self.getToken(AmberPTParser.RESIDUE_POINTER, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_residue_pointer_statement

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

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




    def residue_pointer_statement(self):

        localctx = AmberPTParser.Residue_pointer_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_residue_pointer_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self.match(AmberPTParser.RESIDUE_POINTER)
            self.state = 559
            self.format_function()
            self.state = 561 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 560
                self.match(AmberPTParser.Integer)
                self.state = 563 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==AmberPTParser.Integer):
                    break

            self.state = 565
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Scee_scale_factor_statementContext(ParserRuleContext):

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

        def SCEE_SCALE_FACTOR(self):
            return self.getToken(AmberPTParser.SCEE_SCALE_FACTOR, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_scee_scale_factor_statement

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

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




    def scee_scale_factor_statement(self):

        localctx = AmberPTParser.Scee_scale_factor_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_scee_scale_factor_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 567
            self.match(AmberPTParser.SCEE_SCALE_FACTOR)
            self.state = 568
            self.format_function()
            self.state = 572
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 569
                self.match(AmberPTParser.Real)
                self.state = 574
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 575
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Scnb_scale_factor_statementContext(ParserRuleContext):

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

        def SCNB_SCALE_FACTOR(self):
            return self.getToken(AmberPTParser.SCNB_SCALE_FACTOR, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_scnb_scale_factor_statement

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

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




    def scnb_scale_factor_statement(self):

        localctx = AmberPTParser.Scnb_scale_factor_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_scnb_scale_factor_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 577
            self.match(AmberPTParser.SCNB_SCALE_FACTOR)
            self.state = 578
            self.format_function()
            self.state = 582
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 579
                self.match(AmberPTParser.Real)
                self.state = 584
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 585
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Screen_statementContext(ParserRuleContext):

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

        def SCREEN(self):
            return self.getToken(AmberPTParser.SCREEN, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_screen_statement

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

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




    def screen_statement(self):

        localctx = AmberPTParser.Screen_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_screen_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 587
            self.match(AmberPTParser.SCREEN)
            self.state = 588
            self.format_function()
            self.state = 592
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 589
                self.match(AmberPTParser.Real)
                self.state = 594
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 595
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Solty_statementContext(ParserRuleContext):

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

        def SOLTY(self):
            return self.getToken(AmberPTParser.SOLTY, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_E(self):
            return self.getToken(AmberPTParser.FLAG_E, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_solty_statement

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

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




    def solty_statement(self):

        localctx = AmberPTParser.Solty_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_solty_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 597
            self.match(AmberPTParser.SOLTY)
            self.state = 598
            self.format_function()
            self.state = 602
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Real:
                self.state = 599
                self.match(AmberPTParser.Real)
                self.state = 604
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 605
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_E):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Solvent_pointers_statementContext(ParserRuleContext):

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

        def SOLVENT_POINTERS(self):
            return self.getToken(AmberPTParser.SOLVENT_POINTERS, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_I(self):
            return self.getToken(AmberPTParser.FLAG_I, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_solvent_pointers_statement

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

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




    def solvent_pointers_statement(self):

        localctx = AmberPTParser.Solvent_pointers_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_solvent_pointers_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607
            self.match(AmberPTParser.SOLVENT_POINTERS)
            self.state = 608
            self.format_function()
            self.state = 612
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Integer:
                self.state = 609
                self.match(AmberPTParser.Integer)
                self.state = 614
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 615
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_I):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Title_statementContext(ParserRuleContext):

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

        def TITLE(self):
            return self.getToken(AmberPTParser.TITLE, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_A(self):
            return self.getToken(AmberPTParser.FLAG_A, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_title_statement

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

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




    def title_statement(self):

        localctx = AmberPTParser.Title_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_title_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 617
            self.match(AmberPTParser.TITLE)
            self.state = 618
            self.format_function()
            self.state = 622
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Simple_name:
                self.state = 619
                self.match(AmberPTParser.Simple_name)
                self.state = 624
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 625
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_A):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Tree_chain_classification_statementContext(ParserRuleContext):

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

        def TREE_CHAIN_CLASSIFICATION(self):
            return self.getToken(AmberPTParser.TREE_CHAIN_CLASSIFICATION, 0)

        def format_function(self):
            return self.getTypedRuleContext(AmberPTParser.Format_functionContext,0)


        def FLAG_A(self):
            return self.getToken(AmberPTParser.FLAG_A, 0)

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

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

        def getRuleIndex(self):
            return AmberPTParser.RULE_tree_chain_classification_statement

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

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




    def tree_chain_classification_statement(self):

        localctx = AmberPTParser.Tree_chain_classification_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_tree_chain_classification_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 627
            self.match(AmberPTParser.TREE_CHAIN_CLASSIFICATION)
            self.state = 628
            self.format_function()
            self.state = 632
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==AmberPTParser.Simple_name:
                self.state = 629
                self.match(AmberPTParser.Simple_name)
                self.state = 634
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 635
            _la = self._input.LA(1)
            if not(_la==AmberPTParser.EOF or _la==AmberPTParser.FLAG_A):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Format_functionContext(ParserRuleContext):

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

        def FORMAT(self):
            return self.getToken(AmberPTParser.FORMAT, 0)

        def Fortran_format_A(self):
            return self.getToken(AmberPTParser.Fortran_format_A, 0)

        def Fortran_format_I(self):
            return self.getToken(AmberPTParser.Fortran_format_I, 0)

        def Fortran_format_E(self):
            return self.getToken(AmberPTParser.Fortran_format_E, 0)

        def getRuleIndex(self):
            return AmberPTParser.RULE_format_function

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

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




    def format_function(self):

        localctx = AmberPTParser.Format_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_format_function)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637
            self.match(AmberPTParser.FORMAT)
            self.state = 638
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << AmberPTParser.Fortran_format_A) | (1 << AmberPTParser.Fortran_format_I) | (1 << AmberPTParser.Fortran_format_E))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





