From 4796c56c355320ccbe62861762d198353741e123 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Sun, 9 Feb 2020 01:29:58 +0100 Subject: [PATCH] antlr code back --- parser/src/prog8/parser/prog8Lexer.java | 515 ++ parser/src/prog8/parser/prog8Parser.java | 5570 ++++++++++++++++++++++ 2 files changed, 6085 insertions(+) create mode 100644 parser/src/prog8/parser/prog8Lexer.java create mode 100644 parser/src/prog8/parser/prog8Parser.java diff --git a/parser/src/prog8/parser/prog8Lexer.java b/parser/src/prog8/parser/prog8Lexer.java new file mode 100644 index 000000000..666b858b0 --- /dev/null +++ b/parser/src/prog8/parser/prog8Lexer.java @@ -0,0 +1,515 @@ +// Generated from prog8.g4 by ANTLR 4.8 + +package prog8.parser; + +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class prog8Lexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, + T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, + T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, + T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, + T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, + T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, + T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, + T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, + T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, + T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, + T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, + T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, + T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, + T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, + T__107=108, T__108=109, LINECOMMENT=110, COMMENT=111, WS=112, EOL=113, + VOID=114, NAME=115, DEC_INTEGER=116, HEX_INTEGER=117, BIN_INTEGER=118, + ADDRESS_OF=119, FLOAT_NUMBER=120, STRING=121, INLINEASMBLOCK=122, SINGLECHAR=123, + ZEROPAGE=124, ARRAYSIG=125; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", + "T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", + "T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "T__24", + "T__25", "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", "T__32", + "T__33", "T__34", "T__35", "T__36", "T__37", "T__38", "T__39", "T__40", + "T__41", "T__42", "T__43", "T__44", "T__45", "T__46", "T__47", "T__48", + "T__49", "T__50", "T__51", "T__52", "T__53", "T__54", "T__55", "T__56", + "T__57", "T__58", "T__59", "T__60", "T__61", "T__62", "T__63", "T__64", + "T__65", "T__66", "T__67", "T__68", "T__69", "T__70", "T__71", "T__72", + "T__73", "T__74", "T__75", "T__76", "T__77", "T__78", "T__79", "T__80", + "T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88", + "T__89", "T__90", "T__91", "T__92", "T__93", "T__94", "T__95", "T__96", + "T__97", "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", "T__104", + "T__105", "T__106", "T__107", "T__108", "LINECOMMENT", "COMMENT", "WS", + "EOL", "VOID", "NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", + "FLOAT_NUMBER", "FNUMBER", "STRING_ESCAPE_SEQ", "STRING", "INLINEASMBLOCK", + "SINGLECHAR", "ZEROPAGE", "ARRAYSIG" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", "'%zpreserved'", + "'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", "'%asmbinary'", + "'%option'", "','", "'='", "'const'", "'struct'", "'{'", "'}'", "'ubyte'", + "'byte'", "'uword'", "'word'", "'float'", "'str'", "'['", "']'", "'+='", + "'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'%='", "'<<='", + "'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", "'*'", "'/'", "'%'", + "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'^'", + "'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", "'('", "')'", + "'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", "'A'", "'X'", + "'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Pv'", "'.w'", + "'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", "'stack'", + "'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'if_z'", + "'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_vs'", + "'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", "'when'", + null, null, null, null, "'void'", null, null, null, null, "'&'", null, + null, null, null, "'@zp'", "'[]'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "VOID", "NAME", "DEC_INTEGER", + "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING", + "INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE", "ARRAYSIG" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public prog8Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "prog8.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 122: + STRING_action((RuleContext)_localctx, actionIndex); + break; + case 123: + INLINEASMBLOCK_action((RuleContext)_localctx, actionIndex); + break; + case 124: + SINGLECHAR_action((RuleContext)_localctx, actionIndex); + break; + } + } + private void STRING_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + + // get rid of the enclosing quotes + String s = getText(); + setText(s.substring(1, s.length() - 1)); + + break; + } + } + private void INLINEASMBLOCK_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + + // get rid of the enclosing double braces + String s = getText(); + setText(s.substring(2, s.length() - 2)); + + break; + } + } + private void SINGLECHAR_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + + // get rid of the enclosing quotes + String s = getText(); + setText(s.substring(1, s.length() - 1)); + + break; + } + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\177\u036d\b\1\4\2"+ + "\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\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\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+ + "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+ + "\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+ + " \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+ + "+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64"+ + "\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t"+ + "=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4"+ + "I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\t"+ + "T\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_"+ + "\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k"+ + "\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv"+ + "\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t"+ + "\u0080\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5"+ + "\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+ + "\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b"+ + "\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3"+ + "\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+ + "\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3"+ + "\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20"+ + "\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24"+ + "\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26"+ + "\3\26\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31"+ + "\3\31\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\34\3\35\3\35\3\35\3\36\3\36"+ + "\3\36\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3"+ + "$\3%\3%\3%\3%\3&\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3)\3)\3*\3*\3+\3+\3,\3"+ + ",\3,\3-\3-\3.\3.\3/\3/\3\60\3\60\3\60\3\61\3\61\3\61\3\62\3\62\3\63\3"+ + "\63\3\64\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\3\67\38\38"+ + "\39\39\3:\3:\3:\3;\3;\3;\3;\3;\3<\3<\3<\3<\3=\3=\3=\3>\3>\3>\3>\3?\3?"+ + "\3?\3?\3@\3@\3A\3A\3B\3B\3B\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E"+ + "\3E\3F\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3K\3L\3L"+ + "\3L\3M\3M\3M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3S"+ + "\3S\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3V\3V\3V\3V\3W\3W\3W\3X\3X\3X\3X"+ + "\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3\\\3"+ + "\\\3\\\3\\\3\\\3]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3"+ + "`\3`\3`\3`\3`\3a\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3"+ + "d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3"+ + "g\3g\3g\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3j\3j\3j\3k\3k\3k\3k\3k\3k\3l\3"+ + "l\3l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3o\3o\7o\u02ee\no\f"+ + "o\16o\u02f1\13o\3o\3o\3o\3o\3p\3p\7p\u02f9\np\fp\16p\u02fc\13p\3p\3p\3"+ + "q\3q\3q\3q\3r\6r\u0305\nr\rr\16r\u0306\3s\3s\3s\3s\3s\3t\3t\7t\u0310\n"+ + "t\ft\16t\u0313\13t\3u\3u\3u\6u\u0318\nu\ru\16u\u0319\5u\u031c\nu\3v\3"+ + "v\6v\u0320\nv\rv\16v\u0321\3w\3w\6w\u0326\nw\rw\16w\u0327\3x\3x\3y\3y"+ + "\3y\5y\u032f\ny\3y\5y\u0332\ny\3z\6z\u0335\nz\rz\16z\u0336\3z\3z\6z\u033b"+ + "\nz\rz\16z\u033c\5z\u033f\nz\3{\3{\3{\3{\5{\u0345\n{\3|\3|\3|\7|\u034a"+ + "\n|\f|\16|\u034d\13|\3|\3|\3|\3}\3}\3}\3}\6}\u0356\n}\r}\16}\u0357\3}"+ + "\3}\3}\3}\3}\3~\3~\3~\5~\u0362\n~\3~\3~\3~\3\177\3\177\3\177\3\177\3\u0080"+ + "\3\u0080\3\u0080\3\u0357\2\u0081\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23"+ + "\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31"+ + "\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60"+ + "_\61a\62c\63e\64g\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083C\u0085"+ + "D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099"+ + "N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00ad"+ + "X\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1"+ + "b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5"+ + "l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9"+ + "v\u00ebw\u00edx\u00efy\u00f1z\u00f3\2\u00f5\2\u00f7{\u00f9|\u00fb}\u00fd"+ + "~\u00ff\177\3\2\n\4\2\f\f\17\17\4\2\13\13\"\"\5\2C\\aac|\6\2\62;C\\aa"+ + "c|\5\2\62;CHch\4\2GGgg\4\2--//\6\2\f\f\16\17$$^^\2\u037c\2\3\3\2\2\2\2"+ + "\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2"+ + "\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2"+ + "\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2"+ + "\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2"+ + "\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2"+ + "\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2"+ + "K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3"+ + "\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2"+ + "\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2"+ + "q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3"+ + "\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2"+ + "\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f"+ + "\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2"+ + "\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1"+ + "\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2"+ + "\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3"+ + "\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2"+ + "\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5"+ + "\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2"+ + "\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7"+ + "\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2"+ + "\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9"+ + "\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2"+ + "\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff"+ + "\3\2\2\2\3\u0101\3\2\2\2\5\u0103\3\2\2\2\7\u0108\3\2\2\2\t\u0110\3\2\2"+ + "\2\13\u011a\3\2\2\2\r\u0124\3\2\2\2\17\u0130\3\2\2\2\21\u0139\3\2\2\2"+ + "\23\u0141\3\2\2\2\25\u014d\3\2\2\2\27\u0159\3\2\2\2\31\u0164\3\2\2\2\33"+ + "\u016c\3\2\2\2\35\u016e\3\2\2\2\37\u0170\3\2\2\2!\u0176\3\2\2\2#\u017d"+ + "\3\2\2\2%\u017f\3\2\2\2\'\u0181\3\2\2\2)\u0187\3\2\2\2+\u018c\3\2\2\2"+ + "-\u0192\3\2\2\2/\u0197\3\2\2\2\61\u019d\3\2\2\2\63\u01a1\3\2\2\2\65\u01a3"+ + "\3\2\2\2\67\u01a5\3\2\2\29\u01a8\3\2\2\2;\u01ab\3\2\2\2=\u01ae\3\2\2\2"+ + "?\u01b1\3\2\2\2A\u01b5\3\2\2\2C\u01b8\3\2\2\2E\u01bb\3\2\2\2G\u01be\3"+ + "\2\2\2I\u01c1\3\2\2\2K\u01c5\3\2\2\2M\u01c9\3\2\2\2O\u01cc\3\2\2\2Q\u01cf"+ + "\3\2\2\2S\u01d1\3\2\2\2U\u01d3\3\2\2\2W\u01d5\3\2\2\2Y\u01d8\3\2\2\2["+ + "\u01da\3\2\2\2]\u01dc\3\2\2\2_\u01de\3\2\2\2a\u01e1\3\2\2\2c\u01e4\3\2"+ + "\2\2e\u01e6\3\2\2\2g\u01e8\3\2\2\2i\u01eb\3\2\2\2k\u01ee\3\2\2\2m\u01f1"+ + "\3\2\2\2o\u01f4\3\2\2\2q\u01f6\3\2\2\2s\u01f8\3\2\2\2u\u01fb\3\2\2\2w"+ + "\u0200\3\2\2\2y\u0204\3\2\2\2{\u0207\3\2\2\2}\u020b\3\2\2\2\177\u020f"+ + "\3\2\2\2\u0081\u0211\3\2\2\2\u0083\u0213\3\2\2\2\u0085\u0216\3\2\2\2\u0087"+ + "\u0218\3\2\2\2\u0089\u021f\3\2\2\2\u008b\u0225\3\2\2\2\u008d\u022e\3\2"+ + "\2\2\u008f\u0230\3\2\2\2\u0091\u0232\3\2\2\2\u0093\u0234\3\2\2\2\u0095"+ + "\u0236\3\2\2\2\u0097\u0239\3\2\2\2\u0099\u023c\3\2\2\2\u009b\u023f\3\2"+ + "\2\2\u009d\u0242\3\2\2\2\u009f\u0245\3\2\2\2\u00a1\u0248\3\2\2\2\u00a3"+ + "\u024b\3\2\2\2\u00a5\u024e\3\2\2\2\u00a7\u0253\3\2\2\2\u00a9\u0259\3\2"+ + "\2\2\u00ab\u025e\3\2\2\2\u00ad\u0262\3\2\2\2\u00af\u0265\3\2\2\2\u00b1"+ + "\u026c\3\2\2\2\u00b3\u0272\3\2\2\2\u00b5\u027b\3\2\2\2\u00b7\u027e\3\2"+ + "\2\2\u00b9\u0283\3\2\2\2\u00bb\u0289\3\2\2\2\u00bd\u028f\3\2\2\2\u00bf"+ + "\u0295\3\2\2\2\u00c1\u029a\3\2\2\2\u00c3\u02a0\3\2\2\2\u00c5\u02a6\3\2"+ + "\2\2\u00c7\u02ac\3\2\2\2\u00c9\u02b3\3\2\2\2\u00cb\u02b9\3\2\2\2\u00cd"+ + "\u02c0\3\2\2\2\u00cf\u02c6\3\2\2\2\u00d1\u02cc\3\2\2\2\u00d3\u02d0\3\2"+ + "\2\2\u00d5\u02d3\3\2\2\2\u00d7\u02d9\3\2\2\2\u00d9\u02e0\3\2\2\2\u00db"+ + "\u02e6\3\2\2\2\u00dd\u02eb\3\2\2\2\u00df\u02f6\3\2\2\2\u00e1\u02ff\3\2"+ + "\2\2\u00e3\u0304\3\2\2\2\u00e5\u0308\3\2\2\2\u00e7\u030d\3\2\2\2\u00e9"+ + "\u031b\3\2\2\2\u00eb\u031d\3\2\2\2\u00ed\u0323\3\2\2\2\u00ef\u0329\3\2"+ + "\2\2\u00f1\u032b\3\2\2\2\u00f3\u0334\3\2\2\2\u00f5\u0344\3\2\2\2\u00f7"+ + "\u0346\3\2\2\2\u00f9\u0351\3\2\2\2\u00fb\u035e\3\2\2\2\u00fd\u0366\3\2"+ + "\2\2\u00ff\u036a\3\2\2\2\u0101\u0102\7<\2\2\u0102\4\3\2\2\2\u0103\u0104"+ + "\7i\2\2\u0104\u0105\7q\2\2\u0105\u0106\7v\2\2\u0106\u0107\7q\2\2\u0107"+ + "\6\3\2\2\2\u0108\u0109\7\'\2\2\u0109\u010a\7q\2\2\u010a\u010b\7w\2\2\u010b"+ + "\u010c\7v\2\2\u010c\u010d\7r\2\2\u010d\u010e\7w\2\2\u010e\u010f\7v\2\2"+ + "\u010f\b\3\2\2\2\u0110\u0111\7\'\2\2\u0111\u0112\7n\2\2\u0112\u0113\7"+ + "c\2\2\u0113\u0114\7w\2\2\u0114\u0115\7p\2\2\u0115\u0116\7e\2\2\u0116\u0117"+ + "\7j\2\2\u0117\u0118\7g\2\2\u0118\u0119\7t\2\2\u0119\n\3\2\2\2\u011a\u011b"+ + "\7\'\2\2\u011b\u011c\7|\2\2\u011c\u011d\7g\2\2\u011d\u011e\7t\2\2\u011e"+ + "\u011f\7q\2\2\u011f\u0120\7r\2\2\u0120\u0121\7c\2\2\u0121\u0122\7i\2\2"+ + "\u0122\u0123\7g\2\2\u0123\f\3\2\2\2\u0124\u0125\7\'\2\2\u0125\u0126\7"+ + "|\2\2\u0126\u0127\7r\2\2\u0127\u0128\7t\2\2\u0128\u0129\7g\2\2\u0129\u012a"+ + "\7u\2\2\u012a\u012b\7g\2\2\u012b\u012c\7t\2\2\u012c\u012d\7x\2\2\u012d"+ + "\u012e\7g\2\2\u012e\u012f\7f\2\2\u012f\16\3\2\2\2\u0130\u0131\7\'\2\2"+ + "\u0131\u0132\7c\2\2\u0132\u0133\7f\2\2\u0133\u0134\7f\2\2\u0134\u0135"+ + "\7t\2\2\u0135\u0136\7g\2\2\u0136\u0137\7u\2\2\u0137\u0138\7u\2\2\u0138"+ + "\20\3\2\2\2\u0139\u013a\7\'\2\2\u013a\u013b\7k\2\2\u013b\u013c\7o\2\2"+ + "\u013c\u013d\7r\2\2\u013d\u013e\7q\2\2\u013e\u013f\7t\2\2\u013f\u0140"+ + "\7v\2\2\u0140\22\3\2\2\2\u0141\u0142\7\'\2\2\u0142\u0143\7d\2\2\u0143"+ + "\u0144\7t\2\2\u0144\u0145\7g\2\2\u0145\u0146\7c\2\2\u0146\u0147\7m\2\2"+ + "\u0147\u0148\7r\2\2\u0148\u0149\7q\2\2\u0149\u014a\7k\2\2\u014a\u014b"+ + "\7p\2\2\u014b\u014c\7v\2\2\u014c\24\3\2\2\2\u014d\u014e\7\'\2\2\u014e"+ + "\u014f\7c\2\2\u014f\u0150\7u\2\2\u0150\u0151\7o\2\2\u0151\u0152\7k\2\2"+ + "\u0152\u0153\7p\2\2\u0153\u0154\7e\2\2\u0154\u0155\7n\2\2\u0155\u0156"+ + "\7w\2\2\u0156\u0157\7f\2\2\u0157\u0158\7g\2\2\u0158\26\3\2\2\2\u0159\u015a"+ + "\7\'\2\2\u015a\u015b\7c\2\2\u015b\u015c\7u\2\2\u015c\u015d\7o\2\2\u015d"+ + "\u015e\7d\2\2\u015e\u015f\7k\2\2\u015f\u0160\7p\2\2\u0160\u0161\7c\2\2"+ + "\u0161\u0162\7t\2\2\u0162\u0163\7{\2\2\u0163\30\3\2\2\2\u0164\u0165\7"+ + "\'\2\2\u0165\u0166\7q\2\2\u0166\u0167\7r\2\2\u0167\u0168\7v\2\2\u0168"+ + "\u0169\7k\2\2\u0169\u016a\7q\2\2\u016a\u016b\7p\2\2\u016b\32\3\2\2\2\u016c"+ + "\u016d\7.\2\2\u016d\34\3\2\2\2\u016e\u016f\7?\2\2\u016f\36\3\2\2\2\u0170"+ + "\u0171\7e\2\2\u0171\u0172\7q\2\2\u0172\u0173\7p\2\2\u0173\u0174\7u\2\2"+ + "\u0174\u0175\7v\2\2\u0175 \3\2\2\2\u0176\u0177\7u\2\2\u0177\u0178\7v\2"+ + "\2\u0178\u0179\7t\2\2\u0179\u017a\7w\2\2\u017a\u017b\7e\2\2\u017b\u017c"+ + "\7v\2\2\u017c\"\3\2\2\2\u017d\u017e\7}\2\2\u017e$\3\2\2\2\u017f\u0180"+ + "\7\177\2\2\u0180&\3\2\2\2\u0181\u0182\7w\2\2\u0182\u0183\7d\2\2\u0183"+ + "\u0184\7{\2\2\u0184\u0185\7v\2\2\u0185\u0186\7g\2\2\u0186(\3\2\2\2\u0187"+ + "\u0188\7d\2\2\u0188\u0189\7{\2\2\u0189\u018a\7v\2\2\u018a\u018b\7g\2\2"+ + "\u018b*\3\2\2\2\u018c\u018d\7w\2\2\u018d\u018e\7y\2\2\u018e\u018f\7q\2"+ + "\2\u018f\u0190\7t\2\2\u0190\u0191\7f\2\2\u0191,\3\2\2\2\u0192\u0193\7"+ + "y\2\2\u0193\u0194\7q\2\2\u0194\u0195\7t\2\2\u0195\u0196\7f\2\2\u0196."+ + "\3\2\2\2\u0197\u0198\7h\2\2\u0198\u0199\7n\2\2\u0199\u019a\7q\2\2\u019a"+ + "\u019b\7c\2\2\u019b\u019c\7v\2\2\u019c\60\3\2\2\2\u019d\u019e\7u\2\2\u019e"+ + "\u019f\7v\2\2\u019f\u01a0\7t\2\2\u01a0\62\3\2\2\2\u01a1\u01a2\7]\2\2\u01a2"+ + "\64\3\2\2\2\u01a3\u01a4\7_\2\2\u01a4\66\3\2\2\2\u01a5\u01a6\7-\2\2\u01a6"+ + "\u01a7\7?\2\2\u01a78\3\2\2\2\u01a8\u01a9\7/\2\2\u01a9\u01aa\7?\2\2\u01aa"+ + ":\3\2\2\2\u01ab\u01ac\7\61\2\2\u01ac\u01ad\7?\2\2\u01ad<\3\2\2\2\u01ae"+ + "\u01af\7,\2\2\u01af\u01b0\7?\2\2\u01b0>\3\2\2\2\u01b1\u01b2\7,\2\2\u01b2"+ + "\u01b3\7,\2\2\u01b3\u01b4\7?\2\2\u01b4@\3\2\2\2\u01b5\u01b6\7(\2\2\u01b6"+ + "\u01b7\7?\2\2\u01b7B\3\2\2\2\u01b8\u01b9\7~\2\2\u01b9\u01ba\7?\2\2\u01ba"+ + "D\3\2\2\2\u01bb\u01bc\7`\2\2\u01bc\u01bd\7?\2\2\u01bdF\3\2\2\2\u01be\u01bf"+ + "\7\'\2\2\u01bf\u01c0\7?\2\2\u01c0H\3\2\2\2\u01c1\u01c2\7>\2\2\u01c2\u01c3"+ + "\7>\2\2\u01c3\u01c4\7?\2\2\u01c4J\3\2\2\2\u01c5\u01c6\7@\2\2\u01c6\u01c7"+ + "\7@\2\2\u01c7\u01c8\7?\2\2\u01c8L\3\2\2\2\u01c9\u01ca\7-\2\2\u01ca\u01cb"+ + "\7-\2\2\u01cbN\3\2\2\2\u01cc\u01cd\7/\2\2\u01cd\u01ce\7/\2\2\u01ceP\3"+ + "\2\2\2\u01cf\u01d0\7-\2\2\u01d0R\3\2\2\2\u01d1\u01d2\7/\2\2\u01d2T\3\2"+ + "\2\2\u01d3\u01d4\7\u0080\2\2\u01d4V\3\2\2\2\u01d5\u01d6\7,\2\2\u01d6\u01d7"+ + "\7,\2\2\u01d7X\3\2\2\2\u01d8\u01d9\7,\2\2\u01d9Z\3\2\2\2\u01da\u01db\7"+ + "\61\2\2\u01db\\\3\2\2\2\u01dc\u01dd\7\'\2\2\u01dd^\3\2\2\2\u01de\u01df"+ + "\7>\2\2\u01df\u01e0\7>\2\2\u01e0`\3\2\2\2\u01e1\u01e2\7@\2\2\u01e2\u01e3"+ + "\7@\2\2\u01e3b\3\2\2\2\u01e4\u01e5\7>\2\2\u01e5d\3\2\2\2\u01e6\u01e7\7"+ + "@\2\2\u01e7f\3\2\2\2\u01e8\u01e9\7>\2\2\u01e9\u01ea\7?\2\2\u01eah\3\2"+ + "\2\2\u01eb\u01ec\7@\2\2\u01ec\u01ed\7?\2\2\u01edj\3\2\2\2\u01ee\u01ef"+ + "\7?\2\2\u01ef\u01f0\7?\2\2\u01f0l\3\2\2\2\u01f1\u01f2\7#\2\2\u01f2\u01f3"+ + "\7?\2\2\u01f3n\3\2\2\2\u01f4\u01f5\7`\2\2\u01f5p\3\2\2\2\u01f6\u01f7\7"+ + "~\2\2\u01f7r\3\2\2\2\u01f8\u01f9\7v\2\2\u01f9\u01fa\7q\2\2\u01fat\3\2"+ + "\2\2\u01fb\u01fc\7u\2\2\u01fc\u01fd\7v\2\2\u01fd\u01fe\7g\2\2\u01fe\u01ff"+ + "\7r\2\2\u01ffv\3\2\2\2\u0200\u0201\7c\2\2\u0201\u0202\7p\2\2\u0202\u0203"+ + "\7f\2\2\u0203x\3\2\2\2\u0204\u0205\7q\2\2\u0205\u0206\7t\2\2\u0206z\3"+ + "\2\2\2\u0207\u0208\7z\2\2\u0208\u0209\7q\2\2\u0209\u020a\7t\2\2\u020a"+ + "|\3\2\2\2\u020b\u020c\7p\2\2\u020c\u020d\7q\2\2\u020d\u020e\7v\2\2\u020e"+ + "~\3\2\2\2\u020f\u0210\7*\2\2\u0210\u0080\3\2\2\2\u0211\u0212\7+\2\2\u0212"+ + "\u0082\3\2\2\2\u0213\u0214\7c\2\2\u0214\u0215\7u\2\2\u0215\u0084\3\2\2"+ + "\2\u0216\u0217\7B\2\2\u0217\u0086\3\2\2\2\u0218\u0219\7t\2\2\u0219\u021a"+ + "\7g\2\2\u021a\u021b\7v\2\2\u021b\u021c\7w\2\2\u021c\u021d\7t\2\2\u021d"+ + "\u021e\7p\2\2\u021e\u0088\3\2\2\2\u021f\u0220\7d\2\2\u0220\u0221\7t\2"+ + "\2\u0221\u0222\7g\2\2\u0222\u0223\7c\2\2\u0223\u0224\7m\2\2\u0224\u008a"+ + "\3\2\2\2\u0225\u0226\7e\2\2\u0226\u0227\7q\2\2\u0227\u0228\7p\2\2\u0228"+ + "\u0229\7v\2\2\u0229\u022a\7k\2\2\u022a\u022b\7p\2\2\u022b\u022c\7w\2\2"+ + "\u022c\u022d\7g\2\2\u022d\u008c\3\2\2\2\u022e\u022f\7\60\2\2\u022f\u008e"+ + "\3\2\2\2\u0230\u0231\7C\2\2\u0231\u0090\3\2\2\2\u0232\u0233\7Z\2\2\u0233"+ + "\u0092\3\2\2\2\u0234\u0235\7[\2\2\u0235\u0094\3\2\2\2\u0236\u0237\7C\2"+ + "\2\u0237\u0238\7Z\2\2\u0238\u0096\3\2\2\2\u0239\u023a\7C\2\2\u023a\u023b"+ + "\7[\2\2\u023b\u0098\3\2\2\2\u023c\u023d\7Z\2\2\u023d\u023e\7[\2\2\u023e"+ + "\u009a\3\2\2\2\u023f\u0240\7R\2\2\u0240\u0241\7e\2\2\u0241\u009c\3\2\2"+ + "\2\u0242\u0243\7R\2\2\u0243\u0244\7|\2\2\u0244\u009e\3\2\2\2\u0245\u0246"+ + "\7R\2\2\u0246\u0247\7p\2\2\u0247\u00a0\3\2\2\2\u0248\u0249\7R\2\2\u0249"+ + "\u024a\7x\2\2\u024a\u00a2\3\2\2\2\u024b\u024c\7\60\2\2\u024c\u024d\7y"+ + "\2\2\u024d\u00a4\3\2\2\2\u024e\u024f\7v\2\2\u024f\u0250\7t\2\2\u0250\u0251"+ + "\7w\2\2\u0251\u0252\7g\2\2\u0252\u00a6\3\2\2\2\u0253\u0254\7h\2\2\u0254"+ + "\u0255\7c\2\2\u0255\u0256\7n\2\2\u0256\u0257\7u\2\2\u0257\u0258\7g\2\2"+ + "\u0258\u00a8\3\2\2\2\u0259\u025a\7\'\2\2\u025a\u025b\7c\2\2\u025b\u025c"+ + "\7u\2\2\u025c\u025d\7o\2\2\u025d\u00aa\3\2\2\2\u025e\u025f\7u\2\2\u025f"+ + "\u0260\7w\2\2\u0260\u0261\7d\2\2\u0261\u00ac\3\2\2\2\u0262\u0263\7/\2"+ + "\2\u0263\u0264\7@\2\2\u0264\u00ae\3\2\2\2\u0265\u0266\7c\2\2\u0266\u0267"+ + "\7u\2\2\u0267\u0268\7o\2\2\u0268\u0269\7u\2\2\u0269\u026a\7w\2\2\u026a"+ + "\u026b\7d\2\2\u026b\u00b0\3\2\2\2\u026c\u026d\7u\2\2\u026d\u026e\7v\2"+ + "\2\u026e\u026f\7c\2\2\u026f\u0270\7e\2\2\u0270\u0271\7m\2\2\u0271\u00b2"+ + "\3\2\2\2\u0272\u0273\7e\2\2\u0273\u0274\7n\2\2\u0274\u0275\7q\2\2\u0275"+ + "\u0276\7d\2\2\u0276\u0277\7d\2\2\u0277\u0278\7g\2\2\u0278\u0279\7t\2\2"+ + "\u0279\u027a\7u\2\2\u027a\u00b4\3\2\2\2\u027b\u027c\7k\2\2\u027c\u027d"+ + "\7h\2\2\u027d\u00b6\3\2\2\2\u027e\u027f\7g\2\2\u027f\u0280\7n\2\2\u0280"+ + "\u0281\7u\2\2\u0281\u0282\7g\2\2\u0282\u00b8\3\2\2\2\u0283\u0284\7k\2"+ + "\2\u0284\u0285\7h\2\2\u0285\u0286\7a\2\2\u0286\u0287\7e\2\2\u0287\u0288"+ + "\7u\2\2\u0288\u00ba\3\2\2\2\u0289\u028a\7k\2\2\u028a\u028b\7h\2\2\u028b"+ + "\u028c\7a\2\2\u028c\u028d\7e\2\2\u028d\u028e\7e\2\2\u028e\u00bc\3\2\2"+ + "\2\u028f\u0290\7k\2\2\u0290\u0291\7h\2\2\u0291\u0292\7a\2\2\u0292\u0293"+ + "\7g\2\2\u0293\u0294\7s\2\2\u0294\u00be\3\2\2\2\u0295\u0296\7k\2\2\u0296"+ + "\u0297\7h\2\2\u0297\u0298\7a\2\2\u0298\u0299\7|\2\2\u0299\u00c0\3\2\2"+ + "\2\u029a\u029b\7k\2\2\u029b\u029c\7h\2\2\u029c\u029d\7a\2\2\u029d\u029e"+ + "\7p\2\2\u029e\u029f\7g\2\2\u029f\u00c2\3\2\2\2\u02a0\u02a1\7k\2\2\u02a1"+ + "\u02a2\7h\2\2\u02a2\u02a3\7a\2\2\u02a3\u02a4\7p\2\2\u02a4\u02a5\7|\2\2"+ + "\u02a5\u00c4\3\2\2\2\u02a6\u02a7\7k\2\2\u02a7\u02a8\7h\2\2\u02a8\u02a9"+ + "\7a\2\2\u02a9\u02aa\7r\2\2\u02aa\u02ab\7n\2\2\u02ab\u00c6\3\2\2\2\u02ac"+ + "\u02ad\7k\2\2\u02ad\u02ae\7h\2\2\u02ae\u02af\7a\2\2\u02af\u02b0\7r\2\2"+ + "\u02b0\u02b1\7q\2\2\u02b1\u02b2\7u\2\2\u02b2\u00c8\3\2\2\2\u02b3\u02b4"+ + "\7k\2\2\u02b4\u02b5\7h\2\2\u02b5\u02b6\7a\2\2\u02b6\u02b7\7o\2\2\u02b7"+ + "\u02b8\7k\2\2\u02b8\u00ca\3\2\2\2\u02b9\u02ba\7k\2\2\u02ba\u02bb\7h\2"+ + "\2\u02bb\u02bc\7a\2\2\u02bc\u02bd\7p\2\2\u02bd\u02be\7g\2\2\u02be\u02bf"+ + "\7i\2\2\u02bf\u00cc\3\2\2\2\u02c0\u02c1\7k\2\2\u02c1\u02c2\7h\2\2\u02c2"+ + "\u02c3\7a\2\2\u02c3\u02c4\7x\2\2\u02c4\u02c5\7u\2\2\u02c5\u00ce\3\2\2"+ + "\2\u02c6\u02c7\7k\2\2\u02c7\u02c8\7h\2\2\u02c8\u02c9\7a\2\2\u02c9\u02ca"+ + "\7x\2\2\u02ca\u02cb\7e\2\2\u02cb\u00d0\3\2\2\2\u02cc\u02cd\7h\2\2\u02cd"+ + "\u02ce\7q\2\2\u02ce\u02cf\7t\2\2\u02cf\u00d2\3\2\2\2\u02d0\u02d1\7k\2"+ + "\2\u02d1\u02d2\7p\2\2\u02d2\u00d4\3\2\2\2\u02d3\u02d4\7y\2\2\u02d4\u02d5"+ + "\7j\2\2\u02d5\u02d6\7k\2\2\u02d6\u02d7\7n\2\2\u02d7\u02d8\7g\2\2\u02d8"+ + "\u00d6\3\2\2\2\u02d9\u02da\7t\2\2\u02da\u02db\7g\2\2\u02db\u02dc\7r\2"+ + "\2\u02dc\u02dd\7g\2\2\u02dd\u02de\7c\2\2\u02de\u02df\7v\2\2\u02df\u00d8"+ + "\3\2\2\2\u02e0\u02e1\7w\2\2\u02e1\u02e2\7p\2\2\u02e2\u02e3\7v\2\2\u02e3"+ + "\u02e4\7k\2\2\u02e4\u02e5\7n\2\2\u02e5\u00da\3\2\2\2\u02e6\u02e7\7y\2"+ + "\2\u02e7\u02e8\7j\2\2\u02e8\u02e9\7g\2\2\u02e9\u02ea\7p\2\2\u02ea\u00dc"+ + "\3\2\2\2\u02eb\u02ef\t\2\2\2\u02ec\u02ee\t\3\2\2\u02ed\u02ec\3\2\2\2\u02ee"+ + "\u02f1\3\2\2\2\u02ef\u02ed\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0\u02f2\3\2"+ + "\2\2\u02f1\u02ef\3\2\2\2\u02f2\u02f3\5\u00dfp\2\u02f3\u02f4\3\2\2\2\u02f4"+ + "\u02f5\bo\2\2\u02f5\u00de\3\2\2\2\u02f6\u02fa\7=\2\2\u02f7\u02f9\n\2\2"+ + "\2\u02f8\u02f7\3\2\2\2\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb"+ + "\3\2\2\2\u02fb\u02fd\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd\u02fe\bp\2\2\u02fe"+ + "\u00e0\3\2\2\2\u02ff\u0300\t\3\2\2\u0300\u0301\3\2\2\2\u0301\u0302\bq"+ + "\3\2\u0302\u00e2\3\2\2\2\u0303\u0305\t\2\2\2\u0304\u0303\3\2\2\2\u0305"+ + "\u0306\3\2\2\2\u0306\u0304\3\2\2\2\u0306\u0307\3\2\2\2\u0307\u00e4\3\2"+ + "\2\2\u0308\u0309\7x\2\2\u0309\u030a\7q\2\2\u030a\u030b\7k\2\2\u030b\u030c"+ + "\7f\2\2\u030c\u00e6\3\2\2\2\u030d\u0311\t\4\2\2\u030e\u0310\t\5\2\2\u030f"+ + "\u030e\3\2\2\2\u0310\u0313\3\2\2\2\u0311\u030f\3\2\2\2\u0311\u0312\3\2"+ + "\2\2\u0312\u00e8\3\2\2\2\u0313\u0311\3\2\2\2\u0314\u031c\4\62;\2\u0315"+ + "\u0317\4\63;\2\u0316\u0318\4\62;\2\u0317\u0316\3\2\2\2\u0318\u0319\3\2"+ + "\2\2\u0319\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u031c\3\2\2\2\u031b"+ + "\u0314\3\2\2\2\u031b\u0315\3\2\2\2\u031c\u00ea\3\2\2\2\u031d\u031f\7&"+ + "\2\2\u031e\u0320\t\6\2\2\u031f\u031e\3\2\2\2\u0320\u0321\3\2\2\2\u0321"+ + "\u031f\3\2\2\2\u0321\u0322\3\2\2\2\u0322\u00ec\3\2\2\2\u0323\u0325\7\'"+ + "\2\2\u0324\u0326\4\62\63\2\u0325\u0324\3\2\2\2\u0326\u0327\3\2\2\2\u0327"+ + "\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u00ee\3\2\2\2\u0329\u032a\7("+ + "\2\2\u032a\u00f0\3\2\2\2\u032b\u0331\5\u00f3z\2\u032c\u032e\t\7\2\2\u032d"+ + "\u032f\t\b\2\2\u032e\u032d\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0330\3\2"+ + "\2\2\u0330\u0332\5\u00f3z\2\u0331\u032c\3\2\2\2\u0331\u0332\3\2\2\2\u0332"+ + "\u00f2\3\2\2\2\u0333\u0335\4\62;\2\u0334\u0333\3\2\2\2\u0335\u0336\3\2"+ + "\2\2\u0336\u0334\3\2\2\2\u0336\u0337\3\2\2\2\u0337\u033e\3\2\2\2\u0338"+ + "\u033a\7\60\2\2\u0339\u033b\4\62;\2\u033a\u0339\3\2\2\2\u033b\u033c\3"+ + "\2\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e"+ + "\u0338\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u00f4\3\2\2\2\u0340\u0341\7^"+ + "\2\2\u0341\u0345\13\2\2\2\u0342\u0343\7^\2\2\u0343\u0345\5\u00e3r\2\u0344"+ + "\u0340\3\2\2\2\u0344\u0342\3\2\2\2\u0345\u00f6\3\2\2\2\u0346\u034b\7$"+ + "\2\2\u0347\u034a\5\u00f5{\2\u0348\u034a\n\t\2\2\u0349\u0347\3\2\2\2\u0349"+ + "\u0348\3\2\2\2\u034a\u034d\3\2\2\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2"+ + "\2\2\u034c\u034e\3\2\2\2\u034d\u034b\3\2\2\2\u034e\u034f\7$\2\2\u034f"+ + "\u0350\b|\4\2\u0350\u00f8\3\2\2\2\u0351\u0352\7}\2\2\u0352\u0353\7}\2"+ + "\2\u0353\u0355\3\2\2\2\u0354\u0356\13\2\2\2\u0355\u0354\3\2\2\2\u0356"+ + "\u0357\3\2\2\2\u0357\u0358\3\2\2\2\u0357\u0355\3\2\2\2\u0358\u0359\3\2"+ + "\2\2\u0359\u035a\7\177\2\2\u035a\u035b\7\177\2\2\u035b\u035c\3\2\2\2\u035c"+ + "\u035d\b}\5\2\u035d\u00fa\3\2\2\2\u035e\u0361\7)\2\2\u035f\u0362\5\u00f5"+ + "{\2\u0360\u0362\n\t\2\2\u0361\u035f\3\2\2\2\u0361\u0360\3\2\2\2\u0362"+ + "\u0363\3\2\2\2\u0363\u0364\7)\2\2\u0364\u0365\b~\6\2\u0365\u00fc\3\2\2"+ + "\2\u0366\u0367\7B\2\2\u0367\u0368\7|\2\2\u0368\u0369\7r\2\2\u0369\u00fe"+ + "\3\2\2\2\u036a\u036b\7]\2\2\u036b\u036c\7_\2\2\u036c\u0100\3\2\2\2\26"+ + "\2\u02ef\u02fa\u0306\u0311\u0319\u031b\u031f\u0321\u0327\u032e\u0331\u0336"+ + "\u033c\u033e\u0344\u0349\u034b\u0357\u0361\7\2\3\2\b\2\2\3|\2\3}\3\3~"+ + "\4"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/parser/src/prog8/parser/prog8Parser.java b/parser/src/prog8/parser/prog8Parser.java new file mode 100644 index 000000000..33d49e8c8 --- /dev/null +++ b/parser/src/prog8/parser/prog8Parser.java @@ -0,0 +1,5570 @@ +// Generated from prog8.g4 by ANTLR 4.8 + +package prog8.parser; + +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class prog8Parser extends Parser { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, + T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, + T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, + T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, + T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, + T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, + T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, + T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, + T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, + T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, + T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, + T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, + T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, + T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, + T__107=108, T__108=109, LINECOMMENT=110, COMMENT=111, WS=112, EOL=113, + VOID=114, NAME=115, DEC_INTEGER=116, HEX_INTEGER=117, BIN_INTEGER=118, + ADDRESS_OF=119, FLOAT_NUMBER=120, STRING=121, INLINEASMBLOCK=122, SINGLECHAR=123, + ZEROPAGE=124, ARRAYSIG=125; + public static final int + RULE_module = 0, RULE_modulestatement = 1, RULE_block = 2, RULE_statement = 3, + RULE_labeldef = 4, RULE_unconditionaljump = 5, RULE_directive = 6, RULE_directivearg = 7, + RULE_vardecl = 8, RULE_structvardecl = 9, RULE_varinitializer = 10, RULE_structvarinitializer = 11, + RULE_constdecl = 12, RULE_memoryvardecl = 13, RULE_structdecl = 14, RULE_datatype = 15, + RULE_arrayindex = 16, RULE_assignment = 17, RULE_augassignment = 18, RULE_assign_target = 19, + RULE_postincrdecr = 20, RULE_expression = 21, RULE_typecast = 22, RULE_arrayindexed = 23, + RULE_directmemory = 24, RULE_addressof = 25, RULE_functioncall = 26, RULE_functioncall_stmt = 27, + RULE_expression_list = 28, RULE_returnstmt = 29, RULE_breakstmt = 30, + RULE_continuestmt = 31, RULE_identifier = 32, RULE_scoped_identifier = 33, + RULE_register = 34, RULE_registerorpair = 35, RULE_statusregister = 36, + RULE_integerliteral = 37, RULE_wordsuffix = 38, RULE_booleanliteral = 39, + RULE_arrayliteral = 40, RULE_structliteral = 41, RULE_stringliteral = 42, + RULE_charliteral = 43, RULE_floatliteral = 44, RULE_literalvalue = 45, + RULE_inlineasm = 46, RULE_subroutine = 47, RULE_sub_return_part = 48, + RULE_statement_block = 49, RULE_sub_params = 50, RULE_sub_returns = 51, + RULE_asmsubroutine = 52, RULE_asmsub_address = 53, RULE_asmsub_params = 54, + RULE_asmsub_param = 55, RULE_asmsub_clobbers = 56, RULE_clobber = 57, + RULE_asmsub_returns = 58, RULE_asmsub_return = 59, RULE_if_stmt = 60, + RULE_else_part = 61, RULE_branch_stmt = 62, RULE_branchcondition = 63, + RULE_forloop = 64, RULE_whileloop = 65, RULE_repeatloop = 66, RULE_whenstmt = 67, + RULE_when_choice = 68; + private static String[] makeRuleNames() { + return new String[] { + "module", "modulestatement", "block", "statement", "labeldef", "unconditionaljump", + "directive", "directivearg", "vardecl", "structvardecl", "varinitializer", + "structvarinitializer", "constdecl", "memoryvardecl", "structdecl", "datatype", + "arrayindex", "assignment", "augassignment", "assign_target", "postincrdecr", + "expression", "typecast", "arrayindexed", "directmemory", "addressof", + "functioncall", "functioncall_stmt", "expression_list", "returnstmt", + "breakstmt", "continuestmt", "identifier", "scoped_identifier", "register", + "registerorpair", "statusregister", "integerliteral", "wordsuffix", "booleanliteral", + "arrayliteral", "structliteral", "stringliteral", "charliteral", "floatliteral", + "literalvalue", "inlineasm", "subroutine", "sub_return_part", "statement_block", + "sub_params", "sub_returns", "asmsubroutine", "asmsub_address", "asmsub_params", + "asmsub_param", "asmsub_clobbers", "clobber", "asmsub_returns", "asmsub_return", + "if_stmt", "else_part", "branch_stmt", "branchcondition", "forloop", + "whileloop", "repeatloop", "whenstmt", "when_choice" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", "'%zpreserved'", + "'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", "'%asmbinary'", + "'%option'", "','", "'='", "'const'", "'struct'", "'{'", "'}'", "'ubyte'", + "'byte'", "'uword'", "'word'", "'float'", "'str'", "'['", "']'", "'+='", + "'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'%='", "'<<='", + "'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", "'*'", "'/'", "'%'", + "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'^'", + "'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", "'('", "')'", + "'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", "'A'", "'X'", + "'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Pv'", "'.w'", + "'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", "'stack'", + "'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'if_z'", + "'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_vs'", + "'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", "'when'", + null, null, null, null, "'void'", null, null, null, null, "'&'", null, + null, null, null, "'@zp'", "'[]'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "VOID", "NAME", "DEC_INTEGER", + "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING", + "INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE", "ARRAYSIG" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "prog8.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public prog8Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class ModuleContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(prog8Parser.EOF, 0); } + public List modulestatement() { + return getRuleContexts(ModulestatementContext.class); + } + public ModulestatementContext modulestatement(int i) { + return getRuleContext(ModulestatementContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public ModuleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_module; } + } + + public final ModuleContext module() throws RecognitionException { + ModuleContext _localctx = new ModuleContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_module); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(142); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11))) != 0) || _la==EOL || _la==NAME) { + { + setState(140); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case NAME: + { + setState(138); + modulestatement(); + } + break; + case EOL: + { + setState(139); + match(EOL); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(144); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(145); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ModulestatementContext extends ParserRuleContext { + public DirectiveContext directive() { + return getRuleContext(DirectiveContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ModulestatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_modulestatement; } + } + + public final ModulestatementContext modulestatement() throws RecognitionException { + ModulestatementContext _localctx = new ModulestatementContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_modulestatement); + try { + setState(149); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + enterOuterAlt(_localctx, 1); + { + setState(147); + directive(); + } + break; + case NAME: + enterOuterAlt(_localctx, 2); + { + setState(148); + block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public IntegerliteralContext integerliteral() { + return getRuleContext(IntegerliteralContext.class,0); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(151); + identifier(); + setState(153); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (DEC_INTEGER - 116)) | (1L << (HEX_INTEGER - 116)) | (1L << (BIN_INTEGER - 116)))) != 0)) { + { + setState(152); + integerliteral(); + } + } + + setState(155); + statement_block(); + setState(156); + match(EOL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementContext extends ParserRuleContext { + public DirectiveContext directive() { + return getRuleContext(DirectiveContext.class,0); + } + public VarinitializerContext varinitializer() { + return getRuleContext(VarinitializerContext.class,0); + } + public StructvarinitializerContext structvarinitializer() { + return getRuleContext(StructvarinitializerContext.class,0); + } + public VardeclContext vardecl() { + return getRuleContext(VardeclContext.class,0); + } + public StructvardeclContext structvardecl() { + return getRuleContext(StructvardeclContext.class,0); + } + public ConstdeclContext constdecl() { + return getRuleContext(ConstdeclContext.class,0); + } + public MemoryvardeclContext memoryvardecl() { + return getRuleContext(MemoryvardeclContext.class,0); + } + public StructdeclContext structdecl() { + return getRuleContext(StructdeclContext.class,0); + } + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class,0); + } + public AugassignmentContext augassignment() { + return getRuleContext(AugassignmentContext.class,0); + } + public UnconditionaljumpContext unconditionaljump() { + return getRuleContext(UnconditionaljumpContext.class,0); + } + public PostincrdecrContext postincrdecr() { + return getRuleContext(PostincrdecrContext.class,0); + } + public Functioncall_stmtContext functioncall_stmt() { + return getRuleContext(Functioncall_stmtContext.class,0); + } + public If_stmtContext if_stmt() { + return getRuleContext(If_stmtContext.class,0); + } + public Branch_stmtContext branch_stmt() { + return getRuleContext(Branch_stmtContext.class,0); + } + public SubroutineContext subroutine() { + return getRuleContext(SubroutineContext.class,0); + } + public AsmsubroutineContext asmsubroutine() { + return getRuleContext(AsmsubroutineContext.class,0); + } + public InlineasmContext inlineasm() { + return getRuleContext(InlineasmContext.class,0); + } + public ReturnstmtContext returnstmt() { + return getRuleContext(ReturnstmtContext.class,0); + } + public ForloopContext forloop() { + return getRuleContext(ForloopContext.class,0); + } + public WhileloopContext whileloop() { + return getRuleContext(WhileloopContext.class,0); + } + public RepeatloopContext repeatloop() { + return getRuleContext(RepeatloopContext.class,0); + } + public WhenstmtContext whenstmt() { + return getRuleContext(WhenstmtContext.class,0); + } + public BreakstmtContext breakstmt() { + return getRuleContext(BreakstmtContext.class,0); + } + public ContinuestmtContext continuestmt() { + return getRuleContext(ContinuestmtContext.class,0); + } + public LabeldefContext labeldef() { + return getRuleContext(LabeldefContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_statement); + try { + setState(184); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(158); + directive(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(159); + varinitializer(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(160); + structvarinitializer(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(161); + vardecl(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(162); + structvardecl(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(163); + constdecl(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(164); + memoryvardecl(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(165); + structdecl(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(166); + assignment(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(167); + augassignment(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(168); + unconditionaljump(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(169); + postincrdecr(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(170); + functioncall_stmt(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(171); + if_stmt(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(172); + branch_stmt(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(173); + subroutine(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(174); + asmsubroutine(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(175); + inlineasm(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(176); + returnstmt(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(177); + forloop(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(178); + whileloop(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(179); + repeatloop(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(180); + whenstmt(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(181); + breakstmt(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(182); + continuestmt(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(183); + labeldef(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LabeldefContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public LabeldefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeldef; } + } + + public final LabeldefContext labeldef() throws RecognitionException { + LabeldefContext _localctx = new LabeldefContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_labeldef); + try { + enterOuterAlt(_localctx, 1); + { + setState(186); + identifier(); + setState(187); + match(T__0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnconditionaljumpContext extends ParserRuleContext { + public IntegerliteralContext integerliteral() { + return getRuleContext(IntegerliteralContext.class,0); + } + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public UnconditionaljumpContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unconditionaljump; } + } + + public final UnconditionaljumpContext unconditionaljump() throws RecognitionException { + UnconditionaljumpContext _localctx = new UnconditionaljumpContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_unconditionaljump); + try { + enterOuterAlt(_localctx, 1); + { + setState(189); + match(T__1); + setState(192); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEC_INTEGER: + case HEX_INTEGER: + case BIN_INTEGER: + { + setState(190); + integerliteral(); + } + break; + case NAME: + { + setState(191); + scoped_identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DirectiveContext extends ParserRuleContext { + public Token directivename; + public List directivearg() { + return getRuleContexts(DirectiveargContext.class); + } + public DirectiveargContext directivearg(int i) { + return getRuleContext(DirectiveargContext.class,i); + } + public DirectiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_directive; } + } + + public final DirectiveContext directive() throws RecognitionException { + DirectiveContext _localctx = new DirectiveContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_directive); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(194); + ((DirectiveContext)_localctx).directivename = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11))) != 0)) ) { + ((DirectiveContext)_localctx).directivename = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(206); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) { + case 1: + { + setState(196); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { + case 1: + { + setState(195); + directivearg(); + } + break; + } + } + break; + case 2: + { + setState(198); + directivearg(); + setState(203); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(199); + match(T__12); + setState(200); + directivearg(); + } + } + setState(205); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DirectiveargContext extends ParserRuleContext { + public StringliteralContext stringliteral() { + return getRuleContext(StringliteralContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public IntegerliteralContext integerliteral() { + return getRuleContext(IntegerliteralContext.class,0); + } + public DirectiveargContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_directivearg; } + } + + public final DirectiveargContext directivearg() throws RecognitionException { + DirectiveargContext _localctx = new DirectiveargContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_directivearg); + try { + setState(211); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + enterOuterAlt(_localctx, 1); + { + setState(208); + stringliteral(); + } + break; + case NAME: + enterOuterAlt(_localctx, 2); + { + setState(209); + identifier(); + } + break; + case DEC_INTEGER: + case HEX_INTEGER: + case BIN_INTEGER: + enterOuterAlt(_localctx, 3); + { + setState(210); + integerliteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VardeclContext extends ParserRuleContext { + public IdentifierContext varname; + public DatatypeContext datatype() { + return getRuleContext(DatatypeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ZEROPAGE() { return getToken(prog8Parser.ZEROPAGE, 0); } + public ArrayindexContext arrayindex() { + return getRuleContext(ArrayindexContext.class,0); + } + public TerminalNode ARRAYSIG() { return getToken(prog8Parser.ARRAYSIG, 0); } + public VardeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vardecl; } + } + + public final VardeclContext vardecl() throws RecognitionException { + VardeclContext _localctx = new VardeclContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_vardecl); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(213); + datatype(); + setState(215); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ZEROPAGE) { + { + setState(214); + match(ZEROPAGE); + } + } + + setState(219); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__24: + { + setState(217); + arrayindex(); + } + break; + case ARRAYSIG: + { + setState(218); + match(ARRAYSIG); + } + break; + case NAME: + break; + default: + break; + } + setState(221); + ((VardeclContext)_localctx).varname = identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StructvardeclContext extends ParserRuleContext { + public IdentifierContext structname; + public IdentifierContext varname; + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public StructvardeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_structvardecl; } + } + + public final StructvardeclContext structvardecl() throws RecognitionException { + StructvardeclContext _localctx = new StructvardeclContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_structvardecl); + try { + enterOuterAlt(_localctx, 1); + { + setState(223); + ((StructvardeclContext)_localctx).structname = identifier(); + setState(224); + ((StructvardeclContext)_localctx).varname = identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VarinitializerContext extends ParserRuleContext { + public VardeclContext vardecl() { + return getRuleContext(VardeclContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public VarinitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_varinitializer; } + } + + public final VarinitializerContext varinitializer() throws RecognitionException { + VarinitializerContext _localctx = new VarinitializerContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_varinitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(226); + vardecl(); + setState(227); + match(T__13); + setState(228); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StructvarinitializerContext extends ParserRuleContext { + public StructvardeclContext structvardecl() { + return getRuleContext(StructvardeclContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StructvarinitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_structvarinitializer; } + } + + public final StructvarinitializerContext structvarinitializer() throws RecognitionException { + StructvarinitializerContext _localctx = new StructvarinitializerContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_structvarinitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(230); + structvardecl(); + setState(231); + match(T__13); + setState(232); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstdeclContext extends ParserRuleContext { + public VarinitializerContext varinitializer() { + return getRuleContext(VarinitializerContext.class,0); + } + public ConstdeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constdecl; } + } + + public final ConstdeclContext constdecl() throws RecognitionException { + ConstdeclContext _localctx = new ConstdeclContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_constdecl); + try { + enterOuterAlt(_localctx, 1); + { + setState(234); + match(T__14); + setState(235); + varinitializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemoryvardeclContext extends ParserRuleContext { + public TerminalNode ADDRESS_OF() { return getToken(prog8Parser.ADDRESS_OF, 0); } + public VarinitializerContext varinitializer() { + return getRuleContext(VarinitializerContext.class,0); + } + public MemoryvardeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memoryvardecl; } + } + + public final MemoryvardeclContext memoryvardecl() throws RecognitionException { + MemoryvardeclContext _localctx = new MemoryvardeclContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_memoryvardecl); + try { + enterOuterAlt(_localctx, 1); + { + setState(237); + match(ADDRESS_OF); + setState(238); + varinitializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StructdeclContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public List vardecl() { + return getRuleContexts(VardeclContext.class); + } + public VardeclContext vardecl(int i) { + return getRuleContext(VardeclContext.class,i); + } + public StructdeclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_structdecl; } + } + + public final StructdeclContext structdecl() throws RecognitionException { + StructdeclContext _localctx = new StructdeclContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_structdecl); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(240); + match(T__15); + setState(241); + identifier(); + setState(242); + match(T__16); + setState(243); + match(EOL); + setState(244); + vardecl(); + setState(249); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,12,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(245); + match(EOL); + setState(246); + vardecl(); + } + } + } + setState(251); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,12,_ctx); + } + setState(253); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(252); + match(EOL); + } + } + + setState(255); + match(T__17); + setState(256); + match(EOL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DatatypeContext extends ParserRuleContext { + public DatatypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_datatype; } + } + + public final DatatypeContext datatype() throws RecognitionException { + DatatypeContext _localctx = new DatatypeContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_datatype); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(258); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayindexContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ArrayindexContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayindex; } + } + + public final ArrayindexContext arrayindex() throws RecognitionException { + ArrayindexContext _localctx = new ArrayindexContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_arrayindex); + try { + enterOuterAlt(_localctx, 1); + { + setState(260); + match(T__24); + setState(261); + expression(0); + setState(262); + match(T__25); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentContext extends ParserRuleContext { + public Assign_targetContext assign_target() { + return getRuleContext(Assign_targetContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignment; } + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_assignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(264); + assign_target(); + setState(265); + match(T__13); + setState(266); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AugassignmentContext extends ParserRuleContext { + public Token operator; + public Assign_targetContext assign_target() { + return getRuleContext(Assign_targetContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public AugassignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_augassignment; } + } + + public final AugassignmentContext augassignment() throws RecognitionException { + AugassignmentContext _localctx = new AugassignmentContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_augassignment); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(268); + assign_target(); + setState(269); + ((AugassignmentContext)_localctx).operator = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36))) != 0)) ) { + ((AugassignmentContext)_localctx).operator = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(270); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Assign_targetContext extends ParserRuleContext { + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public ArrayindexedContext arrayindexed() { + return getRuleContext(ArrayindexedContext.class,0); + } + public DirectmemoryContext directmemory() { + return getRuleContext(DirectmemoryContext.class,0); + } + public Assign_targetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assign_target; } + } + + public final Assign_targetContext assign_target() throws RecognitionException { + Assign_targetContext _localctx = new Assign_targetContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_assign_target); + try { + setState(276); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(272); + register(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(273); + scoped_identifier(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(274); + arrayindexed(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(275); + directmemory(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostincrdecrContext extends ParserRuleContext { + public Token operator; + public Assign_targetContext assign_target() { + return getRuleContext(Assign_targetContext.class,0); + } + public PostincrdecrContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postincrdecr; } + } + + public final PostincrdecrContext postincrdecr() throws RecognitionException { + PostincrdecrContext _localctx = new PostincrdecrContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_postincrdecr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(278); + assign_target(); + setState(279); + ((PostincrdecrContext)_localctx).operator = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==T__37 || _la==T__38) ) { + ((PostincrdecrContext)_localctx).operator = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionContext extends ParserRuleContext { + public ExpressionContext left; + public ExpressionContext rangefrom; + public Token prefix; + public Token bop; + public ExpressionContext right; + public ExpressionContext rangeto; + public ExpressionContext rangestep; + public FunctioncallContext functioncall() { + return getRuleContext(FunctioncallContext.class,0); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public LiteralvalueContext literalvalue() { + return getRuleContext(LiteralvalueContext.class,0); + } + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public ArrayindexedContext arrayindexed() { + return getRuleContext(ArrayindexedContext.class,0); + } + public DirectmemoryContext directmemory() { + return getRuleContext(DirectmemoryContext.class,0); + } + public AddressofContext addressof() { + return getRuleContext(AddressofContext.class,0); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public TerminalNode ADDRESS_OF() { return getToken(prog8Parser.ADDRESS_OF, 0); } + public TypecastContext typecast() { + return getRuleContext(TypecastContext.class,0); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + } + + public final ExpressionContext expression() throws RecognitionException { + return expression(0); + } + + private ExpressionContext expression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); + ExpressionContext _prevctx = _localctx; + int _startState = 42; + enterRecursionRule(_localctx, 42, RULE_expression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(297); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { + case 1: + { + setState(282); + functioncall(); + } + break; + case 2: + { + setState(283); + ((ExpressionContext)_localctx).prefix = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__39) | (1L << T__40) | (1L << T__41))) != 0)) ) { + ((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(284); + expression(23); + } + break; + case 3: + { + setState(285); + ((ExpressionContext)_localctx).prefix = match(T__61); + setState(286); + expression(9); + } + break; + case 4: + { + setState(287); + literalvalue(); + } + break; + case 5: + { + setState(288); + register(); + } + break; + case 6: + { + setState(289); + scoped_identifier(); + } + break; + case 7: + { + setState(290); + arrayindexed(); + } + break; + case 8: + { + setState(291); + directmemory(); + } + break; + case 9: + { + setState(292); + addressof(); + } + break; + case 10: + { + setState(293); + match(T__62); + setState(294); + expression(0); + setState(295); + match(T__63); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(418); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,42,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(416); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { + case 1: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(299); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(301); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(300); + match(EOL); + } + } + + setState(303); + ((ExpressionContext)_localctx).bop = match(T__42); + setState(305); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(304); + match(EOL); + } + } + + setState(307); + ((ExpressionContext)_localctx).right = expression(23); + } + break; + case 2: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(308); + if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); + setState(310); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(309); + match(EOL); + } + } + + setState(312); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__43) | (1L << T__44) | (1L << T__45))) != 0)) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(314); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(313); + match(EOL); + } + } + + setState(316); + ((ExpressionContext)_localctx).right = expression(22); + } + break; + case 3: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(317); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(319); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(318); + match(EOL); + } + } + + setState(321); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==T__39 || _la==T__40) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(323); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(322); + match(EOL); + } + } + + setState(325); + ((ExpressionContext)_localctx).right = expression(21); + } + break; + case 4: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(326); + if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); + setState(328); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(327); + match(EOL); + } + } + + setState(330); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==T__46 || _la==T__47) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(332); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(331); + match(EOL); + } + } + + setState(334); + ((ExpressionContext)_localctx).right = expression(20); + } + break; + case 5: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(335); + if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); + setState(337); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(336); + match(EOL); + } + } + + setState(339); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51))) != 0)) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(341); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(340); + match(EOL); + } + } + + setState(343); + ((ExpressionContext)_localctx).right = expression(19); + } + break; + case 6: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(344); + if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); + setState(346); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(345); + match(EOL); + } + } + + setState(348); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==T__52 || _la==T__53) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(350); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(349); + match(EOL); + } + } + + setState(352); + ((ExpressionContext)_localctx).right = expression(18); + } + break; + case 7: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(353); + if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(355); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(354); + match(EOL); + } + } + + setState(357); + ((ExpressionContext)_localctx).bop = match(ADDRESS_OF); + setState(359); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(358); + match(EOL); + } + } + + setState(361); + ((ExpressionContext)_localctx).right = expression(17); + } + break; + case 8: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(362); + if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(364); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(363); + match(EOL); + } + } + + setState(366); + ((ExpressionContext)_localctx).bop = match(T__54); + setState(368); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(367); + match(EOL); + } + } + + setState(370); + ((ExpressionContext)_localctx).right = expression(16); + } + break; + case 9: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(371); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(373); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(372); + match(EOL); + } + } + + setState(375); + ((ExpressionContext)_localctx).bop = match(T__55); + setState(377); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(376); + match(EOL); + } + } + + setState(379); + ((ExpressionContext)_localctx).right = expression(15); + } + break; + case 10: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(380); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(382); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(381); + match(EOL); + } + } + + setState(384); + ((ExpressionContext)_localctx).bop = match(T__58); + setState(386); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(385); + match(EOL); + } + } + + setState(388); + ((ExpressionContext)_localctx).right = expression(13); + } + break; + case 11: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(389); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(391); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(390); + match(EOL); + } + } + + setState(393); + ((ExpressionContext)_localctx).bop = match(T__59); + setState(395); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(394); + match(EOL); + } + } + + setState(397); + ((ExpressionContext)_localctx).right = expression(12); + } + break; + case 12: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.left = _prevctx; + _localctx.left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(398); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(400); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(399); + match(EOL); + } + } + + setState(402); + ((ExpressionContext)_localctx).bop = match(T__60); + setState(404); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(403); + match(EOL); + } + } + + setState(406); + ((ExpressionContext)_localctx).right = expression(11); + } + break; + case 13: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + _localctx.rangefrom = _prevctx; + _localctx.rangefrom = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(407); + if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); + setState(408); + match(T__56); + setState(409); + ((ExpressionContext)_localctx).rangeto = expression(0); + setState(412); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { + case 1: + { + setState(410); + match(T__57); + setState(411); + ((ExpressionContext)_localctx).rangestep = expression(0); + } + break; + } + } + break; + case 14: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(414); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(415); + typecast(); + } + break; + } + } + } + setState(420); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,42,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class TypecastContext extends ParserRuleContext { + public DatatypeContext datatype() { + return getRuleContext(DatatypeContext.class,0); + } + public TypecastContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typecast; } + } + + public final TypecastContext typecast() throws RecognitionException { + TypecastContext _localctx = new TypecastContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_typecast); + try { + enterOuterAlt(_localctx, 1); + { + setState(421); + match(T__64); + setState(422); + datatype(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayindexedContext extends ParserRuleContext { + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public ArrayindexContext arrayindex() { + return getRuleContext(ArrayindexContext.class,0); + } + public ArrayindexedContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayindexed; } + } + + public final ArrayindexedContext arrayindexed() throws RecognitionException { + ArrayindexedContext _localctx = new ArrayindexedContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_arrayindexed); + try { + enterOuterAlt(_localctx, 1); + { + setState(424); + scoped_identifier(); + setState(425); + arrayindex(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DirectmemoryContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public DirectmemoryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_directmemory; } + } + + public final DirectmemoryContext directmemory() throws RecognitionException { + DirectmemoryContext _localctx = new DirectmemoryContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_directmemory); + try { + enterOuterAlt(_localctx, 1); + { + setState(427); + match(T__65); + setState(428); + match(T__62); + setState(429); + expression(0); + setState(430); + match(T__63); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AddressofContext extends ParserRuleContext { + public TerminalNode ADDRESS_OF() { return getToken(prog8Parser.ADDRESS_OF, 0); } + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public AddressofContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_addressof; } + } + + public final AddressofContext addressof() throws RecognitionException { + AddressofContext _localctx = new AddressofContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_addressof); + try { + enterOuterAlt(_localctx, 1); + { + setState(432); + match(ADDRESS_OF); + setState(433); + scoped_identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctioncallContext extends ParserRuleContext { + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class,0); + } + public FunctioncallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functioncall; } + } + + public final FunctioncallContext functioncall() throws RecognitionException { + FunctioncallContext _localctx = new FunctioncallContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_functioncall); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(435); + scoped_identifier(); + setState(436); + match(T__62); + setState(438); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (ADDRESS_OF - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { + { + setState(437); + expression_list(); + } + } + + setState(440); + match(T__63); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Functioncall_stmtContext extends ParserRuleContext { + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public TerminalNode VOID() { return getToken(prog8Parser.VOID, 0); } + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class,0); + } + public Functioncall_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functioncall_stmt; } + } + + public final Functioncall_stmtContext functioncall_stmt() throws RecognitionException { + Functioncall_stmtContext _localctx = new Functioncall_stmtContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_functioncall_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(443); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VOID) { + { + setState(442); + match(VOID); + } + } + + setState(445); + scoped_identifier(); + setState(446); + match(T__62); + setState(448); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (ADDRESS_OF - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { + { + setState(447); + expression_list(); + } + } + + setState(450); + match(T__63); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Expression_listContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public Expression_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression_list; } + } + + public final Expression_listContext expression_list() throws RecognitionException { + Expression_listContext _localctx = new Expression_listContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_expression_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(452); + expression(0); + setState(460); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(453); + match(T__12); + setState(455); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(454); + match(EOL); + } + } + + setState(457); + expression(0); + } + } + setState(462); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReturnstmtContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnstmt; } + } + + public final ReturnstmtContext returnstmt() throws RecognitionException { + ReturnstmtContext _localctx = new ReturnstmtContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_returnstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(463); + match(T__66); + setState(465); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { + case 1: + { + setState(464); + expression(0); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BreakstmtContext extends ParserRuleContext { + public BreakstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_breakstmt; } + } + + public final BreakstmtContext breakstmt() throws RecognitionException { + BreakstmtContext _localctx = new BreakstmtContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_breakstmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(467); + match(T__67); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ContinuestmtContext extends ParserRuleContext { + public ContinuestmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continuestmt; } + } + + public final ContinuestmtContext continuestmt() throws RecognitionException { + ContinuestmtContext _localctx = new ContinuestmtContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_continuestmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(469); + match(T__68); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IdentifierContext extends ParserRuleContext { + public TerminalNode NAME() { return getToken(prog8Parser.NAME, 0); } + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier; } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_identifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(471); + match(NAME); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Scoped_identifierContext extends ParserRuleContext { + public List NAME() { return getTokens(prog8Parser.NAME); } + public TerminalNode NAME(int i) { + return getToken(prog8Parser.NAME, i); + } + public Scoped_identifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_scoped_identifier; } + } + + public final Scoped_identifierContext scoped_identifier() throws RecognitionException { + Scoped_identifierContext _localctx = new Scoped_identifierContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_scoped_identifier); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(473); + match(NAME); + setState(478); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,49,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(474); + match(T__69); + setState(475); + match(NAME); + } + } + } + setState(480); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,49,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RegisterContext extends ParserRuleContext { + public RegisterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_register; } + } + + public final RegisterContext register() throws RecognitionException { + RegisterContext _localctx = new RegisterContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_register); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(481); + _la = _input.LA(1); + if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RegisterorpairContext extends ParserRuleContext { + public RegisterorpairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_registerorpair; } + } + + public final RegisterorpairContext registerorpair() throws RecognitionException { + RegisterorpairContext _localctx = new RegisterorpairContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_registerorpair); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(483); + _la = _input.LA(1); + if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)) | (1L << (T__73 - 71)) | (1L << (T__74 - 71)) | (1L << (T__75 - 71)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatusregisterContext extends ParserRuleContext { + public StatusregisterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statusregister; } + } + + public final StatusregisterContext statusregister() throws RecognitionException { + StatusregisterContext _localctx = new StatusregisterContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_statusregister); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(485); + _la = _input.LA(1); + if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (T__76 - 77)) | (1L << (T__77 - 77)) | (1L << (T__78 - 77)) | (1L << (T__79 - 77)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IntegerliteralContext extends ParserRuleContext { + public Token intpart; + public TerminalNode DEC_INTEGER() { return getToken(prog8Parser.DEC_INTEGER, 0); } + public TerminalNode HEX_INTEGER() { return getToken(prog8Parser.HEX_INTEGER, 0); } + public TerminalNode BIN_INTEGER() { return getToken(prog8Parser.BIN_INTEGER, 0); } + public WordsuffixContext wordsuffix() { + return getRuleContext(WordsuffixContext.class,0); + } + public IntegerliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integerliteral; } + } + + public final IntegerliteralContext integerliteral() throws RecognitionException { + IntegerliteralContext _localctx = new IntegerliteralContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_integerliteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(487); + ((IntegerliteralContext)_localctx).intpart = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (DEC_INTEGER - 116)) | (1L << (HEX_INTEGER - 116)) | (1L << (BIN_INTEGER - 116)))) != 0)) ) { + ((IntegerliteralContext)_localctx).intpart = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(489); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { + case 1: + { + setState(488); + wordsuffix(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WordsuffixContext extends ParserRuleContext { + public WordsuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_wordsuffix; } + } + + public final WordsuffixContext wordsuffix() throws RecognitionException { + WordsuffixContext _localctx = new WordsuffixContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_wordsuffix); + try { + enterOuterAlt(_localctx, 1); + { + setState(491); + match(T__80); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BooleanliteralContext extends ParserRuleContext { + public BooleanliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_booleanliteral; } + } + + public final BooleanliteralContext booleanliteral() throws RecognitionException { + BooleanliteralContext _localctx = new BooleanliteralContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_booleanliteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(493); + _la = _input.LA(1); + if ( !(_la==T__81 || _la==T__82) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayliteralContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public ArrayliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayliteral; } + } + + public final ArrayliteralContext arrayliteral() throws RecognitionException { + ArrayliteralContext _localctx = new ArrayliteralContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_arrayliteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(495); + match(T__24); + setState(497); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(496); + match(EOL); + } + } + + setState(499); + expression(0); + setState(507); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(500); + match(T__12); + setState(502); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(501); + match(EOL); + } + } + + setState(504); + expression(0); + } + } + setState(509); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(511); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(510); + match(EOL); + } + } + + setState(513); + match(T__25); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StructliteralContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public StructliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_structliteral; } + } + + public final StructliteralContext structliteral() throws RecognitionException { + StructliteralContext _localctx = new StructliteralContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_structliteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(515); + match(T__16); + setState(517); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(516); + match(EOL); + } + } + + setState(519); + expression(0); + setState(527); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(520); + match(T__12); + setState(522); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(521); + match(EOL); + } + } + + setState(524); + expression(0); + } + } + setState(529); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(531); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(530); + match(EOL); + } + } + + setState(533); + match(T__17); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StringliteralContext extends ParserRuleContext { + public TerminalNode STRING() { return getToken(prog8Parser.STRING, 0); } + public StringliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stringliteral; } + } + + public final StringliteralContext stringliteral() throws RecognitionException { + StringliteralContext _localctx = new StringliteralContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_stringliteral); + try { + enterOuterAlt(_localctx, 1); + { + setState(535); + match(STRING); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CharliteralContext extends ParserRuleContext { + public TerminalNode SINGLECHAR() { return getToken(prog8Parser.SINGLECHAR, 0); } + public CharliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_charliteral; } + } + + public final CharliteralContext charliteral() throws RecognitionException { + CharliteralContext _localctx = new CharliteralContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_charliteral); + try { + enterOuterAlt(_localctx, 1); + { + setState(537); + match(SINGLECHAR); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FloatliteralContext extends ParserRuleContext { + public TerminalNode FLOAT_NUMBER() { return getToken(prog8Parser.FLOAT_NUMBER, 0); } + public FloatliteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_floatliteral; } + } + + public final FloatliteralContext floatliteral() throws RecognitionException { + FloatliteralContext _localctx = new FloatliteralContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_floatliteral); + try { + enterOuterAlt(_localctx, 1); + { + setState(539); + match(FLOAT_NUMBER); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LiteralvalueContext extends ParserRuleContext { + public IntegerliteralContext integerliteral() { + return getRuleContext(IntegerliteralContext.class,0); + } + public BooleanliteralContext booleanliteral() { + return getRuleContext(BooleanliteralContext.class,0); + } + public ArrayliteralContext arrayliteral() { + return getRuleContext(ArrayliteralContext.class,0); + } + public StringliteralContext stringliteral() { + return getRuleContext(StringliteralContext.class,0); + } + public CharliteralContext charliteral() { + return getRuleContext(CharliteralContext.class,0); + } + public FloatliteralContext floatliteral() { + return getRuleContext(FloatliteralContext.class,0); + } + public StructliteralContext structliteral() { + return getRuleContext(StructliteralContext.class,0); + } + public LiteralvalueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literalvalue; } + } + + public final LiteralvalueContext literalvalue() throws RecognitionException { + LiteralvalueContext _localctx = new LiteralvalueContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_literalvalue); + try { + setState(548); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEC_INTEGER: + case HEX_INTEGER: + case BIN_INTEGER: + enterOuterAlt(_localctx, 1); + { + setState(541); + integerliteral(); + } + break; + case T__81: + case T__82: + enterOuterAlt(_localctx, 2); + { + setState(542); + booleanliteral(); + } + break; + case T__24: + enterOuterAlt(_localctx, 3); + { + setState(543); + arrayliteral(); + } + break; + case STRING: + enterOuterAlt(_localctx, 4); + { + setState(544); + stringliteral(); + } + break; + case SINGLECHAR: + enterOuterAlt(_localctx, 5); + { + setState(545); + charliteral(); + } + break; + case FLOAT_NUMBER: + enterOuterAlt(_localctx, 6); + { + setState(546); + floatliteral(); + } + break; + case T__16: + enterOuterAlt(_localctx, 7); + { + setState(547); + structliteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InlineasmContext extends ParserRuleContext { + public TerminalNode INLINEASMBLOCK() { return getToken(prog8Parser.INLINEASMBLOCK, 0); } + public InlineasmContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inlineasm; } + } + + public final InlineasmContext inlineasm() throws RecognitionException { + InlineasmContext _localctx = new InlineasmContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_inlineasm); + try { + enterOuterAlt(_localctx, 1); + { + setState(550); + match(T__83); + setState(551); + match(INLINEASMBLOCK); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SubroutineContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public Sub_paramsContext sub_params() { + return getRuleContext(Sub_paramsContext.class,0); + } + public Sub_return_partContext sub_return_part() { + return getRuleContext(Sub_return_partContext.class,0); + } + public SubroutineContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subroutine; } + } + + public final SubroutineContext subroutine() throws RecognitionException { + SubroutineContext _localctx = new SubroutineContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_subroutine); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(553); + match(T__84); + setState(554); + identifier(); + setState(555); + match(T__62); + setState(557); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0)) { + { + setState(556); + sub_params(); + } + } + + setState(559); + match(T__63); + setState(561); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__85) { + { + setState(560); + sub_return_part(); + } + } + + { + setState(563); + statement_block(); + setState(564); + match(EOL); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Sub_return_partContext extends ParserRuleContext { + public Sub_returnsContext sub_returns() { + return getRuleContext(Sub_returnsContext.class,0); + } + public Sub_return_partContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sub_return_part; } + } + + public final Sub_return_partContext sub_return_part() throws RecognitionException { + Sub_return_partContext _localctx = new Sub_return_partContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_sub_return_part); + try { + enterOuterAlt(_localctx, 1); + { + setState(566); + match(T__85); + setState(567); + sub_returns(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Statement_blockContext extends ParserRuleContext { + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public Statement_blockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement_block; } + } + + public final Statement_blockContext statement_block() throws RecognitionException { + Statement_blockContext _localctx = new Statement_blockContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_statement_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(569); + match(T__16); + setState(570); + match(EOL); + setState(575); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__14) | (1L << T__15) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__66 - 66)) | (1L << (T__67 - 66)) | (1L << (T__68 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__83 - 66)) | (1L << (T__84 - 66)) | (1L << (T__86 - 66)) | (1L << (T__89 - 66)) | (1L << (T__91 - 66)) | (1L << (T__92 - 66)) | (1L << (T__93 - 66)) | (1L << (T__94 - 66)) | (1L << (T__95 - 66)) | (1L << (T__96 - 66)) | (1L << (T__97 - 66)) | (1L << (T__98 - 66)) | (1L << (T__99 - 66)) | (1L << (T__100 - 66)) | (1L << (T__101 - 66)) | (1L << (T__102 - 66)) | (1L << (T__103 - 66)) | (1L << (T__105 - 66)) | (1L << (T__106 - 66)) | (1L << (T__108 - 66)) | (1L << (EOL - 66)) | (1L << (VOID - 66)) | (1L << (NAME - 66)) | (1L << (ADDRESS_OF - 66)))) != 0)) { + { + setState(573); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(571); + statement(); + } + break; + case EOL: + { + setState(572); + match(EOL); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(577); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(578); + match(T__17); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Sub_paramsContext extends ParserRuleContext { + public List vardecl() { + return getRuleContexts(VardeclContext.class); + } + public VardeclContext vardecl(int i) { + return getRuleContext(VardeclContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public Sub_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sub_params; } + } + + public final Sub_paramsContext sub_params() throws RecognitionException { + Sub_paramsContext _localctx = new Sub_paramsContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_sub_params); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(580); + vardecl(); + setState(588); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(581); + match(T__12); + setState(583); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(582); + match(EOL); + } + } + + setState(585); + vardecl(); + } + } + setState(590); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Sub_returnsContext extends ParserRuleContext { + public List datatype() { + return getRuleContexts(DatatypeContext.class); + } + public DatatypeContext datatype(int i) { + return getRuleContext(DatatypeContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public Sub_returnsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sub_returns; } + } + + public final Sub_returnsContext sub_returns() throws RecognitionException { + Sub_returnsContext _localctx = new Sub_returnsContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_sub_returns); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(591); + datatype(); + setState(599); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(592); + match(T__12); + setState(594); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(593); + match(EOL); + } + } + + setState(596); + datatype(); + } + } + setState(601); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AsmsubroutineContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Asmsub_addressContext asmsub_address() { + return getRuleContext(Asmsub_addressContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public Asmsub_paramsContext asmsub_params() { + return getRuleContext(Asmsub_paramsContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public Asmsub_clobbersContext asmsub_clobbers() { + return getRuleContext(Asmsub_clobbersContext.class,0); + } + public Asmsub_returnsContext asmsub_returns() { + return getRuleContext(Asmsub_returnsContext.class,0); + } + public AsmsubroutineContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsubroutine; } + } + + public final AsmsubroutineContext asmsubroutine() throws RecognitionException { + AsmsubroutineContext _localctx = new AsmsubroutineContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_asmsubroutine); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(602); + match(T__86); + setState(603); + identifier(); + setState(604); + match(T__62); + setState(606); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0)) { + { + setState(605); + asmsub_params(); + } + } + + setState(608); + match(T__63); + setState(610); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(609); + match(EOL); + } + } + + setState(613); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__88) { + { + setState(612); + asmsub_clobbers(); + } + } + + setState(616); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__85) { + { + setState(615); + asmsub_returns(); + } + } + + setState(620); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__13: + { + setState(618); + asmsub_address(); + } + break; + case T__16: + { + setState(619); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Asmsub_addressContext extends ParserRuleContext { + public IntegerliteralContext address; + public IntegerliteralContext integerliteral() { + return getRuleContext(IntegerliteralContext.class,0); + } + public Asmsub_addressContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsub_address; } + } + + public final Asmsub_addressContext asmsub_address() throws RecognitionException { + Asmsub_addressContext _localctx = new Asmsub_addressContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_asmsub_address); + try { + enterOuterAlt(_localctx, 1); + { + setState(622); + match(T__13); + setState(623); + ((Asmsub_addressContext)_localctx).address = integerliteral(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Asmsub_paramsContext extends ParserRuleContext { + public List asmsub_param() { + return getRuleContexts(Asmsub_paramContext.class); + } + public Asmsub_paramContext asmsub_param(int i) { + return getRuleContext(Asmsub_paramContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public Asmsub_paramsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsub_params; } + } + + public final Asmsub_paramsContext asmsub_params() throws RecognitionException { + Asmsub_paramsContext _localctx = new Asmsub_paramsContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_asmsub_params); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(625); + asmsub_param(); + setState(633); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(626); + match(T__12); + setState(628); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(627); + match(EOL); + } + } + + setState(630); + asmsub_param(); + } + } + setState(635); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Asmsub_paramContext extends ParserRuleContext { + public Token stack; + public VardeclContext vardecl() { + return getRuleContext(VardeclContext.class,0); + } + public RegisterorpairContext registerorpair() { + return getRuleContext(RegisterorpairContext.class,0); + } + public StatusregisterContext statusregister() { + return getRuleContext(StatusregisterContext.class,0); + } + public Asmsub_paramContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsub_param; } + } + + public final Asmsub_paramContext asmsub_param() throws RecognitionException { + Asmsub_paramContext _localctx = new Asmsub_paramContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_asmsub_param); + try { + enterOuterAlt(_localctx, 1); + { + setState(636); + vardecl(); + setState(637); + match(T__65); + setState(641); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__70: + case T__71: + case T__72: + case T__73: + case T__74: + case T__75: + { + setState(638); + registerorpair(); + } + break; + case T__76: + case T__77: + case T__78: + case T__79: + { + setState(639); + statusregister(); + } + break; + case T__87: + { + setState(640); + ((Asmsub_paramContext)_localctx).stack = match(T__87); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Asmsub_clobbersContext extends ParserRuleContext { + public ClobberContext clobber() { + return getRuleContext(ClobberContext.class,0); + } + public Asmsub_clobbersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsub_clobbers; } + } + + public final Asmsub_clobbersContext asmsub_clobbers() throws RecognitionException { + Asmsub_clobbersContext _localctx = new Asmsub_clobbersContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_asmsub_clobbers); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(643); + match(T__88); + setState(644); + match(T__62); + setState(646); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) { + { + setState(645); + clobber(); + } + } + + setState(648); + match(T__63); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClobberContext extends ParserRuleContext { + public List register() { + return getRuleContexts(RegisterContext.class); + } + public RegisterContext register(int i) { + return getRuleContext(RegisterContext.class,i); + } + public ClobberContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_clobber; } + } + + public final ClobberContext clobber() throws RecognitionException { + ClobberContext _localctx = new ClobberContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_clobber); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(650); + register(); + setState(655); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(651); + match(T__12); + setState(652); + register(); + } + } + setState(657); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Asmsub_returnsContext extends ParserRuleContext { + public List asmsub_return() { + return getRuleContexts(Asmsub_returnContext.class); + } + public Asmsub_returnContext asmsub_return(int i) { + return getRuleContext(Asmsub_returnContext.class,i); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public Asmsub_returnsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsub_returns; } + } + + public final Asmsub_returnsContext asmsub_returns() throws RecognitionException { + Asmsub_returnsContext _localctx = new Asmsub_returnsContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_asmsub_returns); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(658); + match(T__85); + setState(659); + asmsub_return(); + setState(667); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__12) { + { + { + setState(660); + match(T__12); + setState(662); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(661); + match(EOL); + } + } + + setState(664); + asmsub_return(); + } + } + setState(669); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Asmsub_returnContext extends ParserRuleContext { + public Token stack; + public DatatypeContext datatype() { + return getRuleContext(DatatypeContext.class,0); + } + public RegisterorpairContext registerorpair() { + return getRuleContext(RegisterorpairContext.class,0); + } + public StatusregisterContext statusregister() { + return getRuleContext(StatusregisterContext.class,0); + } + public Asmsub_returnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmsub_return; } + } + + public final Asmsub_returnContext asmsub_return() throws RecognitionException { + Asmsub_returnContext _localctx = new Asmsub_returnContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_asmsub_return); + try { + enterOuterAlt(_localctx, 1); + { + setState(670); + datatype(); + setState(671); + match(T__65); + setState(675); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__70: + case T__71: + case T__72: + case T__73: + case T__74: + case T__75: + { + setState(672); + registerorpair(); + } + break; + case T__76: + case T__77: + case T__78: + case T__79: + { + setState(673); + statusregister(); + } + break; + case T__87: + { + setState(674); + ((Asmsub_returnContext)_localctx).stack = match(T__87); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class If_stmtContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public Else_partContext else_part() { + return getRuleContext(Else_partContext.class,0); + } + public If_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_if_stmt; } + } + + public final If_stmtContext if_stmt() throws RecognitionException { + If_stmtContext _localctx = new If_stmtContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_if_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(677); + match(T__89); + setState(678); + expression(0); + setState(680); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(679); + match(EOL); + } + } + + setState(684); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(682); + statement(); + } + break; + case T__16: + { + setState(683); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(687); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) { + case 1: + { + setState(686); + match(EOL); + } + break; + } + setState(690); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) { + case 1: + { + setState(689); + else_part(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Else_partContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public Else_partContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_else_part; } + } + + public final Else_partContext else_part() throws RecognitionException { + Else_partContext _localctx = new Else_partContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_else_part); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(692); + match(T__90); + setState(694); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(693); + match(EOL); + } + } + + setState(698); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(696); + statement(); + } + break; + case T__16: + { + setState(697); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Branch_stmtContext extends ParserRuleContext { + public BranchconditionContext branchcondition() { + return getRuleContext(BranchconditionContext.class,0); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public Else_partContext else_part() { + return getRuleContext(Else_partContext.class,0); + } + public Branch_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_branch_stmt; } + } + + public final Branch_stmtContext branch_stmt() throws RecognitionException { + Branch_stmtContext _localctx = new Branch_stmtContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_branch_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(700); + branchcondition(); + setState(702); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(701); + match(EOL); + } + } + + setState(706); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(704); + statement(); + } + break; + case T__16: + { + setState(705); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(709); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { + case 1: + { + setState(708); + match(EOL); + } + break; + } + setState(712); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__90) { + { + setState(711); + else_part(); + } + } + + setState(714); + match(EOL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BranchconditionContext extends ParserRuleContext { + public BranchconditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_branchcondition; } + } + + public final BranchconditionContext branchcondition() throws RecognitionException { + BranchconditionContext _localctx = new BranchconditionContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_branchcondition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(716); + _la = _input.LA(1); + if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (T__91 - 92)) | (1L << (T__92 - 92)) | (1L << (T__93 - 92)) | (1L << (T__94 - 92)) | (1L << (T__95 - 92)) | (1L << (T__96 - 92)) | (1L << (T__97 - 92)) | (1L << (T__98 - 92)) | (1L << (T__99 - 92)) | (1L << (T__100 - 92)) | (1L << (T__101 - 92)) | (1L << (T__102 - 92)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForloopContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public ForloopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forloop; } + } + + public final ForloopContext forloop() throws RecognitionException { + ForloopContext _localctx = new ForloopContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_forloop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(718); + match(T__103); + setState(721); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__70: + case T__71: + case T__72: + { + setState(719); + register(); + } + break; + case NAME: + { + setState(720); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(723); + match(T__104); + setState(724); + expression(0); + setState(726); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(725); + match(EOL); + } + } + + setState(730); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(728); + statement(); + } + break; + case T__16: + { + setState(729); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileloopContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public WhileloopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileloop; } + } + + public final WhileloopContext whileloop() throws RecognitionException { + WhileloopContext _localctx = new WhileloopContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_whileloop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(732); + match(T__105); + setState(733); + expression(0); + setState(735); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(734); + match(EOL); + } + } + + setState(739); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(737); + statement(); + } + break; + case T__16: + { + setState(738); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RepeatloopContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public TerminalNode EOL() { return getToken(prog8Parser.EOL, 0); } + public RepeatloopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_repeatloop; } + } + + public final RepeatloopContext repeatloop() throws RecognitionException { + RepeatloopContext _localctx = new RepeatloopContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_repeatloop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(741); + match(T__106); + setState(744); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(742); + statement(); + } + break; + case T__16: + { + setState(743); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(747); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EOL) { + { + setState(746); + match(EOL); + } + } + + setState(749); + match(T__107); + setState(750); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhenstmtContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List EOL() { return getTokens(prog8Parser.EOL); } + public TerminalNode EOL(int i) { + return getToken(prog8Parser.EOL, i); + } + public List when_choice() { + return getRuleContexts(When_choiceContext.class); + } + public When_choiceContext when_choice(int i) { + return getRuleContext(When_choiceContext.class,i); + } + public WhenstmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whenstmt; } + } + + public final WhenstmtContext whenstmt() throws RecognitionException { + WhenstmtContext _localctx = new WhenstmtContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_whenstmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(752); + match(T__108); + setState(753); + expression(0); + setState(754); + match(T__16); + setState(755); + match(EOL); + setState(760); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (T__90 - 66)) | (1L << (EOL - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (ADDRESS_OF - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { + { + setState(758); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__16: + case T__24: + case T__39: + case T__40: + case T__41: + case T__61: + case T__62: + case T__65: + case T__70: + case T__71: + case T__72: + case T__81: + case T__82: + case T__90: + case NAME: + case DEC_INTEGER: + case HEX_INTEGER: + case BIN_INTEGER: + case ADDRESS_OF: + case FLOAT_NUMBER: + case STRING: + case SINGLECHAR: + { + setState(756); + when_choice(); + } + break; + case EOL: + { + setState(757); + match(EOL); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(762); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(763); + match(T__17); + setState(765); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { + case 1: + { + setState(764); + match(EOL); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class When_choiceContext extends ParserRuleContext { + public Expression_listContext expression_list() { + return getRuleContext(Expression_listContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public Statement_blockContext statement_block() { + return getRuleContext(Statement_blockContext.class,0); + } + public When_choiceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_when_choice; } + } + + public final When_choiceContext when_choice() throws RecognitionException { + When_choiceContext _localctx = new When_choiceContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_when_choice); + try { + enterOuterAlt(_localctx, 1); + { + setState(769); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__16: + case T__24: + case T__39: + case T__40: + case T__41: + case T__61: + case T__62: + case T__65: + case T__70: + case T__71: + case T__72: + case T__81: + case T__82: + case NAME: + case DEC_INTEGER: + case HEX_INTEGER: + case BIN_INTEGER: + case ADDRESS_OF: + case FLOAT_NUMBER: + case STRING: + case SINGLECHAR: + { + setState(767); + expression_list(); + } + break; + case T__90: + { + setState(768); + match(T__90); + } + break; + default: + throw new NoViableAltException(this); + } + setState(771); + match(T__85); + setState(774); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + case T__2: + case T__3: + case T__4: + case T__5: + case T__6: + case T__7: + case T__8: + case T__9: + case T__10: + case T__11: + case T__14: + case T__15: + case T__18: + case T__19: + case T__20: + case T__21: + case T__22: + case T__23: + case T__65: + case T__66: + case T__67: + case T__68: + case T__70: + case T__71: + case T__72: + case T__83: + case T__84: + case T__86: + case T__89: + case T__91: + case T__92: + case T__93: + case T__94: + case T__95: + case T__96: + case T__97: + case T__98: + case T__99: + case T__100: + case T__101: + case T__102: + case T__103: + case T__105: + case T__106: + case T__108: + case VOID: + case NAME: + case ADDRESS_OF: + { + setState(772); + statement(); + } + break; + case T__16: + { + setState(773); + statement_block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 21: + return expression_sempred((ExpressionContext)_localctx, predIndex); + } + return true; + } + private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 22); + case 1: + return precpred(_ctx, 21); + case 2: + return precpred(_ctx, 20); + case 3: + return precpred(_ctx, 19); + case 4: + return precpred(_ctx, 18); + case 5: + return precpred(_ctx, 17); + case 6: + return precpred(_ctx, 16); + case 7: + return precpred(_ctx, 15); + case 8: + return precpred(_ctx, 14); + case 9: + return precpred(_ctx, 12); + case 10: + return precpred(_ctx, 11); + case 11: + return precpred(_ctx, 10); + case 12: + return precpred(_ctx, 13); + case 13: + return precpred(_ctx, 2); + } + return true; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\177\u030b\4\2\t\2"+ + "\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\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\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\3\2\3\2\7\2\u008f"+ + "\n\2\f\2\16\2\u0092\13\2\3\2\3\2\3\3\3\3\5\3\u0098\n\3\3\4\3\4\5\4\u009c"+ + "\n\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3"+ + "\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u00bb\n\5\3\6\3"+ + "\6\3\6\3\7\3\7\3\7\5\7\u00c3\n\7\3\b\3\b\5\b\u00c7\n\b\3\b\3\b\3\b\7\b"+ + "\u00cc\n\b\f\b\16\b\u00cf\13\b\5\b\u00d1\n\b\3\t\3\t\3\t\5\t\u00d6\n\t"+ + "\3\n\3\n\5\n\u00da\n\n\3\n\3\n\5\n\u00de\n\n\3\n\3\n\3\13\3\13\3\13\3"+ + "\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\20\3\20"+ + "\3\20\3\20\3\20\3\20\3\20\7\20\u00fa\n\20\f\20\16\20\u00fd\13\20\3\20"+ + "\5\20\u0100\n\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23"+ + "\3\23\3\23\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\5\25\u0117\n\25\3\26"+ + "\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27"+ + "\3\27\3\27\3\27\3\27\5\27\u012c\n\27\3\27\3\27\5\27\u0130\n\27\3\27\3"+ + "\27\5\27\u0134\n\27\3\27\3\27\3\27\5\27\u0139\n\27\3\27\3\27\5\27\u013d"+ + "\n\27\3\27\3\27\3\27\5\27\u0142\n\27\3\27\3\27\5\27\u0146\n\27\3\27\3"+ + "\27\3\27\5\27\u014b\n\27\3\27\3\27\5\27\u014f\n\27\3\27\3\27\3\27\5\27"+ + "\u0154\n\27\3\27\3\27\5\27\u0158\n\27\3\27\3\27\3\27\5\27\u015d\n\27\3"+ + "\27\3\27\5\27\u0161\n\27\3\27\3\27\3\27\5\27\u0166\n\27\3\27\3\27\5\27"+ + "\u016a\n\27\3\27\3\27\3\27\5\27\u016f\n\27\3\27\3\27\5\27\u0173\n\27\3"+ + "\27\3\27\3\27\5\27\u0178\n\27\3\27\3\27\5\27\u017c\n\27\3\27\3\27\3\27"+ + "\5\27\u0181\n\27\3\27\3\27\5\27\u0185\n\27\3\27\3\27\3\27\5\27\u018a\n"+ + "\27\3\27\3\27\5\27\u018e\n\27\3\27\3\27\3\27\5\27\u0193\n\27\3\27\3\27"+ + "\5\27\u0197\n\27\3\27\3\27\3\27\3\27\3\27\3\27\5\27\u019f\n\27\3\27\3"+ + "\27\7\27\u01a3\n\27\f\27\16\27\u01a6\13\27\3\30\3\30\3\30\3\31\3\31\3"+ + "\31\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\34\3\34\3\34\5\34\u01b9"+ + "\n\34\3\34\3\34\3\35\5\35\u01be\n\35\3\35\3\35\3\35\5\35\u01c3\n\35\3"+ + "\35\3\35\3\36\3\36\3\36\5\36\u01ca\n\36\3\36\7\36\u01cd\n\36\f\36\16\36"+ + "\u01d0\13\36\3\37\3\37\5\37\u01d4\n\37\3 \3 \3!\3!\3\"\3\"\3#\3#\3#\7"+ + "#\u01df\n#\f#\16#\u01e2\13#\3$\3$\3%\3%\3&\3&\3\'\3\'\5\'\u01ec\n\'\3"+ + "(\3(\3)\3)\3*\3*\5*\u01f4\n*\3*\3*\3*\5*\u01f9\n*\3*\7*\u01fc\n*\f*\16"+ + "*\u01ff\13*\3*\5*\u0202\n*\3*\3*\3+\3+\5+\u0208\n+\3+\3+\3+\5+\u020d\n"+ + "+\3+\7+\u0210\n+\f+\16+\u0213\13+\3+\5+\u0216\n+\3+\3+\3,\3,\3-\3-\3."+ + "\3.\3/\3/\3/\3/\3/\3/\3/\5/\u0227\n/\3\60\3\60\3\60\3\61\3\61\3\61\3\61"+ + "\5\61\u0230\n\61\3\61\3\61\5\61\u0234\n\61\3\61\3\61\3\61\3\62\3\62\3"+ + "\62\3\63\3\63\3\63\3\63\7\63\u0240\n\63\f\63\16\63\u0243\13\63\3\63\3"+ + "\63\3\64\3\64\3\64\5\64\u024a\n\64\3\64\7\64\u024d\n\64\f\64\16\64\u0250"+ + "\13\64\3\65\3\65\3\65\5\65\u0255\n\65\3\65\7\65\u0258\n\65\f\65\16\65"+ + "\u025b\13\65\3\66\3\66\3\66\3\66\5\66\u0261\n\66\3\66\3\66\5\66\u0265"+ + "\n\66\3\66\5\66\u0268\n\66\3\66\5\66\u026b\n\66\3\66\3\66\5\66\u026f\n"+ + "\66\3\67\3\67\3\67\38\38\38\58\u0277\n8\38\78\u027a\n8\f8\168\u027d\13"+ + "8\39\39\39\39\39\59\u0284\n9\3:\3:\3:\5:\u0289\n:\3:\3:\3;\3;\3;\7;\u0290"+ + "\n;\f;\16;\u0293\13;\3<\3<\3<\3<\5<\u0299\n<\3<\7<\u029c\n<\f<\16<\u029f"+ + "\13<\3=\3=\3=\3=\3=\5=\u02a6\n=\3>\3>\3>\5>\u02ab\n>\3>\3>\5>\u02af\n"+ + ">\3>\5>\u02b2\n>\3>\5>\u02b5\n>\3?\3?\5?\u02b9\n?\3?\3?\5?\u02bd\n?\3"+ + "@\3@\5@\u02c1\n@\3@\3@\5@\u02c5\n@\3@\5@\u02c8\n@\3@\5@\u02cb\n@\3@\3"+ + "@\3A\3A\3B\3B\3B\5B\u02d4\nB\3B\3B\3B\5B\u02d9\nB\3B\3B\5B\u02dd\nB\3"+ + "C\3C\3C\5C\u02e2\nC\3C\3C\5C\u02e6\nC\3D\3D\3D\5D\u02eb\nD\3D\5D\u02ee"+ + "\nD\3D\3D\3D\3E\3E\3E\3E\3E\3E\7E\u02f9\nE\fE\16E\u02fc\13E\3E\3E\5E\u0300"+ + "\nE\3F\3F\5F\u0304\nF\3F\3F\3F\5F\u0309\nF\3F\2\3,G\2\4\6\b\n\f\16\20"+ + "\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhj"+ + "lnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\2\22\3\2\5\16\3\2\25\32"+ + "\3\2\35\'\3\2()\3\2*,\3\2.\60\3\2*+\3\2\61\62\3\2\63\66\3\2\678\3\2IK"+ + "\3\2IN\3\2OR\3\2vx\3\2TU\3\2^i\2\u0363\2\u0090\3\2\2\2\4\u0097\3\2\2\2"+ + "\6\u0099\3\2\2\2\b\u00ba\3\2\2\2\n\u00bc\3\2\2\2\f\u00bf\3\2\2\2\16\u00c4"+ + "\3\2\2\2\20\u00d5\3\2\2\2\22\u00d7\3\2\2\2\24\u00e1\3\2\2\2\26\u00e4\3"+ + "\2\2\2\30\u00e8\3\2\2\2\32\u00ec\3\2\2\2\34\u00ef\3\2\2\2\36\u00f2\3\2"+ + "\2\2 \u0104\3\2\2\2\"\u0106\3\2\2\2$\u010a\3\2\2\2&\u010e\3\2\2\2(\u0116"+ + "\3\2\2\2*\u0118\3\2\2\2,\u012b\3\2\2\2.\u01a7\3\2\2\2\60\u01aa\3\2\2\2"+ + "\62\u01ad\3\2\2\2\64\u01b2\3\2\2\2\66\u01b5\3\2\2\28\u01bd\3\2\2\2:\u01c6"+ + "\3\2\2\2<\u01d1\3\2\2\2>\u01d5\3\2\2\2@\u01d7\3\2\2\2B\u01d9\3\2\2\2D"+ + "\u01db\3\2\2\2F\u01e3\3\2\2\2H\u01e5\3\2\2\2J\u01e7\3\2\2\2L\u01e9\3\2"+ + "\2\2N\u01ed\3\2\2\2P\u01ef\3\2\2\2R\u01f1\3\2\2\2T\u0205\3\2\2\2V\u0219"+ + "\3\2\2\2X\u021b\3\2\2\2Z\u021d\3\2\2\2\\\u0226\3\2\2\2^\u0228\3\2\2\2"+ + "`\u022b\3\2\2\2b\u0238\3\2\2\2d\u023b\3\2\2\2f\u0246\3\2\2\2h\u0251\3"+ + "\2\2\2j\u025c\3\2\2\2l\u0270\3\2\2\2n\u0273\3\2\2\2p\u027e\3\2\2\2r\u0285"+ + "\3\2\2\2t\u028c\3\2\2\2v\u0294\3\2\2\2x\u02a0\3\2\2\2z\u02a7\3\2\2\2|"+ + "\u02b6\3\2\2\2~\u02be\3\2\2\2\u0080\u02ce\3\2\2\2\u0082\u02d0\3\2\2\2"+ + "\u0084\u02de\3\2\2\2\u0086\u02e7\3\2\2\2\u0088\u02f2\3\2\2\2\u008a\u0303"+ + "\3\2\2\2\u008c\u008f\5\4\3\2\u008d\u008f\7s\2\2\u008e\u008c\3\2\2\2\u008e"+ + "\u008d\3\2\2\2\u008f\u0092\3\2\2\2\u0090\u008e\3\2\2\2\u0090\u0091\3\2"+ + "\2\2\u0091\u0093\3\2\2\2\u0092\u0090\3\2\2\2\u0093\u0094\7\2\2\3\u0094"+ + "\3\3\2\2\2\u0095\u0098\5\16\b\2\u0096\u0098\5\6\4\2\u0097\u0095\3\2\2"+ + "\2\u0097\u0096\3\2\2\2\u0098\5\3\2\2\2\u0099\u009b\5B\"\2\u009a\u009c"+ + "\5L\'\2\u009b\u009a\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d"+ + "\u009e\5d\63\2\u009e\u009f\7s\2\2\u009f\7\3\2\2\2\u00a0\u00bb\5\16\b\2"+ + "\u00a1\u00bb\5\26\f\2\u00a2\u00bb\5\30\r\2\u00a3\u00bb\5\22\n\2\u00a4"+ + "\u00bb\5\24\13\2\u00a5\u00bb\5\32\16\2\u00a6\u00bb\5\34\17\2\u00a7\u00bb"+ + "\5\36\20\2\u00a8\u00bb\5$\23\2\u00a9\u00bb\5&\24\2\u00aa\u00bb\5\f\7\2"+ + "\u00ab\u00bb\5*\26\2\u00ac\u00bb\58\35\2\u00ad\u00bb\5z>\2\u00ae\u00bb"+ + "\5~@\2\u00af\u00bb\5`\61\2\u00b0\u00bb\5j\66\2\u00b1\u00bb\5^\60\2\u00b2"+ + "\u00bb\5<\37\2\u00b3\u00bb\5\u0082B\2\u00b4\u00bb\5\u0084C\2\u00b5\u00bb"+ + "\5\u0086D\2\u00b6\u00bb\5\u0088E\2\u00b7\u00bb\5> \2\u00b8\u00bb\5@!\2"+ + "\u00b9\u00bb\5\n\6\2\u00ba\u00a0\3\2\2\2\u00ba\u00a1\3\2\2\2\u00ba\u00a2"+ + "\3\2\2\2\u00ba\u00a3\3\2\2\2\u00ba\u00a4\3\2\2\2\u00ba\u00a5\3\2\2\2\u00ba"+ + "\u00a6\3\2\2\2\u00ba\u00a7\3\2\2\2\u00ba\u00a8\3\2\2\2\u00ba\u00a9\3\2"+ + "\2\2\u00ba\u00aa\3\2\2\2\u00ba\u00ab\3\2\2\2\u00ba\u00ac\3\2\2\2\u00ba"+ + "\u00ad\3\2\2\2\u00ba\u00ae\3\2\2\2\u00ba\u00af\3\2\2\2\u00ba\u00b0\3\2"+ + "\2\2\u00ba\u00b1\3\2\2\2\u00ba\u00b2\3\2\2\2\u00ba\u00b3\3\2\2\2\u00ba"+ + "\u00b4\3\2\2\2\u00ba\u00b5\3\2\2\2\u00ba\u00b6\3\2\2\2\u00ba\u00b7\3\2"+ + "\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00b9\3\2\2\2\u00bb\t\3\2\2\2\u00bc\u00bd"+ + "\5B\"\2\u00bd\u00be\7\3\2\2\u00be\13\3\2\2\2\u00bf\u00c2\7\4\2\2\u00c0"+ + "\u00c3\5L\'\2\u00c1\u00c3\5D#\2\u00c2\u00c0\3\2\2\2\u00c2\u00c1\3\2\2"+ + "\2\u00c3\r\3\2\2\2\u00c4\u00d0\t\2\2\2\u00c5\u00c7\5\20\t\2\u00c6\u00c5"+ + "\3\2\2\2\u00c6\u00c7\3\2\2\2\u00c7\u00d1\3\2\2\2\u00c8\u00cd\5\20\t\2"+ + "\u00c9\u00ca\7\17\2\2\u00ca\u00cc\5\20\t\2\u00cb\u00c9\3\2\2\2\u00cc\u00cf"+ + "\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf"+ + "\u00cd\3\2\2\2\u00d0\u00c6\3\2\2\2\u00d0\u00c8\3\2\2\2\u00d1\17\3\2\2"+ + "\2\u00d2\u00d6\5V,\2\u00d3\u00d6\5B\"\2\u00d4\u00d6\5L\'\2\u00d5\u00d2"+ + "\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d4\3\2\2\2\u00d6\21\3\2\2\2\u00d7"+ + "\u00d9\5 \21\2\u00d8\u00da\7~\2\2\u00d9\u00d8\3\2\2\2\u00d9\u00da\3\2"+ + "\2\2\u00da\u00dd\3\2\2\2\u00db\u00de\5\"\22\2\u00dc\u00de\7\177\2\2\u00dd"+ + "\u00db\3\2\2\2\u00dd\u00dc\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\3\2"+ + "\2\2\u00df\u00e0\5B\"\2\u00e0\23\3\2\2\2\u00e1\u00e2\5B\"\2\u00e2\u00e3"+ + "\5B\"\2\u00e3\25\3\2\2\2\u00e4\u00e5\5\22\n\2\u00e5\u00e6\7\20\2\2\u00e6"+ + "\u00e7\5,\27\2\u00e7\27\3\2\2\2\u00e8\u00e9\5\24\13\2\u00e9\u00ea\7\20"+ + "\2\2\u00ea\u00eb\5,\27\2\u00eb\31\3\2\2\2\u00ec\u00ed\7\21\2\2\u00ed\u00ee"+ + "\5\26\f\2\u00ee\33\3\2\2\2\u00ef\u00f0\7y\2\2\u00f0\u00f1\5\26\f\2\u00f1"+ + "\35\3\2\2\2\u00f2\u00f3\7\22\2\2\u00f3\u00f4\5B\"\2\u00f4\u00f5\7\23\2"+ + "\2\u00f5\u00f6\7s\2\2\u00f6\u00fb\5\22\n\2\u00f7\u00f8\7s\2\2\u00f8\u00fa"+ + "\5\22\n\2\u00f9\u00f7\3\2\2\2\u00fa\u00fd\3\2\2\2\u00fb\u00f9\3\2\2\2"+ + "\u00fb\u00fc\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fe\u0100"+ + "\7s\2\2\u00ff\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2\u0101"+ + "\u0102\7\24\2\2\u0102\u0103\7s\2\2\u0103\37\3\2\2\2\u0104\u0105\t\3\2"+ + "\2\u0105!\3\2\2\2\u0106\u0107\7\33\2\2\u0107\u0108\5,\27\2\u0108\u0109"+ + "\7\34\2\2\u0109#\3\2\2\2\u010a\u010b\5(\25\2\u010b\u010c\7\20\2\2\u010c"+ + "\u010d\5,\27\2\u010d%\3\2\2\2\u010e\u010f\5(\25\2\u010f\u0110\t\4\2\2"+ + "\u0110\u0111\5,\27\2\u0111\'\3\2\2\2\u0112\u0117\5F$\2\u0113\u0117\5D"+ + "#\2\u0114\u0117\5\60\31\2\u0115\u0117\5\62\32\2\u0116\u0112\3\2\2\2\u0116"+ + "\u0113\3\2\2\2\u0116\u0114\3\2\2\2\u0116\u0115\3\2\2\2\u0117)\3\2\2\2"+ + "\u0118\u0119\5(\25\2\u0119\u011a\t\5\2\2\u011a+\3\2\2\2\u011b\u011c\b"+ + "\27\1\2\u011c\u012c\5\66\34\2\u011d\u011e\t\6\2\2\u011e\u012c\5,\27\31"+ + "\u011f\u0120\7@\2\2\u0120\u012c\5,\27\13\u0121\u012c\5\\/\2\u0122\u012c"+ + "\5F$\2\u0123\u012c\5D#\2\u0124\u012c\5\60\31\2\u0125\u012c\5\62\32\2\u0126"+ + "\u012c\5\64\33\2\u0127\u0128\7A\2\2\u0128\u0129\5,\27\2\u0129\u012a\7"+ + "B\2\2\u012a\u012c\3\2\2\2\u012b\u011b\3\2\2\2\u012b\u011d\3\2\2\2\u012b"+ + "\u011f\3\2\2\2\u012b\u0121\3\2\2\2\u012b\u0122\3\2\2\2\u012b\u0123\3\2"+ + "\2\2\u012b\u0124\3\2\2\2\u012b\u0125\3\2\2\2\u012b\u0126\3\2\2\2\u012b"+ + "\u0127\3\2\2\2\u012c\u01a4\3\2\2\2\u012d\u012f\f\30\2\2\u012e\u0130\7"+ + "s\2\2\u012f\u012e\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131"+ + "\u0133\7-\2\2\u0132\u0134\7s\2\2\u0133\u0132\3\2\2\2\u0133\u0134\3\2\2"+ + "\2\u0134\u0135\3\2\2\2\u0135\u01a3\5,\27\31\u0136\u0138\f\27\2\2\u0137"+ + "\u0139\7s\2\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013a\3\2"+ + "\2\2\u013a\u013c\t\7\2\2\u013b\u013d\7s\2\2\u013c\u013b\3\2\2\2\u013c"+ + "\u013d\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u01a3\5,\27\30\u013f\u0141\f"+ + "\26\2\2\u0140\u0142\7s\2\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2\2\2\u0142"+ + "\u0143\3\2\2\2\u0143\u0145\t\b\2\2\u0144\u0146\7s\2\2\u0145\u0144\3\2"+ + "\2\2\u0145\u0146\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u01a3\5,\27\27\u0148"+ + "\u014a\f\25\2\2\u0149\u014b\7s\2\2\u014a\u0149\3\2\2\2\u014a\u014b\3\2"+ + "\2\2\u014b\u014c\3\2\2\2\u014c\u014e\t\t\2\2\u014d\u014f\7s\2\2\u014e"+ + "\u014d\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u01a3\5,"+ + "\27\26\u0151\u0153\f\24\2\2\u0152\u0154\7s\2\2\u0153\u0152\3\2\2\2\u0153"+ + "\u0154\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0157\t\n\2\2\u0156\u0158\7s"+ + "\2\2\u0157\u0156\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159"+ + "\u01a3\5,\27\25\u015a\u015c\f\23\2\2\u015b\u015d\7s\2\2\u015c\u015b\3"+ + "\2\2\2\u015c\u015d\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0160\t\13\2\2\u015f"+ + "\u0161\7s\2\2\u0160\u015f\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0162\3\2"+ + "\2\2\u0162\u01a3\5,\27\24\u0163\u0165\f\22\2\2\u0164\u0166\7s\2\2\u0165"+ + "\u0164\3\2\2\2\u0165\u0166\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0169\7y"+ + "\2\2\u0168\u016a\7s\2\2\u0169\u0168\3\2\2\2\u0169\u016a\3\2\2\2\u016a"+ + "\u016b\3\2\2\2\u016b\u01a3\5,\27\23\u016c\u016e\f\21\2\2\u016d\u016f\7"+ + "s\2\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0170\3\2\2\2\u0170"+ + "\u0172\79\2\2\u0171\u0173\7s\2\2\u0172\u0171\3\2\2\2\u0172\u0173\3\2\2"+ + "\2\u0173\u0174\3\2\2\2\u0174\u01a3\5,\27\22\u0175\u0177\f\20\2\2\u0176"+ + "\u0178\7s\2\2\u0177\u0176\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u0179\3\2"+ + "\2\2\u0179\u017b\7:\2\2\u017a\u017c\7s\2\2\u017b\u017a\3\2\2\2\u017b\u017c"+ + "\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u01a3\5,\27\21\u017e\u0180\f\16\2\2"+ + "\u017f\u0181\7s\2\2\u0180\u017f\3\2\2\2\u0180\u0181\3\2\2\2\u0181\u0182"+ + "\3\2\2\2\u0182\u0184\7=\2\2\u0183\u0185\7s\2\2\u0184\u0183\3\2\2\2\u0184"+ + "\u0185\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u01a3\5,\27\17\u0187\u0189\f"+ + "\r\2\2\u0188\u018a\7s\2\2\u0189\u0188\3\2\2\2\u0189\u018a\3\2\2\2\u018a"+ + "\u018b\3\2\2\2\u018b\u018d\7>\2\2\u018c\u018e\7s\2\2\u018d\u018c\3\2\2"+ + "\2\u018d\u018e\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u01a3\5,\27\16\u0190"+ + "\u0192\f\f\2\2\u0191\u0193\7s\2\2\u0192\u0191\3\2\2\2\u0192\u0193\3\2"+ + "\2\2\u0193\u0194\3\2\2\2\u0194\u0196\7?\2\2\u0195\u0197\7s\2\2\u0196\u0195"+ + "\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u01a3\5,\27\r\u0199"+ + "\u019a\f\17\2\2\u019a\u019b\7;\2\2\u019b\u019e\5,\27\2\u019c\u019d\7<"+ + "\2\2\u019d\u019f\5,\27\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2\2\u019f"+ + "\u01a3\3\2\2\2\u01a0\u01a1\f\4\2\2\u01a1\u01a3\5.\30\2\u01a2\u012d\3\2"+ + "\2\2\u01a2\u0136\3\2\2\2\u01a2\u013f\3\2\2\2\u01a2\u0148\3\2\2\2\u01a2"+ + "\u0151\3\2\2\2\u01a2\u015a\3\2\2\2\u01a2\u0163\3\2\2\2\u01a2\u016c\3\2"+ + "\2\2\u01a2\u0175\3\2\2\2\u01a2\u017e\3\2\2\2\u01a2\u0187\3\2\2\2\u01a2"+ + "\u0190\3\2\2\2\u01a2\u0199\3\2\2\2\u01a2\u01a0\3\2\2\2\u01a3\u01a6\3\2"+ + "\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5-\3\2\2\2\u01a6\u01a4"+ + "\3\2\2\2\u01a7\u01a8\7C\2\2\u01a8\u01a9\5 \21\2\u01a9/\3\2\2\2\u01aa\u01ab"+ + "\5D#\2\u01ab\u01ac\5\"\22\2\u01ac\61\3\2\2\2\u01ad\u01ae\7D\2\2\u01ae"+ + "\u01af\7A\2\2\u01af\u01b0\5,\27\2\u01b0\u01b1\7B\2\2\u01b1\63\3\2\2\2"+ + "\u01b2\u01b3\7y\2\2\u01b3\u01b4\5D#\2\u01b4\65\3\2\2\2\u01b5\u01b6\5D"+ + "#\2\u01b6\u01b8\7A\2\2\u01b7\u01b9\5:\36\2\u01b8\u01b7\3\2\2\2\u01b8\u01b9"+ + "\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb\7B\2\2\u01bb\67\3\2\2\2\u01bc"+ + "\u01be\7t\2\2\u01bd\u01bc\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01bf\3\2"+ + "\2\2\u01bf\u01c0\5D#\2\u01c0\u01c2\7A\2\2\u01c1\u01c3\5:\36\2\u01c2\u01c1"+ + "\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c5\7B\2\2\u01c5"+ + "9\3\2\2\2\u01c6\u01ce\5,\27\2\u01c7\u01c9\7\17\2\2\u01c8\u01ca\7s\2\2"+ + "\u01c9\u01c8\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01cd"+ + "\5,\27\2\u01cc\u01c7\3\2\2\2\u01cd\u01d0\3\2\2\2\u01ce\u01cc\3\2\2\2\u01ce"+ + "\u01cf\3\2\2\2\u01cf;\3\2\2\2\u01d0\u01ce\3\2\2\2\u01d1\u01d3\7E\2\2\u01d2"+ + "\u01d4\5,\27\2\u01d3\u01d2\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4=\3\2\2\2"+ + "\u01d5\u01d6\7F\2\2\u01d6?\3\2\2\2\u01d7\u01d8\7G\2\2\u01d8A\3\2\2\2\u01d9"+ + "\u01da\7u\2\2\u01daC\3\2\2\2\u01db\u01e0\7u\2\2\u01dc\u01dd\7H\2\2\u01dd"+ + "\u01df\7u\2\2\u01de\u01dc\3\2\2\2\u01df\u01e2\3\2\2\2\u01e0\u01de\3\2"+ + "\2\2\u01e0\u01e1\3\2\2\2\u01e1E\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e3\u01e4"+ + "\t\f\2\2\u01e4G\3\2\2\2\u01e5\u01e6\t\r\2\2\u01e6I\3\2\2\2\u01e7\u01e8"+ + "\t\16\2\2\u01e8K\3\2\2\2\u01e9\u01eb\t\17\2\2\u01ea\u01ec\5N(\2\u01eb"+ + "\u01ea\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ecM\3\2\2\2\u01ed\u01ee\7S\2\2\u01ee"+ + "O\3\2\2\2\u01ef\u01f0\t\20\2\2\u01f0Q\3\2\2\2\u01f1\u01f3\7\33\2\2\u01f2"+ + "\u01f4\7s\2\2\u01f3\u01f2\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f5\3\2"+ + "\2\2\u01f5\u01fd\5,\27\2\u01f6\u01f8\7\17\2\2\u01f7\u01f9\7s\2\2\u01f8"+ + "\u01f7\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fc\5,"+ + "\27\2\u01fb\u01f6\3\2\2\2\u01fc\u01ff\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fd"+ + "\u01fe\3\2\2\2\u01fe\u0201\3\2\2\2\u01ff\u01fd\3\2\2\2\u0200\u0202\7s"+ + "\2\2\u0201\u0200\3\2\2\2\u0201\u0202\3\2\2\2\u0202\u0203\3\2\2\2\u0203"+ + "\u0204\7\34\2\2\u0204S\3\2\2\2\u0205\u0207\7\23\2\2\u0206\u0208\7s\2\2"+ + "\u0207\u0206\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0209\3\2\2\2\u0209\u0211"+ + "\5,\27\2\u020a\u020c\7\17\2\2\u020b\u020d\7s\2\2\u020c\u020b\3\2\2\2\u020c"+ + "\u020d\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\5,\27\2\u020f\u020a\3\2"+ + "\2\2\u0210\u0213\3\2\2\2\u0211\u020f\3\2\2\2\u0211\u0212\3\2\2\2\u0212"+ + "\u0215\3\2\2\2\u0213\u0211\3\2\2\2\u0214\u0216\7s\2\2\u0215\u0214\3\2"+ + "\2\2\u0215\u0216\3\2\2\2\u0216\u0217\3\2\2\2\u0217\u0218\7\24\2\2\u0218"+ + "U\3\2\2\2\u0219\u021a\7{\2\2\u021aW\3\2\2\2\u021b\u021c\7}\2\2\u021cY"+ + "\3\2\2\2\u021d\u021e\7z\2\2\u021e[\3\2\2\2\u021f\u0227\5L\'\2\u0220\u0227"+ + "\5P)\2\u0221\u0227\5R*\2\u0222\u0227\5V,\2\u0223\u0227\5X-\2\u0224\u0227"+ + "\5Z.\2\u0225\u0227\5T+\2\u0226\u021f\3\2\2\2\u0226\u0220\3\2\2\2\u0226"+ + "\u0221\3\2\2\2\u0226\u0222\3\2\2\2\u0226\u0223\3\2\2\2\u0226\u0224\3\2"+ + "\2\2\u0226\u0225\3\2\2\2\u0227]\3\2\2\2\u0228\u0229\7V\2\2\u0229\u022a"+ + "\7|\2\2\u022a_\3\2\2\2\u022b\u022c\7W\2\2\u022c\u022d\5B\"\2\u022d\u022f"+ + "\7A\2\2\u022e\u0230\5f\64\2\u022f\u022e\3\2\2\2\u022f\u0230\3\2\2\2\u0230"+ + "\u0231\3\2\2\2\u0231\u0233\7B\2\2\u0232\u0234\5b\62\2\u0233\u0232\3\2"+ + "\2\2\u0233\u0234\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\5d\63\2\u0236"+ + "\u0237\7s\2\2\u0237a\3\2\2\2\u0238\u0239\7X\2\2\u0239\u023a\5h\65\2\u023a"+ + "c\3\2\2\2\u023b\u023c\7\23\2\2\u023c\u0241\7s\2\2\u023d\u0240\5\b\5\2"+ + "\u023e\u0240\7s\2\2\u023f\u023d\3\2\2\2\u023f\u023e\3\2\2\2\u0240\u0243"+ + "\3\2\2\2\u0241\u023f\3\2\2\2\u0241\u0242\3\2\2\2\u0242\u0244\3\2\2\2\u0243"+ + "\u0241\3\2\2\2\u0244\u0245\7\24\2\2\u0245e\3\2\2\2\u0246\u024e\5\22\n"+ + "\2\u0247\u0249\7\17\2\2\u0248\u024a\7s\2\2\u0249\u0248\3\2\2\2\u0249\u024a"+ + "\3\2\2\2\u024a\u024b\3\2\2\2\u024b\u024d\5\22\n\2\u024c\u0247\3\2\2\2"+ + "\u024d\u0250\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024f\3\2\2\2\u024fg\3"+ + "\2\2\2\u0250\u024e\3\2\2\2\u0251\u0259\5 \21\2\u0252\u0254\7\17\2\2\u0253"+ + "\u0255\7s\2\2\u0254\u0253\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u0256\3\2"+ + "\2\2\u0256\u0258\5 \21\2\u0257\u0252\3\2\2\2\u0258\u025b\3\2\2\2\u0259"+ + "\u0257\3\2\2\2\u0259\u025a\3\2\2\2\u025ai\3\2\2\2\u025b\u0259\3\2\2\2"+ + "\u025c\u025d\7Y\2\2\u025d\u025e\5B\"\2\u025e\u0260\7A\2\2\u025f\u0261"+ + "\5n8\2\u0260\u025f\3\2\2\2\u0260\u0261\3\2\2\2\u0261\u0262\3\2\2\2\u0262"+ + "\u0264\7B\2\2\u0263\u0265\7s\2\2\u0264\u0263\3\2\2\2\u0264\u0265\3\2\2"+ + "\2\u0265\u0267\3\2\2\2\u0266\u0268\5r:\2\u0267\u0266\3\2\2\2\u0267\u0268"+ + "\3\2\2\2\u0268\u026a\3\2\2\2\u0269\u026b\5v<\2\u026a\u0269\3\2\2\2\u026a"+ + "\u026b\3\2\2\2\u026b\u026e\3\2\2\2\u026c\u026f\5l\67\2\u026d\u026f\5d"+ + "\63\2\u026e\u026c\3\2\2\2\u026e\u026d\3\2\2\2\u026fk\3\2\2\2\u0270\u0271"+ + "\7\20\2\2\u0271\u0272\5L\'\2\u0272m\3\2\2\2\u0273\u027b\5p9\2\u0274\u0276"+ + "\7\17\2\2\u0275\u0277\7s\2\2\u0276\u0275\3\2\2\2\u0276\u0277\3\2\2\2\u0277"+ + "\u0278\3\2\2\2\u0278\u027a\5p9\2\u0279\u0274\3\2\2\2\u027a\u027d\3\2\2"+ + "\2\u027b\u0279\3\2\2\2\u027b\u027c\3\2\2\2\u027co\3\2\2\2\u027d\u027b"+ + "\3\2\2\2\u027e\u027f\5\22\n\2\u027f\u0283\7D\2\2\u0280\u0284\5H%\2\u0281"+ + "\u0284\5J&\2\u0282\u0284\7Z\2\2\u0283\u0280\3\2\2\2\u0283\u0281\3\2\2"+ + "\2\u0283\u0282\3\2\2\2\u0284q\3\2\2\2\u0285\u0286\7[\2\2\u0286\u0288\7"+ + "A\2\2\u0287\u0289\5t;\2\u0288\u0287\3\2\2\2\u0288\u0289\3\2\2\2\u0289"+ + "\u028a\3\2\2\2\u028a\u028b\7B\2\2\u028bs\3\2\2\2\u028c\u0291\5F$\2\u028d"+ + "\u028e\7\17\2\2\u028e\u0290\5F$\2\u028f\u028d\3\2\2\2\u0290\u0293\3\2"+ + "\2\2\u0291\u028f\3\2\2\2\u0291\u0292\3\2\2\2\u0292u\3\2\2\2\u0293\u0291"+ + "\3\2\2\2\u0294\u0295\7X\2\2\u0295\u029d\5x=\2\u0296\u0298\7\17\2\2\u0297"+ + "\u0299\7s\2\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299\u029a\3\2"+ + "\2\2\u029a\u029c\5x=\2\u029b\u0296\3\2\2\2\u029c\u029f\3\2\2\2\u029d\u029b"+ + "\3\2\2\2\u029d\u029e\3\2\2\2\u029ew\3\2\2\2\u029f\u029d\3\2\2\2\u02a0"+ + "\u02a1\5 \21\2\u02a1\u02a5\7D\2\2\u02a2\u02a6\5H%\2\u02a3\u02a6\5J&\2"+ + "\u02a4\u02a6\7Z\2\2\u02a5\u02a2\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a5\u02a4"+ + "\3\2\2\2\u02a6y\3\2\2\2\u02a7\u02a8\7\\\2\2\u02a8\u02aa\5,\27\2\u02a9"+ + "\u02ab\7s\2\2\u02aa\u02a9\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab\u02ae\3\2"+ + "\2\2\u02ac\u02af\5\b\5\2\u02ad\u02af\5d\63\2\u02ae\u02ac\3\2\2\2\u02ae"+ + "\u02ad\3\2\2\2\u02af\u02b1\3\2\2\2\u02b0\u02b2\7s\2\2\u02b1\u02b0\3\2"+ + "\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b4\3\2\2\2\u02b3\u02b5\5|?\2\u02b4\u02b3"+ + "\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5{\3\2\2\2\u02b6\u02b8\7]\2\2\u02b7\u02b9"+ + "\7s\2\2\u02b8\u02b7\3\2\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba"+ + "\u02bd\5\b\5\2\u02bb\u02bd\5d\63\2\u02bc\u02ba\3\2\2\2\u02bc\u02bb\3\2"+ + "\2\2\u02bd}\3\2\2\2\u02be\u02c0\5\u0080A\2\u02bf\u02c1\7s\2\2\u02c0\u02bf"+ + "\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c4\3\2\2\2\u02c2\u02c5\5\b\5\2\u02c3"+ + "\u02c5\5d\63\2\u02c4\u02c2\3\2\2\2\u02c4\u02c3\3\2\2\2\u02c5\u02c7\3\2"+ + "\2\2\u02c6\u02c8\7s\2\2\u02c7\u02c6\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8"+ + "\u02ca\3\2\2\2\u02c9\u02cb\5|?\2\u02ca\u02c9\3\2\2\2\u02ca\u02cb\3\2\2"+ + "\2\u02cb\u02cc\3\2\2\2\u02cc\u02cd\7s\2\2\u02cd\177\3\2\2\2\u02ce\u02cf"+ + "\t\21\2\2\u02cf\u0081\3\2\2\2\u02d0\u02d3\7j\2\2\u02d1\u02d4\5F$\2\u02d2"+ + "\u02d4\5B\"\2\u02d3\u02d1\3\2\2\2\u02d3\u02d2\3\2\2\2\u02d4\u02d5\3\2"+ + "\2\2\u02d5\u02d6\7k\2\2\u02d6\u02d8\5,\27\2\u02d7\u02d9\7s\2\2\u02d8\u02d7"+ + "\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9\u02dc\3\2\2\2\u02da\u02dd\5\b\5\2\u02db"+ + "\u02dd\5d\63\2\u02dc\u02da\3\2\2\2\u02dc\u02db\3\2\2\2\u02dd\u0083\3\2"+ + "\2\2\u02de\u02df\7l\2\2\u02df\u02e1\5,\27\2\u02e0\u02e2\7s\2\2\u02e1\u02e0"+ + "\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2\u02e5\3\2\2\2\u02e3\u02e6\5\b\5\2\u02e4"+ + "\u02e6\5d\63\2\u02e5\u02e3\3\2\2\2\u02e5\u02e4\3\2\2\2\u02e6\u0085\3\2"+ + "\2\2\u02e7\u02ea\7m\2\2\u02e8\u02eb\5\b\5\2\u02e9\u02eb\5d\63\2\u02ea"+ + "\u02e8\3\2\2\2\u02ea\u02e9\3\2\2\2\u02eb\u02ed\3\2\2\2\u02ec\u02ee\7s"+ + "\2\2\u02ed\u02ec\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef"+ + "\u02f0\7n\2\2\u02f0\u02f1\5,\27\2\u02f1\u0087\3\2\2\2\u02f2\u02f3\7o\2"+ + "\2\u02f3\u02f4\5,\27\2\u02f4\u02f5\7\23\2\2\u02f5\u02fa\7s\2\2\u02f6\u02f9"+ + "\5\u008aF\2\u02f7\u02f9\7s\2\2\u02f8\u02f6\3\2\2\2\u02f8\u02f7\3\2\2\2"+ + "\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb\u02fd"+ + "\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd\u02ff\7\24\2\2\u02fe\u0300\7s\2\2\u02ff"+ + "\u02fe\3\2\2\2\u02ff\u0300\3\2\2\2\u0300\u0089\3\2\2\2\u0301\u0304\5:"+ + "\36\2\u0302\u0304\7]\2\2\u0303\u0301\3\2\2\2\u0303\u0302\3\2\2\2\u0304"+ + "\u0305\3\2\2\2\u0305\u0308\7X\2\2\u0306\u0309\5\b\5\2\u0307\u0309\5d\63"+ + "\2\u0308\u0306\3\2\2\2\u0308\u0307\3\2\2\2\u0309\u008b\3\2\2\2i\u008e"+ + "\u0090\u0097\u009b\u00ba\u00c2\u00c6\u00cd\u00d0\u00d5\u00d9\u00dd\u00fb"+ + "\u00ff\u0116\u012b\u012f\u0133\u0138\u013c\u0141\u0145\u014a\u014e\u0153"+ + "\u0157\u015c\u0160\u0165\u0169\u016e\u0172\u0177\u017b\u0180\u0184\u0189"+ + "\u018d\u0192\u0196\u019e\u01a2\u01a4\u01b8\u01bd\u01c2\u01c9\u01ce\u01d3"+ + "\u01e0\u01eb\u01f3\u01f8\u01fd\u0201\u0207\u020c\u0211\u0215\u0226\u022f"+ + "\u0233\u023f\u0241\u0249\u024e\u0254\u0259\u0260\u0264\u0267\u026a\u026e"+ + "\u0276\u027b\u0283\u0288\u0291\u0298\u029d\u02a5\u02aa\u02ae\u02b1\u02b4"+ + "\u02b8\u02bc\u02c0\u02c4\u02c7\u02ca\u02d3\u02d8\u02dc\u02e1\u02e5\u02ea"+ + "\u02ed\u02f8\u02fa\u02ff\u0303\u0308"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file