@dseict/psc-interpreter 0.0.1 → 0.0.2

package/dist/_antlr/PSCParser.js

@@ -0,0 +1,3075 @@
+// Generated from ./PSCParser.g4 by ANTLR 4.13.2
+// noinspection ES6UnusedImports,JSUnusedGlobalSymbols,JSUnusedLocalSymbols
+import { ATN, ATNDeserializer, DecisionState, DFA, FailedPredicateException, RecognitionException, NoViableAltException, BailErrorStrategy, Parser, ParserATNSimulator, RuleContext, ParserRuleContext, PredictionMode, PredictionContextCache, TerminalNode, RuleNode, Token, TokenStream, Interval, IntervalSet } from 'antlr4';
+import PSCParserVisitor from "./PSCParserVisitor.js";
+export default class PSCParser extends Parser {
+    static INDENT = 1;
+    static DEDENT = 2;
+    static WHITESPACE = 3;
+    static NEWLINE = 4;
+    static COMMENT = 5;
+    static COMMA = 6;
+    static LPAREN = 7;
+    static RPAREN = 8;
+    static LSQUARE = 9;
+    static RSQUARE = 10;
+    static SQUOTE = 11;
+    static DQUOTE = 12;
+    static STRING = 13;
+    static NULL = 14;
+    static INTEGER = 15;
+    static FLOAT = 16;
+    static BOOLEAN = 17;
+    static PLUS = 18;
+    static MINUS = 19;
+    static MULTIPLY = 20;
+    static DIVIDE = 21;
+    static MODULO = 22;
+    static EXPONENT = 23;
+    static AND = 24;
+    static OR = 25;
+    static NOT = 26;
+    static EQUAL = 27;
+    static NEQUAL = 28;
+    static GT = 29;
+    static LT = 30;
+    static GTEQ = 31;
+    static LTEQ = 32;
+    static IF = 33;
+    static ELSE = 34;
+    static WHILE = 35;
+    static DO = 36;
+    static REPEAT = 37;
+    static UNTIL = 38;
+    static FOR = 39;
+    static FROM = 40;
+    static DOWN = 41;
+    static TO = 42;
+    static ASSIGN = 43;
+    static INPUT = 44;
+    static OUTPUT = 45;
+    static SUBPROGRAM = 46;
+    static RETURN = 47;
+    static ID = 48;
+    static EOF = Token.EOF;
+    static RULE_program = 0;
+    static RULE_addOp = 1;
+    static RULE_mulOp = 2;
+    static RULE_expOp = 3;
+    static RULE_compOp = 4;
+    static RULE_expr = 5;
+    static RULE_orExpr = 6;
+    static RULE_andExpr = 7;
+    static RULE_compExpr = 8;
+    static RULE_addExpr = 9;
+    static RULE_mulExpr = 10;
+    static RULE_expExpr = 11;
+    static RULE_unaryExpr = 12;
+    static RULE_notExpr = 13;
+    static RULE_primaryExpr = 14;
+    static RULE_groupExpr = 15;
+    static RULE_atom = 16;
+    static RULE_lits = 17;
+    static RULE_intLits = 18;
+    static RULE_floatLits = 19;
+    static RULE_arrayLits = 20;
+    static RULE_stmts = 21;
+    static RULE_stmt = 22;
+    static RULE_block = 23;
+    static RULE_ifStmt = 24;
+    static RULE_whileStmt = 25;
+    static RULE_doWhileStmt = 26;
+    static RULE_repeatUntilStmt = 27;
+    static RULE_forStmt = 28;
+    static RULE_asmStmt = 29;
+    static RULE_lvalue = 30;
+    static RULE_inputStmt = 31;
+    static RULE_outputStmt = 32;
+    static RULE_subprogram = 33;
+    static RULE_returnStmt = 34;
+    static literalNames = [null, null,
+        null, null,
+        null, null,
+        "','", "'('",
+        "')'", "'['",
+        "']'", "'''",
+        "'\"'", null,
+        "'null'", null,
+        null, null,
+        "'+'", "'-'",
+        "'*'", "'/'",
+        null, null,
+        "'and'", "'or'",
+        "'not'", "'='",
+        "'<>'", "'>'",
+        "'<'", "'>='",
+        "'<='", "'if'",
+        "'else'", "'while'",
+        "'do'", "'repeat'",
+        "'until'", "'for'",
+        "'from'", "'down'",
+        "'to'", "'<-'",
+        "'input'", "'output'",
+        null, "'return'"];
+    static symbolicNames = [null, "INDENT",
+        "DEDENT", "WHITESPACE",
+        "NEWLINE",
+        "COMMENT",
+        "COMMA", "LPAREN",
+        "RPAREN", "LSQUARE",
+        "RSQUARE",
+        "SQUOTE", "DQUOTE",
+        "STRING", "NULL",
+        "INTEGER",
+        "FLOAT", "BOOLEAN",
+        "PLUS", "MINUS",
+        "MULTIPLY",
+        "DIVIDE", "MODULO",
+        "EXPONENT",
+        "AND", "OR",
+        "NOT", "EQUAL",
+        "NEQUAL", "GT",
+        "LT", "GTEQ",
+        "LTEQ", "IF",
+        "ELSE", "WHILE",
+        "DO", "REPEAT",
+        "UNTIL", "FOR",
+        "FROM", "DOWN",
+        "TO", "ASSIGN",
+        "INPUT", "OUTPUT",
+        "SUBPROGRAM",
+        "RETURN", "ID"];
+    // tslint:disable:no-trailing-whitespace
+    static ruleNames = [
+        "program", "addOp", "mulOp", "expOp", "compOp", "expr", "orExpr", "andExpr",
+        "compExpr", "addExpr", "mulExpr", "expExpr", "unaryExpr", "notExpr", "primaryExpr",
+        "groupExpr", "atom", "lits", "intLits", "floatLits", "arrayLits", "stmts",
+        "stmt", "block", "ifStmt", "whileStmt", "doWhileStmt", "repeatUntilStmt",
+        "forStmt", "asmStmt", "lvalue", "inputStmt", "outputStmt", "subprogram",
+        "returnStmt",
+    ];
+    get grammarFileName() { return "PSCParser.g4"; }
+    get literalNames() { return PSCParser.literalNames; }
+    get symbolicNames() { return PSCParser.symbolicNames; }
+    get ruleNames() { return PSCParser.ruleNames; }
+    get serializedATN() { return PSCParser._serializedATN; }
+    createFailedPredicateException(predicate, message) {
+        return new FailedPredicateException(this, predicate, message);
+    }
+    constructor(input) {
+        super(input);
+        this._interp = new ParserATNSimulator(this, PSCParser._ATN, PSCParser.DecisionsToDFA, new PredictionContextCache());
+    }
+    // @RuleVersion(0)
+    program() {
+        let localctx = new ProgramContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 0, PSCParser.RULE_program);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 73;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 46) {
+                    {
+                        {
+                            this.state = 70;
+                            this.subprogram();
+                        }
+                    }
+                    this.state = 75;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 77;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 68149904) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 55389) !== 0)) {
+                    {
+                        this.state = 76;
+                        this.stmts();
+                    }
+                }
+                this.state = 79;
+                this.match(PSCParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    addOp() {
+        let localctx = new AddOpContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 2, PSCParser.RULE_addOp);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 81;
+                _la = this._input.LA(1);
+                if (!(_la === 18 || _la === 19)) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    mulOp() {
+        let localctx = new MulOpContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 4, PSCParser.RULE_mulOp);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 83;
+                _la = this._input.LA(1);
+                if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & 7340032) !== 0))) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    expOp() {
+        let localctx = new ExpOpContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 6, PSCParser.RULE_expOp);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 85;
+                this.match(PSCParser.EXPONENT);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    compOp() {
+        let localctx = new CompOpContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 8, PSCParser.RULE_compOp);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 87;
+                _la = this._input.LA(1);
+                if (!(((((_la - 27)) & ~0x1F) === 0 && ((1 << (_la - 27)) & 63) !== 0))) {
+                    this._errHandler.recoverInline(this);
+                }
+                else {
+                    this._errHandler.reportMatch(this);
+                    this.consume();
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    expr() {
+        let localctx = new ExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 10, PSCParser.RULE_expr);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 89;
+                this.orExpr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    orExpr() {
+        let localctx = new OrExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 12, PSCParser.RULE_orExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 91;
+                this.andExpr();
+                this.state = 96;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 25) {
+                    {
+                        {
+                            this.state = 92;
+                            this.match(PSCParser.OR);
+                            this.state = 93;
+                            this.andExpr();
+                        }
+                    }
+                    this.state = 98;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    andExpr() {
+        let localctx = new AndExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 14, PSCParser.RULE_andExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 99;
+                this.compExpr();
+                this.state = 104;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 24) {
+                    {
+                        {
+                            this.state = 100;
+                            this.match(PSCParser.AND);
+                            this.state = 101;
+                            this.compExpr();
+                        }
+                    }
+                    this.state = 106;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    compExpr() {
+        let localctx = new CompExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 16, PSCParser.RULE_compExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 107;
+                this.addExpr();
+                this.state = 113;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (((((_la - 27)) & ~0x1F) === 0 && ((1 << (_la - 27)) & 63) !== 0)) {
+                    {
+                        {
+                            this.state = 108;
+                            this.compOp();
+                            this.state = 109;
+                            this.addExpr();
+                        }
+                    }
+                    this.state = 115;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    addExpr() {
+        let localctx = new AddExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 18, PSCParser.RULE_addExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 116;
+                this.mulExpr();
+                this.state = 122;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 18 || _la === 19) {
+                    {
+                        {
+                            this.state = 117;
+                            this.addOp();
+                            this.state = 118;
+                            this.mulExpr();
+                        }
+                    }
+                    this.state = 124;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    mulExpr() {
+        let localctx = new MulExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 20, PSCParser.RULE_mulExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 125;
+                this.expExpr();
+                this.state = 131;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 7340032) !== 0)) {
+                    {
+                        {
+                            this.state = 126;
+                            this.mulOp();
+                            this.state = 127;
+                            this.expExpr();
+                        }
+                    }
+                    this.state = 133;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    expExpr() {
+        let localctx = new ExpExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 22, PSCParser.RULE_expExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 134;
+                this.unaryExpr();
+                this.state = 140;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 23) {
+                    {
+                        {
+                            this.state = 135;
+                            this.expOp();
+                            this.state = 136;
+                            this.unaryExpr();
+                        }
+                    }
+                    this.state = 142;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    unaryExpr() {
+        let localctx = new UnaryExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 24, PSCParser.RULE_unaryExpr);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 146;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 8, this._ctx);
+                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 143;
+                                _la = this._input.LA(1);
+                                if (!(_la === 18 || _la === 19)) {
+                                    this._errHandler.recoverInline(this);
+                                }
+                                else {
+                                    this._errHandler.reportMatch(this);
+                                    this.consume();
+                                }
+                            }
+                        }
+                    }
+                    this.state = 148;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 8, this._ctx);
+                }
+                this.state = 149;
+                this.notExpr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    notExpr() {
+        let localctx = new NotExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 26, PSCParser.RULE_notExpr);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 154;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 26) {
+                    {
+                        {
+                            this.state = 151;
+                            this.match(PSCParser.NOT);
+                        }
+                    }
+                    this.state = 156;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 157;
+                this.primaryExpr(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    primaryExpr(_p) {
+        if (_p === undefined) {
+            _p = 0;
+        }
+        let _parentctx = this._ctx;
+        let _parentState = this.state;
+        let localctx = new PrimaryExprContext(this, this._ctx, _parentState);
+        let _prevctx = localctx;
+        let _startState = 28;
+        this.enterRecursionRule(localctx, 28, PSCParser.RULE_primaryExpr, _p);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                {
+                    this.state = 160;
+                    this.groupExpr();
+                }
+                this._ctx.stop = this._input.LT(-1);
+                this.state = 189;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 14, this._ctx);
+                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        if (this._parseListeners != null) {
+                            this.triggerExitRuleEvent();
+                        }
+                        _prevctx = localctx;
+                        {
+                            this.state = 187;
+                            this._errHandler.sync(this);
+                            switch (this._interp.adaptivePredict(this._input, 13, this._ctx)) {
+                                case 1:
+                                    {
+                                        localctx = new PrimaryExprContext(this, _parentctx, _parentState);
+                                        this.pushNewRecursionContext(localctx, _startState, PSCParser.RULE_primaryExpr);
+                                        this.state = 162;
+                                        if (!(this.precpred(this._ctx, 2))) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
+                                        }
+                                        this.state = 163;
+                                        this.match(PSCParser.LSQUARE);
+                                        this.state = 164;
+                                        this.expr();
+                                        this.state = 169;
+                                        this._errHandler.sync(this);
+                                        _la = this._input.LA(1);
+                                        while (_la === 6) {
+                                            {
+                                                {
+                                                    this.state = 165;
+                                                    this.match(PSCParser.COMMA);
+                                                    this.state = 166;
+                                                    this.expr();
+                                                }
+                                            }
+                                            this.state = 171;
+                                            this._errHandler.sync(this);
+                                            _la = this._input.LA(1);
+                                        }
+                                        this.state = 172;
+                                        this.match(PSCParser.RSQUARE);
+                                    }
+                                    break;
+                                case 2:
+                                    {
+                                        localctx = new PrimaryExprContext(this, _parentctx, _parentState);
+                                        this.pushNewRecursionContext(localctx, _startState, PSCParser.RULE_primaryExpr);
+                                        this.state = 174;
+                                        if (!(this.precpred(this._ctx, 1))) {
+                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
+                                        }
+                                        this.state = 175;
+                                        this.match(PSCParser.LPAREN);
+                                        this.state = 184;
+                                        this._errHandler.sync(this);
+                                        _la = this._input.LA(1);
+                                        if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 68149888) !== 0) || _la === 48) {
+                                            {
+                                                this.state = 176;
+                                                this.expr();
+                                                this.state = 181;
+                                                this._errHandler.sync(this);
+                                                _la = this._input.LA(1);
+                                                while (_la === 6) {
+                                                    {
+                                                        {
+                                                            this.state = 177;
+                                                            this.match(PSCParser.COMMA);
+                                                            this.state = 178;
+                                                            this.expr();
+                                                        }
+                                                    }
+                                                    this.state = 183;
+                                                    this._errHandler.sync(this);
+                                                    _la = this._input.LA(1);
+                                                }
+                                            }
+                                        }
+                                        this.state = 186;
+                                        this.match(PSCParser.RPAREN);
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    this.state = 191;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 14, this._ctx);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(_parentctx);
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    groupExpr() {
+        let localctx = new GroupExprContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 30, PSCParser.RULE_groupExpr);
+        try {
+            this.state = 197;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case 9:
+                case 13:
+                case 14:
+                case 15:
+                case 16:
+                case 17:
+                case 19:
+                case 48:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 192;
+                        this.atom();
+                    }
+                    break;
+                case 7:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        {
+                            this.state = 193;
+                            this.match(PSCParser.LPAREN);
+                            this.state = 194;
+                            this.expr();
+                            this.state = 195;
+                            this.match(PSCParser.RPAREN);
+                        }
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    atom() {
+        let localctx = new AtomContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 32, PSCParser.RULE_atom);
+        try {
+            this.state = 201;
+            this._errHandler.sync(this);
+            switch (this._input.LA(1)) {
+                case 9:
+                case 13:
+                case 14:
+                case 15:
+                case 16:
+                case 17:
+                case 19:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 199;
+                        this.lits();
+                    }
+                    break;
+                case 48:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 200;
+                        this.match(PSCParser.ID);
+                    }
+                    break;
+                default:
+                    throw new NoViableAltException(this);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    lits() {
+        let localctx = new LitsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 34, PSCParser.RULE_lits);
+        try {
+            this.state = 209;
+            this._errHandler.sync(this);
+            switch (this._interp.adaptivePredict(this._input, 17, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 203;
+                        this.intLits();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 204;
+                        this.floatLits();
+                    }
+                    break;
+                case 3:
+                    this.enterOuterAlt(localctx, 3);
+                    {
+                        this.state = 205;
+                        this.arrayLits();
+                    }
+                    break;
+                case 4:
+                    this.enterOuterAlt(localctx, 4);
+                    {
+                        this.state = 206;
+                        this.match(PSCParser.STRING);
+                    }
+                    break;
+                case 5:
+                    this.enterOuterAlt(localctx, 5);
+                    {
+                        this.state = 207;
+                        this.match(PSCParser.BOOLEAN);
+                    }
+                    break;
+                case 6:
+                    this.enterOuterAlt(localctx, 6);
+                    {
+                        this.state = 208;
+                        this.match(PSCParser.NULL);
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    intLits() {
+        let localctx = new IntLitsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 36, PSCParser.RULE_intLits);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 212;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 19) {
+                    {
+                        this.state = 211;
+                        this.match(PSCParser.MINUS);
+                    }
+                }
+                this.state = 214;
+                this.match(PSCParser.INTEGER);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    floatLits() {
+        let localctx = new FloatLitsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 38, PSCParser.RULE_floatLits);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 217;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 19) {
+                    {
+                        this.state = 216;
+                        this.match(PSCParser.MINUS);
+                    }
+                }
+                this.state = 219;
+                this.match(PSCParser.FLOAT);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    arrayLits() {
+        let localctx = new ArrayLitsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 40, PSCParser.RULE_arrayLits);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 221;
+                this.match(PSCParser.LSQUARE);
+                this.state = 230;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 68149888) !== 0) || _la === 48) {
+                    {
+                        this.state = 222;
+                        this.expr();
+                        this.state = 227;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 6) {
+                            {
+                                {
+                                    this.state = 223;
+                                    this.match(PSCParser.COMMA);
+                                    this.state = 224;
+                                    this.expr();
+                                }
+                            }
+                            this.state = 229;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                    }
+                }
+                this.state = 232;
+                this.match(PSCParser.RSQUARE);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    stmts() {
+        let localctx = new StmtsContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 42, PSCParser.RULE_stmts);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 237;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 4) {
+                    {
+                        {
+                            this.state = 234;
+                            this.match(PSCParser.NEWLINE);
+                        }
+                    }
+                    this.state = 239;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+                this.state = 240;
+                this.stmt();
+                this.state = 249;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 24, this._ctx);
+                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        {
+                            {
+                                this.state = 242;
+                                this._errHandler.sync(this);
+                                _la = this._input.LA(1);
+                                do {
+                                    {
+                                        {
+                                            this.state = 241;
+                                            this.match(PSCParser.NEWLINE);
+                                        }
+                                    }
+                                    this.state = 244;
+                                    this._errHandler.sync(this);
+                                    _la = this._input.LA(1);
+                                } while (_la === 4);
+                                this.state = 246;
+                                this.stmt();
+                            }
+                        }
+                    }
+                    this.state = 251;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 24, this._ctx);
+                }
+                this.state = 255;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                while (_la === 4) {
+                    {
+                        {
+                            this.state = 252;
+                            this.match(PSCParser.NEWLINE);
+                        }
+                    }
+                    this.state = 257;
+                    this._errHandler.sync(this);
+                    _la = this._input.LA(1);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    stmt() {
+        let localctx = new StmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 44, PSCParser.RULE_stmt);
+        try {
+            this.state = 268;
+            this._errHandler.sync(this);
+            switch (this._interp.adaptivePredict(this._input, 26, this._ctx)) {
+                case 1:
+                    this.enterOuterAlt(localctx, 1);
+                    {
+                        this.state = 258;
+                        this.expr();
+                    }
+                    break;
+                case 2:
+                    this.enterOuterAlt(localctx, 2);
+                    {
+                        this.state = 259;
+                        this.ifStmt();
+                    }
+                    break;
+                case 3:
+                    this.enterOuterAlt(localctx, 3);
+                    {
+                        this.state = 260;
+                        this.whileStmt();
+                    }
+                    break;
+                case 4:
+                    this.enterOuterAlt(localctx, 4);
+                    {
+                        this.state = 261;
+                        this.doWhileStmt();
+                    }
+                    break;
+                case 5:
+                    this.enterOuterAlt(localctx, 5);
+                    {
+                        this.state = 262;
+                        this.repeatUntilStmt();
+                    }
+                    break;
+                case 6:
+                    this.enterOuterAlt(localctx, 6);
+                    {
+                        this.state = 263;
+                        this.forStmt();
+                    }
+                    break;
+                case 7:
+                    this.enterOuterAlt(localctx, 7);
+                    {
+                        this.state = 264;
+                        this.asmStmt();
+                    }
+                    break;
+                case 8:
+                    this.enterOuterAlt(localctx, 8);
+                    {
+                        this.state = 265;
+                        this.inputStmt();
+                    }
+                    break;
+                case 9:
+                    this.enterOuterAlt(localctx, 9);
+                    {
+                        this.state = 266;
+                        this.outputStmt();
+                    }
+                    break;
+                case 10:
+                    this.enterOuterAlt(localctx, 10);
+                    {
+                        this.state = 267;
+                        this.returnStmt();
+                    }
+                    break;
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    block() {
+        let localctx = new BlockContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 46, PSCParser.RULE_block);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 270;
+                this.match(PSCParser.INDENT);
+                this.state = 271;
+                this.stmts();
+                this.state = 272;
+                this.match(PSCParser.DEDENT);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    ifStmt() {
+        let localctx = new IfStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 48, PSCParser.RULE_ifStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 274;
+                this.match(PSCParser.IF);
+                this.state = 275;
+                this.expr();
+                this.state = 276;
+                this.match(PSCParser.NEWLINE);
+                this.state = 277;
+                this.block();
+                this.state = 285;
+                this._errHandler.sync(this);
+                switch (this._interp.adaptivePredict(this._input, 27, this._ctx)) {
+                    case 1:
+                        {
+                            this.state = 278;
+                            this.match(PSCParser.NEWLINE);
+                            this.state = 279;
+                            this.match(PSCParser.ELSE);
+                            this.state = 280;
+                            this.ifStmt();
+                        }
+                        break;
+                    case 2:
+                        {
+                            this.state = 281;
+                            this.match(PSCParser.NEWLINE);
+                            this.state = 282;
+                            this.match(PSCParser.ELSE);
+                            this.state = 283;
+                            this.match(PSCParser.NEWLINE);
+                            this.state = 284;
+                            this.block();
+                        }
+                        break;
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    whileStmt() {
+        let localctx = new WhileStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 50, PSCParser.RULE_whileStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 287;
+                this.match(PSCParser.WHILE);
+                this.state = 288;
+                this.expr();
+                this.state = 289;
+                this.match(PSCParser.NEWLINE);
+                this.state = 290;
+                this.block();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    doWhileStmt() {
+        let localctx = new DoWhileStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 52, PSCParser.RULE_doWhileStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 292;
+                this.match(PSCParser.DO);
+                this.state = 293;
+                this.match(PSCParser.NEWLINE);
+                this.state = 294;
+                this.block();
+                this.state = 295;
+                this.match(PSCParser.NEWLINE);
+                this.state = 296;
+                this.match(PSCParser.WHILE);
+                this.state = 297;
+                this.expr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    repeatUntilStmt() {
+        let localctx = new RepeatUntilStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 54, PSCParser.RULE_repeatUntilStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 299;
+                this.match(PSCParser.REPEAT);
+                this.state = 300;
+                this.match(PSCParser.NEWLINE);
+                this.state = 301;
+                this.block();
+                this.state = 302;
+                this.match(PSCParser.NEWLINE);
+                this.state = 303;
+                this.match(PSCParser.UNTIL);
+                this.state = 304;
+                this.expr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    forStmt() {
+        let localctx = new ForStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 56, PSCParser.RULE_forStmt);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 306;
+                this.match(PSCParser.FOR);
+                this.state = 307;
+                this.match(PSCParser.ID);
+                this.state = 308;
+                this.match(PSCParser.FROM);
+                this.state = 309;
+                this.expr();
+                this.state = 311;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 41) {
+                    {
+                        this.state = 310;
+                        this.match(PSCParser.DOWN);
+                    }
+                }
+                this.state = 313;
+                this.match(PSCParser.TO);
+                this.state = 314;
+                this.expr();
+                this.state = 315;
+                this.match(PSCParser.NEWLINE);
+                this.state = 316;
+                this.block();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    asmStmt() {
+        let localctx = new AsmStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 58, PSCParser.RULE_asmStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 318;
+                this.lvalue(0);
+                this.state = 319;
+                this.match(PSCParser.ASSIGN);
+                this.state = 320;
+                this.expr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    lvalue(_p) {
+        if (_p === undefined) {
+            _p = 0;
+        }
+        let _parentctx = this._ctx;
+        let _parentState = this.state;
+        let localctx = new LvalueContext(this, this._ctx, _parentState);
+        let _prevctx = localctx;
+        let _startState = 60;
+        this.enterRecursionRule(localctx, 60, PSCParser.RULE_lvalue, _p);
+        let _la;
+        try {
+            let _alt;
+            this.enterOuterAlt(localctx, 1);
+            {
+                {
+                    this.state = 323;
+                    this.match(PSCParser.ID);
+                }
+                this._ctx.stop = this._input.LT(-1);
+                this.state = 339;
+                this._errHandler.sync(this);
+                _alt = this._interp.adaptivePredict(this._input, 30, this._ctx);
+                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
+                    if (_alt === 1) {
+                        if (this._parseListeners != null) {
+                            this.triggerExitRuleEvent();
+                        }
+                        _prevctx = localctx;
+                        {
+                            {
+                                localctx = new LvalueContext(this, _parentctx, _parentState);
+                                this.pushNewRecursionContext(localctx, _startState, PSCParser.RULE_lvalue);
+                                this.state = 325;
+                                if (!(this.precpred(this._ctx, 1))) {
+                                    throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
+                                }
+                                this.state = 326;
+                                this.match(PSCParser.LSQUARE);
+                                this.state = 327;
+                                this.expr();
+                                this.state = 332;
+                                this._errHandler.sync(this);
+                                _la = this._input.LA(1);
+                                while (_la === 6) {
+                                    {
+                                        {
+                                            this.state = 328;
+                                            this.match(PSCParser.COMMA);
+                                            this.state = 329;
+                                            this.expr();
+                                        }
+                                    }
+                                    this.state = 334;
+                                    this._errHandler.sync(this);
+                                    _la = this._input.LA(1);
+                                }
+                                this.state = 335;
+                                this.match(PSCParser.RSQUARE);
+                            }
+                        }
+                    }
+                    this.state = 341;
+                    this._errHandler.sync(this);
+                    _alt = this._interp.adaptivePredict(this._input, 30, this._ctx);
+                }
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.unrollRecursionContexts(_parentctx);
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    inputStmt() {
+        let localctx = new InputStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 62, PSCParser.RULE_inputStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 342;
+                this.match(PSCParser.INPUT);
+                this.state = 343;
+                this.lvalue(0);
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    outputStmt() {
+        let localctx = new OutputStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 64, PSCParser.RULE_outputStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 345;
+                this.match(PSCParser.OUTPUT);
+                this.state = 346;
+                this.expr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    subprogram() {
+        let localctx = new SubprogramContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 66, PSCParser.RULE_subprogram);
+        let _la;
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 348;
+                this.match(PSCParser.SUBPROGRAM);
+                this.state = 349;
+                this.match(PSCParser.ID);
+                this.state = 350;
+                this.match(PSCParser.LPAREN);
+                this.state = 359;
+                this._errHandler.sync(this);
+                _la = this._input.LA(1);
+                if (_la === 48) {
+                    {
+                        this.state = 351;
+                        this.match(PSCParser.ID);
+                        this.state = 356;
+                        this._errHandler.sync(this);
+                        _la = this._input.LA(1);
+                        while (_la === 6) {
+                            {
+                                {
+                                    this.state = 352;
+                                    this.match(PSCParser.COMMA);
+                                    this.state = 353;
+                                    this.match(PSCParser.ID);
+                                }
+                            }
+                            this.state = 358;
+                            this._errHandler.sync(this);
+                            _la = this._input.LA(1);
+                        }
+                    }
+                }
+                this.state = 361;
+                this.match(PSCParser.RPAREN);
+                this.state = 362;
+                this.match(PSCParser.NEWLINE);
+                this.state = 363;
+                this.block();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    // @RuleVersion(0)
+    returnStmt() {
+        let localctx = new ReturnStmtContext(this, this._ctx, this.state);
+        this.enterRule(localctx, 68, PSCParser.RULE_returnStmt);
+        try {
+            this.enterOuterAlt(localctx, 1);
+            {
+                this.state = 365;
+                this.match(PSCParser.RETURN);
+                this.state = 366;
+                this.expr();
+            }
+        }
+        catch (re) {
+            if (re instanceof RecognitionException) {
+                localctx.exception = re;
+                this._errHandler.reportError(this, re);
+                this._errHandler.recover(this, re);
+            }
+            else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localctx;
+    }
+    sempred(localctx, ruleIndex, predIndex) {
+        switch (ruleIndex) {
+            case 14:
+                return this.primaryExpr_sempred(localctx, predIndex);
+            case 30:
+                return this.lvalue_sempred(localctx, predIndex);
+        }
+        return true;
+    }
+    primaryExpr_sempred(localctx, predIndex) {
+        switch (predIndex) {
+            case 0:
+                return this.precpred(this._ctx, 2);
+            case 1:
+                return this.precpred(this._ctx, 1);
+        }
+        return true;
+    }
+    lvalue_sempred(localctx, predIndex) {
+        switch (predIndex) {
+            case 2:
+                return this.precpred(this._ctx, 1);
+        }
+        return true;
+    }
+    static _serializedATN = [4, 1, 48, 369, 2, 0, 7, 0, 2,
+        1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2,
+        10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17,
+        7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7,
+        24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31,
+        2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 1, 0, 5, 0, 72, 8, 0, 10, 0, 12, 0, 75, 9, 0, 1, 0, 3, 0, 78,
+        8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 5, 6, 95,
+        8, 6, 10, 6, 12, 6, 98, 9, 6, 1, 7, 1, 7, 1, 7, 5, 7, 103, 8, 7, 10, 7, 12, 7, 106, 9, 7, 1, 8, 1, 8,
+        1, 8, 1, 8, 5, 8, 112, 8, 8, 10, 8, 12, 8, 115, 9, 8, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 121, 8, 9, 10, 9,
+        12, 9, 124, 9, 9, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 130, 8, 10, 10, 10, 12, 10, 133, 9, 10, 1, 11,
+        1, 11, 1, 11, 1, 11, 5, 11, 139, 8, 11, 10, 11, 12, 11, 142, 9, 11, 1, 12, 5, 12, 145, 8, 12, 10,
+        12, 12, 12, 148, 9, 12, 1, 12, 1, 12, 1, 13, 5, 13, 153, 8, 13, 10, 13, 12, 13, 156, 9, 13, 1, 13,
+        1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 168, 8, 14, 10, 14, 12, 14,
+        171, 9, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 180, 8, 14, 10, 14, 12, 14, 183,
+        9, 14, 3, 14, 185, 8, 14, 1, 14, 5, 14, 188, 8, 14, 10, 14, 12, 14, 191, 9, 14, 1, 15, 1, 15, 1,
+        15, 1, 15, 1, 15, 3, 15, 198, 8, 15, 1, 16, 1, 16, 3, 16, 202, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17,
+        1, 17, 1, 17, 3, 17, 210, 8, 17, 1, 18, 3, 18, 213, 8, 18, 1, 18, 1, 18, 1, 19, 3, 19, 218, 8, 19,
+        1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 226, 8, 20, 10, 20, 12, 20, 229, 9, 20, 3, 20, 231,
+        8, 20, 1, 20, 1, 20, 1, 21, 5, 21, 236, 8, 21, 10, 21, 12, 21, 239, 9, 21, 1, 21, 1, 21, 4, 21, 243,
+        8, 21, 11, 21, 12, 21, 244, 1, 21, 5, 21, 248, 8, 21, 10, 21, 12, 21, 251, 9, 21, 1, 21, 5, 21,
+        254, 8, 21, 10, 21, 12, 21, 257, 9, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1,
+        22, 1, 22, 3, 22, 269, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24,
+        1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 286, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1,
+        26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28,
+        1, 28, 1, 28, 1, 28, 3, 28, 312, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1,
+        29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 5, 30, 331, 8, 30, 10, 30, 12, 30, 334,
+        9, 30, 1, 30, 1, 30, 5, 30, 338, 8, 30, 10, 30, 12, 30, 341, 9, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1,
+        32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 355, 8, 33, 10, 33, 12, 33, 358, 9, 33,
+        3, 33, 360, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 0, 2, 28, 60, 35, 0, 2,
+        4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52,
+        54, 56, 58, 60, 62, 64, 66, 68, 0, 3, 1, 0, 18, 19, 1, 0, 20, 22, 1, 0, 27, 32, 379, 0, 73, 1, 0,
+        0, 0, 2, 81, 1, 0, 0, 0, 4, 83, 1, 0, 0, 0, 6, 85, 1, 0, 0, 0, 8, 87, 1, 0, 0, 0, 10, 89, 1, 0, 0, 0, 12,
+        91, 1, 0, 0, 0, 14, 99, 1, 0, 0, 0, 16, 107, 1, 0, 0, 0, 18, 116, 1, 0, 0, 0, 20, 125, 1, 0, 0, 0, 22,
+        134, 1, 0, 0, 0, 24, 146, 1, 0, 0, 0, 26, 154, 1, 0, 0, 0, 28, 159, 1, 0, 0, 0, 30, 197, 1, 0, 0, 0,
+        32, 201, 1, 0, 0, 0, 34, 209, 1, 0, 0, 0, 36, 212, 1, 0, 0, 0, 38, 217, 1, 0, 0, 0, 40, 221, 1, 0,
+        0, 0, 42, 237, 1, 0, 0, 0, 44, 268, 1, 0, 0, 0, 46, 270, 1, 0, 0, 0, 48, 274, 1, 0, 0, 0, 50, 287,
+        1, 0, 0, 0, 52, 292, 1, 0, 0, 0, 54, 299, 1, 0, 0, 0, 56, 306, 1, 0, 0, 0, 58, 318, 1, 0, 0, 0, 60,
+        322, 1, 0, 0, 0, 62, 342, 1, 0, 0, 0, 64, 345, 1, 0, 0, 0, 66, 348, 1, 0, 0, 0, 68, 365, 1, 0, 0, 0,
+        70, 72, 3, 66, 33, 0, 71, 70, 1, 0, 0, 0, 72, 75, 1, 0, 0, 0, 73, 71, 1, 0, 0, 0, 73, 74, 1, 0, 0, 0,
+        74, 77, 1, 0, 0, 0, 75, 73, 1, 0, 0, 0, 76, 78, 3, 42, 21, 0, 77, 76, 1, 0, 0, 0, 77, 78, 1, 0, 0, 0,
+        78, 79, 1, 0, 0, 0, 79, 80, 5, 0, 0, 1, 80, 1, 1, 0, 0, 0, 81, 82, 7, 0, 0, 0, 82, 3, 1, 0, 0, 0, 83,
+        84, 7, 1, 0, 0, 84, 5, 1, 0, 0, 0, 85, 86, 5, 23, 0, 0, 86, 7, 1, 0, 0, 0, 87, 88, 7, 2, 0, 0, 88, 9,
+        1, 0, 0, 0, 89, 90, 3, 12, 6, 0, 90, 11, 1, 0, 0, 0, 91, 96, 3, 14, 7, 0, 92, 93, 5, 25, 0, 0, 93, 95,
+        3, 14, 7, 0, 94, 92, 1, 0, 0, 0, 95, 98, 1, 0, 0, 0, 96, 94, 1, 0, 0, 0, 96, 97, 1, 0, 0, 0, 97, 13,
+        1, 0, 0, 0, 98, 96, 1, 0, 0, 0, 99, 104, 3, 16, 8, 0, 100, 101, 5, 24, 0, 0, 101, 103, 3, 16, 8, 0,
+        102, 100, 1, 0, 0, 0, 103, 106, 1, 0, 0, 0, 104, 102, 1, 0, 0, 0, 104, 105, 1, 0, 0, 0, 105, 15,
+        1, 0, 0, 0, 106, 104, 1, 0, 0, 0, 107, 113, 3, 18, 9, 0, 108, 109, 3, 8, 4, 0, 109, 110, 3, 18, 9,
+        0, 110, 112, 1, 0, 0, 0, 111, 108, 1, 0, 0, 0, 112, 115, 1, 0, 0, 0, 113, 111, 1, 0, 0, 0, 113, 114,
+        1, 0, 0, 0, 114, 17, 1, 0, 0, 0, 115, 113, 1, 0, 0, 0, 116, 122, 3, 20, 10, 0, 117, 118, 3, 2, 1,
+        0, 118, 119, 3, 20, 10, 0, 119, 121, 1, 0, 0, 0, 120, 117, 1, 0, 0, 0, 121, 124, 1, 0, 0, 0, 122,
+        120, 1, 0, 0, 0, 122, 123, 1, 0, 0, 0, 123, 19, 1, 0, 0, 0, 124, 122, 1, 0, 0, 0, 125, 131, 3, 22,
+        11, 0, 126, 127, 3, 4, 2, 0, 127, 128, 3, 22, 11, 0, 128, 130, 1, 0, 0, 0, 129, 126, 1, 0, 0, 0,
+        130, 133, 1, 0, 0, 0, 131, 129, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 21, 1, 0, 0, 0, 133, 131,
+        1, 0, 0, 0, 134, 140, 3, 24, 12, 0, 135, 136, 3, 6, 3, 0, 136, 137, 3, 24, 12, 0, 137, 139, 1, 0,
+        0, 0, 138, 135, 1, 0, 0, 0, 139, 142, 1, 0, 0, 0, 140, 138, 1, 0, 0, 0, 140, 141, 1, 0, 0, 0, 141,
+        23, 1, 0, 0, 0, 142, 140, 1, 0, 0, 0, 143, 145, 7, 0, 0, 0, 144, 143, 1, 0, 0, 0, 145, 148, 1, 0,
+        0, 0, 146, 144, 1, 0, 0, 0, 146, 147, 1, 0, 0, 0, 147, 149, 1, 0, 0, 0, 148, 146, 1, 0, 0, 0, 149,
+        150, 3, 26, 13, 0, 150, 25, 1, 0, 0, 0, 151, 153, 5, 26, 0, 0, 152, 151, 1, 0, 0, 0, 153, 156, 1,
+        0, 0, 0, 154, 152, 1, 0, 0, 0, 154, 155, 1, 0, 0, 0, 155, 157, 1, 0, 0, 0, 156, 154, 1, 0, 0, 0, 157,
+        158, 3, 28, 14, 0, 158, 27, 1, 0, 0, 0, 159, 160, 6, 14, -1, 0, 160, 161, 3, 30, 15, 0, 161, 189,
+        1, 0, 0, 0, 162, 163, 10, 2, 0, 0, 163, 164, 5, 9, 0, 0, 164, 169, 3, 10, 5, 0, 165, 166, 5, 6, 0,
+        0, 166, 168, 3, 10, 5, 0, 167, 165, 1, 0, 0, 0, 168, 171, 1, 0, 0, 0, 169, 167, 1, 0, 0, 0, 169,
+        170, 1, 0, 0, 0, 170, 172, 1, 0, 0, 0, 171, 169, 1, 0, 0, 0, 172, 173, 5, 10, 0, 0, 173, 188, 1,
+        0, 0, 0, 174, 175, 10, 1, 0, 0, 175, 184, 5, 7, 0, 0, 176, 181, 3, 10, 5, 0, 177, 178, 5, 6, 0, 0,
+        178, 180, 3, 10, 5, 0, 179, 177, 1, 0, 0, 0, 180, 183, 1, 0, 0, 0, 181, 179, 1, 0, 0, 0, 181, 182,
+        1, 0, 0, 0, 182, 185, 1, 0, 0, 0, 183, 181, 1, 0, 0, 0, 184, 176, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0,
+        185, 186, 1, 0, 0, 0, 186, 188, 5, 8, 0, 0, 187, 162, 1, 0, 0, 0, 187, 174, 1, 0, 0, 0, 188, 191,
+        1, 0, 0, 0, 189, 187, 1, 0, 0, 0, 189, 190, 1, 0, 0, 0, 190, 29, 1, 0, 0, 0, 191, 189, 1, 0, 0, 0,
+        192, 198, 3, 32, 16, 0, 193, 194, 5, 7, 0, 0, 194, 195, 3, 10, 5, 0, 195, 196, 5, 8, 0, 0, 196,
+        198, 1, 0, 0, 0, 197, 192, 1, 0, 0, 0, 197, 193, 1, 0, 0, 0, 198, 31, 1, 0, 0, 0, 199, 202, 3, 34,
+        17, 0, 200, 202, 5, 48, 0, 0, 201, 199, 1, 0, 0, 0, 201, 200, 1, 0, 0, 0, 202, 33, 1, 0, 0, 0, 203,
+        210, 3, 36, 18, 0, 204, 210, 3, 38, 19, 0, 205, 210, 3, 40, 20, 0, 206, 210, 5, 13, 0, 0, 207,
+        210, 5, 17, 0, 0, 208, 210, 5, 14, 0, 0, 209, 203, 1, 0, 0, 0, 209, 204, 1, 0, 0, 0, 209, 205, 1,
+        0, 0, 0, 209, 206, 1, 0, 0, 0, 209, 207, 1, 0, 0, 0, 209, 208, 1, 0, 0, 0, 210, 35, 1, 0, 0, 0, 211,
+        213, 5, 19, 0, 0, 212, 211, 1, 0, 0, 0, 212, 213, 1, 0, 0, 0, 213, 214, 1, 0, 0, 0, 214, 215, 5,
+        15, 0, 0, 215, 37, 1, 0, 0, 0, 216, 218, 5, 19, 0, 0, 217, 216, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0,
+        218, 219, 1, 0, 0, 0, 219, 220, 5, 16, 0, 0, 220, 39, 1, 0, 0, 0, 221, 230, 5, 9, 0, 0, 222, 227,
+        3, 10, 5, 0, 223, 224, 5, 6, 0, 0, 224, 226, 3, 10, 5, 0, 225, 223, 1, 0, 0, 0, 226, 229, 1, 0, 0,
+        0, 227, 225, 1, 0, 0, 0, 227, 228, 1, 0, 0, 0, 228, 231, 1, 0, 0, 0, 229, 227, 1, 0, 0, 0, 230, 222,
+        1, 0, 0, 0, 230, 231, 1, 0, 0, 0, 231, 232, 1, 0, 0, 0, 232, 233, 5, 10, 0, 0, 233, 41, 1, 0, 0, 0,
+        234, 236, 5, 4, 0, 0, 235, 234, 1, 0, 0, 0, 236, 239, 1, 0, 0, 0, 237, 235, 1, 0, 0, 0, 237, 238,
+        1, 0, 0, 0, 238, 240, 1, 0, 0, 0, 239, 237, 1, 0, 0, 0, 240, 249, 3, 44, 22, 0, 241, 243, 5, 4, 0,
+        0, 242, 241, 1, 0, 0, 0, 243, 244, 1, 0, 0, 0, 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 246,
+        1, 0, 0, 0, 246, 248, 3, 44, 22, 0, 247, 242, 1, 0, 0, 0, 248, 251, 1, 0, 0, 0, 249, 247, 1, 0, 0,
+        0, 249, 250, 1, 0, 0, 0, 250, 255, 1, 0, 0, 0, 251, 249, 1, 0, 0, 0, 252, 254, 5, 4, 0, 0, 253, 252,
+        1, 0, 0, 0, 254, 257, 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 255, 256, 1, 0, 0, 0, 256, 43, 1, 0, 0, 0,
+        257, 255, 1, 0, 0, 0, 258, 269, 3, 10, 5, 0, 259, 269, 3, 48, 24, 0, 260, 269, 3, 50, 25, 0, 261,
+        269, 3, 52, 26, 0, 262, 269, 3, 54, 27, 0, 263, 269, 3, 56, 28, 0, 264, 269, 3, 58, 29, 0, 265,
+        269, 3, 62, 31, 0, 266, 269, 3, 64, 32, 0, 267, 269, 3, 68, 34, 0, 268, 258, 1, 0, 0, 0, 268, 259,
+        1, 0, 0, 0, 268, 260, 1, 0, 0, 0, 268, 261, 1, 0, 0, 0, 268, 262, 1, 0, 0, 0, 268, 263, 1, 0, 0, 0,
+        268, 264, 1, 0, 0, 0, 268, 265, 1, 0, 0, 0, 268, 266, 1, 0, 0, 0, 268, 267, 1, 0, 0, 0, 269, 45,
+        1, 0, 0, 0, 270, 271, 5, 1, 0, 0, 271, 272, 3, 42, 21, 0, 272, 273, 5, 2, 0, 0, 273, 47, 1, 0, 0,
+        0, 274, 275, 5, 33, 0, 0, 275, 276, 3, 10, 5, 0, 276, 277, 5, 4, 0, 0, 277, 285, 3, 46, 23, 0, 278,
+        279, 5, 4, 0, 0, 279, 280, 5, 34, 0, 0, 280, 286, 3, 48, 24, 0, 281, 282, 5, 4, 0, 0, 282, 283,
+        5, 34, 0, 0, 283, 284, 5, 4, 0, 0, 284, 286, 3, 46, 23, 0, 285, 278, 1, 0, 0, 0, 285, 281, 1, 0,
+        0, 0, 285, 286, 1, 0, 0, 0, 286, 49, 1, 0, 0, 0, 287, 288, 5, 35, 0, 0, 288, 289, 3, 10, 5, 0, 289,
+        290, 5, 4, 0, 0, 290, 291, 3, 46, 23, 0, 291, 51, 1, 0, 0, 0, 292, 293, 5, 36, 0, 0, 293, 294, 5,
+        4, 0, 0, 294, 295, 3, 46, 23, 0, 295, 296, 5, 4, 0, 0, 296, 297, 5, 35, 0, 0, 297, 298, 3, 10, 5,
+        0, 298, 53, 1, 0, 0, 0, 299, 300, 5, 37, 0, 0, 300, 301, 5, 4, 0, 0, 301, 302, 3, 46, 23, 0, 302,
+        303, 5, 4, 0, 0, 303, 304, 5, 38, 0, 0, 304, 305, 3, 10, 5, 0, 305, 55, 1, 0, 0, 0, 306, 307, 5,
+        39, 0, 0, 307, 308, 5, 48, 0, 0, 308, 309, 5, 40, 0, 0, 309, 311, 3, 10, 5, 0, 310, 312, 5, 41,
+        0, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 313, 1, 0, 0, 0, 313, 314, 5, 42, 0, 0, 314,
+        315, 3, 10, 5, 0, 315, 316, 5, 4, 0, 0, 316, 317, 3, 46, 23, 0, 317, 57, 1, 0, 0, 0, 318, 319, 3,
+        60, 30, 0, 319, 320, 5, 43, 0, 0, 320, 321, 3, 10, 5, 0, 321, 59, 1, 0, 0, 0, 322, 323, 6, 30, -1,
+        0, 323, 324, 5, 48, 0, 0, 324, 339, 1, 0, 0, 0, 325, 326, 10, 1, 0, 0, 326, 327, 5, 9, 0, 0, 327,
+        332, 3, 10, 5, 0, 328, 329, 5, 6, 0, 0, 329, 331, 3, 10, 5, 0, 330, 328, 1, 0, 0, 0, 331, 334, 1,
+        0, 0, 0, 332, 330, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 335, 1, 0, 0, 0, 334, 332, 1, 0, 0, 0, 335,
+        336, 5, 10, 0, 0, 336, 338, 1, 0, 0, 0, 337, 325, 1, 0, 0, 0, 338, 341, 1, 0, 0, 0, 339, 337, 1,
+        0, 0, 0, 339, 340, 1, 0, 0, 0, 340, 61, 1, 0, 0, 0, 341, 339, 1, 0, 0, 0, 342, 343, 5, 44, 0, 0, 343,
+        344, 3, 60, 30, 0, 344, 63, 1, 0, 0, 0, 345, 346, 5, 45, 0, 0, 346, 347, 3, 10, 5, 0, 347, 65, 1,
+        0, 0, 0, 348, 349, 5, 46, 0, 0, 349, 350, 5, 48, 0, 0, 350, 359, 5, 7, 0, 0, 351, 356, 5, 48, 0,
+        0, 352, 353, 5, 6, 0, 0, 353, 355, 5, 48, 0, 0, 354, 352, 1, 0, 0, 0, 355, 358, 1, 0, 0, 0, 356,
+        354, 1, 0, 0, 0, 356, 357, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 359, 351, 1, 0,
+        0, 0, 359, 360, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 362, 5, 8, 0, 0, 362, 363, 5, 4, 0, 0, 363,
+        364, 3, 46, 23, 0, 364, 67, 1, 0, 0, 0, 365, 366, 5, 47, 0, 0, 366, 367, 3, 10, 5, 0, 367, 69, 1,
+        0, 0, 0, 33, 73, 77, 96, 104, 113, 122, 131, 140, 146, 154, 169, 181, 184, 187, 189, 197, 201,
+        209, 212, 217, 227, 230, 237, 244, 249, 255, 268, 285, 311, 332, 339, 356, 359];
+    static __ATN;
+    static get _ATN() {
+        if (!PSCParser.__ATN) {
+            PSCParser.__ATN = new ATNDeserializer().deserialize(PSCParser._serializedATN);
+        }
+        return PSCParser.__ATN;
+    }
+    static DecisionsToDFA = PSCParser._ATN.decisionToState.map((ds, index) => new DFA(ds, index));
+}
+export class ProgramContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    EOF() {
+        return this.getToken(PSCParser.EOF, 0);
+    }
+    subprogram_list() {
+        return this.getTypedRuleContexts(SubprogramContext);
+    }
+    subprogram(i) {
+        return this.getTypedRuleContext(SubprogramContext, i);
+    }
+    stmts() {
+        return this.getTypedRuleContext(StmtsContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_program;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitProgram) {
+            return visitor.visitProgram(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class AddOpContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    PLUS() {
+        return this.getToken(PSCParser.PLUS, 0);
+    }
+    MINUS() {
+        return this.getToken(PSCParser.MINUS, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_addOp;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAddOp) {
+            return visitor.visitAddOp(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class MulOpContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    MULTIPLY() {
+        return this.getToken(PSCParser.MULTIPLY, 0);
+    }
+    DIVIDE() {
+        return this.getToken(PSCParser.DIVIDE, 0);
+    }
+    MODULO() {
+        return this.getToken(PSCParser.MODULO, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_mulOp;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMulOp) {
+            return visitor.visitMulOp(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ExpOpContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    EXPONENT() {
+        return this.getToken(PSCParser.EXPONENT, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_expOp;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitExpOp) {
+            return visitor.visitExpOp(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class CompOpContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    EQUAL() {
+        return this.getToken(PSCParser.EQUAL, 0);
+    }
+    NEQUAL() {
+        return this.getToken(PSCParser.NEQUAL, 0);
+    }
+    GT() {
+        return this.getToken(PSCParser.GT, 0);
+    }
+    LT() {
+        return this.getToken(PSCParser.LT, 0);
+    }
+    GTEQ() {
+        return this.getToken(PSCParser.GTEQ, 0);
+    }
+    LTEQ() {
+        return this.getToken(PSCParser.LTEQ, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_compOp;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitCompOp) {
+            return visitor.visitCompOp(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    orExpr() {
+        return this.getTypedRuleContext(OrExprContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_expr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitExpr) {
+            return visitor.visitExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class OrExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    andExpr_list() {
+        return this.getTypedRuleContexts(AndExprContext);
+    }
+    andExpr(i) {
+        return this.getTypedRuleContext(AndExprContext, i);
+    }
+    OR_list() {
+        return this.getTokens(PSCParser.OR);
+    }
+    OR(i) {
+        return this.getToken(PSCParser.OR, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_orExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitOrExpr) {
+            return visitor.visitOrExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class AndExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    compExpr_list() {
+        return this.getTypedRuleContexts(CompExprContext);
+    }
+    compExpr(i) {
+        return this.getTypedRuleContext(CompExprContext, i);
+    }
+    AND_list() {
+        return this.getTokens(PSCParser.AND);
+    }
+    AND(i) {
+        return this.getToken(PSCParser.AND, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_andExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAndExpr) {
+            return visitor.visitAndExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class CompExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    addExpr_list() {
+        return this.getTypedRuleContexts(AddExprContext);
+    }
+    addExpr(i) {
+        return this.getTypedRuleContext(AddExprContext, i);
+    }
+    compOp_list() {
+        return this.getTypedRuleContexts(CompOpContext);
+    }
+    compOp(i) {
+        return this.getTypedRuleContext(CompOpContext, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_compExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitCompExpr) {
+            return visitor.visitCompExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class AddExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    mulExpr_list() {
+        return this.getTypedRuleContexts(MulExprContext);
+    }
+    mulExpr(i) {
+        return this.getTypedRuleContext(MulExprContext, i);
+    }
+    addOp_list() {
+        return this.getTypedRuleContexts(AddOpContext);
+    }
+    addOp(i) {
+        return this.getTypedRuleContext(AddOpContext, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_addExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAddExpr) {
+            return visitor.visitAddExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class MulExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    expExpr_list() {
+        return this.getTypedRuleContexts(ExpExprContext);
+    }
+    expExpr(i) {
+        return this.getTypedRuleContext(ExpExprContext, i);
+    }
+    mulOp_list() {
+        return this.getTypedRuleContexts(MulOpContext);
+    }
+    mulOp(i) {
+        return this.getTypedRuleContext(MulOpContext, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_mulExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitMulExpr) {
+            return visitor.visitMulExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ExpExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    unaryExpr_list() {
+        return this.getTypedRuleContexts(UnaryExprContext);
+    }
+    unaryExpr(i) {
+        return this.getTypedRuleContext(UnaryExprContext, i);
+    }
+    expOp_list() {
+        return this.getTypedRuleContexts(ExpOpContext);
+    }
+    expOp(i) {
+        return this.getTypedRuleContext(ExpOpContext, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_expExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitExpExpr) {
+            return visitor.visitExpExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class UnaryExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    notExpr() {
+        return this.getTypedRuleContext(NotExprContext, 0);
+    }
+    PLUS_list() {
+        return this.getTokens(PSCParser.PLUS);
+    }
+    PLUS(i) {
+        return this.getToken(PSCParser.PLUS, i);
+    }
+    MINUS_list() {
+        return this.getTokens(PSCParser.MINUS);
+    }
+    MINUS(i) {
+        return this.getToken(PSCParser.MINUS, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_unaryExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitUnaryExpr) {
+            return visitor.visitUnaryExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class NotExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    primaryExpr() {
+        return this.getTypedRuleContext(PrimaryExprContext, 0);
+    }
+    NOT_list() {
+        return this.getTokens(PSCParser.NOT);
+    }
+    NOT(i) {
+        return this.getToken(PSCParser.NOT, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_notExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitNotExpr) {
+            return visitor.visitNotExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class PrimaryExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    groupExpr() {
+        return this.getTypedRuleContext(GroupExprContext, 0);
+    }
+    primaryExpr() {
+        return this.getTypedRuleContext(PrimaryExprContext, 0);
+    }
+    LSQUARE() {
+        return this.getToken(PSCParser.LSQUARE, 0);
+    }
+    expr_list() {
+        return this.getTypedRuleContexts(ExprContext);
+    }
+    expr(i) {
+        return this.getTypedRuleContext(ExprContext, i);
+    }
+    RSQUARE() {
+        return this.getToken(PSCParser.RSQUARE, 0);
+    }
+    COMMA_list() {
+        return this.getTokens(PSCParser.COMMA);
+    }
+    COMMA(i) {
+        return this.getToken(PSCParser.COMMA, i);
+    }
+    LPAREN() {
+        return this.getToken(PSCParser.LPAREN, 0);
+    }
+    RPAREN() {
+        return this.getToken(PSCParser.RPAREN, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_primaryExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitPrimaryExpr) {
+            return visitor.visitPrimaryExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class GroupExprContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    atom() {
+        return this.getTypedRuleContext(AtomContext, 0);
+    }
+    LPAREN() {
+        return this.getToken(PSCParser.LPAREN, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    RPAREN() {
+        return this.getToken(PSCParser.RPAREN, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_groupExpr;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitGroupExpr) {
+            return visitor.visitGroupExpr(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class AtomContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    lits() {
+        return this.getTypedRuleContext(LitsContext, 0);
+    }
+    ID() {
+        return this.getToken(PSCParser.ID, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_atom;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAtom) {
+            return visitor.visitAtom(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class LitsContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    intLits() {
+        return this.getTypedRuleContext(IntLitsContext, 0);
+    }
+    floatLits() {
+        return this.getTypedRuleContext(FloatLitsContext, 0);
+    }
+    arrayLits() {
+        return this.getTypedRuleContext(ArrayLitsContext, 0);
+    }
+    STRING() {
+        return this.getToken(PSCParser.STRING, 0);
+    }
+    BOOLEAN() {
+        return this.getToken(PSCParser.BOOLEAN, 0);
+    }
+    NULL() {
+        return this.getToken(PSCParser.NULL, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_lits;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitLits) {
+            return visitor.visitLits(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class IntLitsContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    INTEGER() {
+        return this.getToken(PSCParser.INTEGER, 0);
+    }
+    MINUS() {
+        return this.getToken(PSCParser.MINUS, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_intLits;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIntLits) {
+            return visitor.visitIntLits(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class FloatLitsContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    FLOAT() {
+        return this.getToken(PSCParser.FLOAT, 0);
+    }
+    MINUS() {
+        return this.getToken(PSCParser.MINUS, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_floatLits;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitFloatLits) {
+            return visitor.visitFloatLits(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ArrayLitsContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    LSQUARE() {
+        return this.getToken(PSCParser.LSQUARE, 0);
+    }
+    RSQUARE() {
+        return this.getToken(PSCParser.RSQUARE, 0);
+    }
+    expr_list() {
+        return this.getTypedRuleContexts(ExprContext);
+    }
+    expr(i) {
+        return this.getTypedRuleContext(ExprContext, i);
+    }
+    COMMA_list() {
+        return this.getTokens(PSCParser.COMMA);
+    }
+    COMMA(i) {
+        return this.getToken(PSCParser.COMMA, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_arrayLits;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitArrayLits) {
+            return visitor.visitArrayLits(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class StmtsContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    stmt_list() {
+        return this.getTypedRuleContexts(StmtContext);
+    }
+    stmt(i) {
+        return this.getTypedRuleContext(StmtContext, i);
+    }
+    NEWLINE_list() {
+        return this.getTokens(PSCParser.NEWLINE);
+    }
+    NEWLINE(i) {
+        return this.getToken(PSCParser.NEWLINE, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_stmts;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitStmts) {
+            return visitor.visitStmts(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class StmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    ifStmt() {
+        return this.getTypedRuleContext(IfStmtContext, 0);
+    }
+    whileStmt() {
+        return this.getTypedRuleContext(WhileStmtContext, 0);
+    }
+    doWhileStmt() {
+        return this.getTypedRuleContext(DoWhileStmtContext, 0);
+    }
+    repeatUntilStmt() {
+        return this.getTypedRuleContext(RepeatUntilStmtContext, 0);
+    }
+    forStmt() {
+        return this.getTypedRuleContext(ForStmtContext, 0);
+    }
+    asmStmt() {
+        return this.getTypedRuleContext(AsmStmtContext, 0);
+    }
+    inputStmt() {
+        return this.getTypedRuleContext(InputStmtContext, 0);
+    }
+    outputStmt() {
+        return this.getTypedRuleContext(OutputStmtContext, 0);
+    }
+    returnStmt() {
+        return this.getTypedRuleContext(ReturnStmtContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_stmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitStmt) {
+            return visitor.visitStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class BlockContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    INDENT() {
+        return this.getToken(PSCParser.INDENT, 0);
+    }
+    stmts() {
+        return this.getTypedRuleContext(StmtsContext, 0);
+    }
+    DEDENT() {
+        return this.getToken(PSCParser.DEDENT, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_block;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitBlock) {
+            return visitor.visitBlock(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class IfStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    IF() {
+        return this.getToken(PSCParser.IF, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    NEWLINE_list() {
+        return this.getTokens(PSCParser.NEWLINE);
+    }
+    NEWLINE(i) {
+        return this.getToken(PSCParser.NEWLINE, i);
+    }
+    block_list() {
+        return this.getTypedRuleContexts(BlockContext);
+    }
+    block(i) {
+        return this.getTypedRuleContext(BlockContext, i);
+    }
+    ELSE() {
+        return this.getToken(PSCParser.ELSE, 0);
+    }
+    ifStmt() {
+        return this.getTypedRuleContext(IfStmtContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_ifStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitIfStmt) {
+            return visitor.visitIfStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class WhileStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    WHILE() {
+        return this.getToken(PSCParser.WHILE, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    NEWLINE() {
+        return this.getToken(PSCParser.NEWLINE, 0);
+    }
+    block() {
+        return this.getTypedRuleContext(BlockContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_whileStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitWhileStmt) {
+            return visitor.visitWhileStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class DoWhileStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    DO() {
+        return this.getToken(PSCParser.DO, 0);
+    }
+    NEWLINE_list() {
+        return this.getTokens(PSCParser.NEWLINE);
+    }
+    NEWLINE(i) {
+        return this.getToken(PSCParser.NEWLINE, i);
+    }
+    block() {
+        return this.getTypedRuleContext(BlockContext, 0);
+    }
+    WHILE() {
+        return this.getToken(PSCParser.WHILE, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_doWhileStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitDoWhileStmt) {
+            return visitor.visitDoWhileStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class RepeatUntilStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    REPEAT() {
+        return this.getToken(PSCParser.REPEAT, 0);
+    }
+    NEWLINE_list() {
+        return this.getTokens(PSCParser.NEWLINE);
+    }
+    NEWLINE(i) {
+        return this.getToken(PSCParser.NEWLINE, i);
+    }
+    block() {
+        return this.getTypedRuleContext(BlockContext, 0);
+    }
+    UNTIL() {
+        return this.getToken(PSCParser.UNTIL, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_repeatUntilStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitRepeatUntilStmt) {
+            return visitor.visitRepeatUntilStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ForStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    FOR() {
+        return this.getToken(PSCParser.FOR, 0);
+    }
+    ID() {
+        return this.getToken(PSCParser.ID, 0);
+    }
+    FROM() {
+        return this.getToken(PSCParser.FROM, 0);
+    }
+    expr_list() {
+        return this.getTypedRuleContexts(ExprContext);
+    }
+    expr(i) {
+        return this.getTypedRuleContext(ExprContext, i);
+    }
+    TO() {
+        return this.getToken(PSCParser.TO, 0);
+    }
+    NEWLINE() {
+        return this.getToken(PSCParser.NEWLINE, 0);
+    }
+    block() {
+        return this.getTypedRuleContext(BlockContext, 0);
+    }
+    DOWN() {
+        return this.getToken(PSCParser.DOWN, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_forStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitForStmt) {
+            return visitor.visitForStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class AsmStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    lvalue() {
+        return this.getTypedRuleContext(LvalueContext, 0);
+    }
+    ASSIGN() {
+        return this.getToken(PSCParser.ASSIGN, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_asmStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitAsmStmt) {
+            return visitor.visitAsmStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class LvalueContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    ID() {
+        return this.getToken(PSCParser.ID, 0);
+    }
+    lvalue() {
+        return this.getTypedRuleContext(LvalueContext, 0);
+    }
+    LSQUARE() {
+        return this.getToken(PSCParser.LSQUARE, 0);
+    }
+    expr_list() {
+        return this.getTypedRuleContexts(ExprContext);
+    }
+    expr(i) {
+        return this.getTypedRuleContext(ExprContext, i);
+    }
+    RSQUARE() {
+        return this.getToken(PSCParser.RSQUARE, 0);
+    }
+    COMMA_list() {
+        return this.getTokens(PSCParser.COMMA);
+    }
+    COMMA(i) {
+        return this.getToken(PSCParser.COMMA, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_lvalue;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitLvalue) {
+            return visitor.visitLvalue(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class InputStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    INPUT() {
+        return this.getToken(PSCParser.INPUT, 0);
+    }
+    lvalue() {
+        return this.getTypedRuleContext(LvalueContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_inputStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitInputStmt) {
+            return visitor.visitInputStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class OutputStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    OUTPUT() {
+        return this.getToken(PSCParser.OUTPUT, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_outputStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitOutputStmt) {
+            return visitor.visitOutputStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class SubprogramContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    SUBPROGRAM() {
+        return this.getToken(PSCParser.SUBPROGRAM, 0);
+    }
+    ID_list() {
+        return this.getTokens(PSCParser.ID);
+    }
+    ID(i) {
+        return this.getToken(PSCParser.ID, i);
+    }
+    LPAREN() {
+        return this.getToken(PSCParser.LPAREN, 0);
+    }
+    RPAREN() {
+        return this.getToken(PSCParser.RPAREN, 0);
+    }
+    NEWLINE() {
+        return this.getToken(PSCParser.NEWLINE, 0);
+    }
+    block() {
+        return this.getTypedRuleContext(BlockContext, 0);
+    }
+    COMMA_list() {
+        return this.getTokens(PSCParser.COMMA);
+    }
+    COMMA(i) {
+        return this.getToken(PSCParser.COMMA, i);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_subprogram;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitSubprogram) {
+            return visitor.visitSubprogram(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+export class ReturnStmtContext extends ParserRuleContext {
+    constructor(parser, parent, invokingState) {
+        super(parent, invokingState);
+        this.parser = parser;
+    }
+    RETURN() {
+        return this.getToken(PSCParser.RETURN, 0);
+    }
+    expr() {
+        return this.getTypedRuleContext(ExprContext, 0);
+    }
+    get ruleIndex() {
+        return PSCParser.RULE_returnStmt;
+    }
+    // @Override
+    accept(visitor) {
+        if (visitor.visitReturnStmt) {
+            return visitor.visitReturnStmt(this);
+        }
+        else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+//# sourceMappingURL=PSCParser.js.map