circuitscript 0.0.22 → 0.0.25

package/build/src/antlr/CircuitScriptParser.js

@@ -1,4841 +0,0 @@
-import { ATN, ATNDeserializer, DFA, FailedPredicateException, RecognitionException, NoViableAltException, Parser, ParserATNSimulator, ParserRuleContext, PredictionContextCache, Token } from 'antlr4';
-export default class CircuitScriptParser extends Parser {
-    static T__0 = 1;
-    static T__1 = 2;
-    static T__2 = 3;
-    static T__3 = 4;
-    static T__4 = 5;
-    static T__5 = 6;
-    static T__6 = 7;
-    static T__7 = 8;
-    static Break = 9;
-    static Branch = 10;
-    static Create = 11;
-    static Component = 12;
-    static Graphic = 13;
-    static Wire = 14;
-    static Pin = 15;
-    static Add = 16;
-    static At = 17;
-    static To = 18;
-    static Point = 19;
-    static Join = 20;
-    static Parallel = 21;
-    static Return = 22;
-    static Define = 23;
-    static Import = 24;
-    static If = 25;
-    static Not = 26;
-    static Equals = 27;
-    static NotEquals = 28;
-    static Addition = 29;
-    static Minus = 30;
-    static Divide = 31;
-    static Multiply = 32;
-    static OPEN_PAREN = 33;
-    static CLOSE_PAREN = 34;
-    static NOT_CONNECTED = 35;
-    static BOOLEAN_VALUE = 36;
-    static ID = 37;
-    static INTEGER_VALUE = 38;
-    static DECIMAL_VALUE = 39;
-    static NUMERIC_VALUE = 40;
-    static STRING_VALUE = 41;
-    static PERCENTAGE_VALUE = 42;
-    static ALPHA_NUMERIC = 43;
-    static WS = 44;
-    static NEWLINE = 45;
-    static SKIP_ = 46;
-    static INDENT = 47;
-    static DEDENT = 48;
-    static EOF = Token.EOF;
-    static RULE_script = 0;
-    static RULE_expression = 1;
-    static RULE_path_blocks = 2;
-    static RULE_path_block_inner = 3;
-    static RULE_property_set_expr2 = 4;
-    static RULE_assignment_expr2 = 5;
-    static RULE_data_expr_with_assignment = 6;
-    static RULE_add_component_expr = 7;
-    static RULE_component_select_expr = 8;
-    static RULE_pin_select_expr = 9;
-    static RULE_pin_select_expr2 = 10;
-    static RULE_at_component_expr = 11;
-    static RULE_to_component_expr = 12;
-    static RULE_at_to_multiple_expr = 13;
-    static RULE_at_to_multiple_line_expr = 14;
-    static RULE_at_to_multiple_line_expr_to_pin = 15;
-    static RULE_at_block = 16;
-    static RULE_at_block_expressions = 17;
-    static RULE_at_block_pin_expr = 18;
-    static RULE_at_block_pin_expression_simple = 19;
-    static RULE_at_block_pin_expression_complex = 20;
-    static RULE_break_keyword = 21;
-    static RULE_assignment_expr = 22;
-    static RULE_keyword_assignment_expr = 23;
-    static RULE_parameters = 24;
-    static RULE_property_set_expr = 25;
-    static RULE_double_dot_property_set_expr = 26;
-    static RULE_data_expr = 27;
-    static RULE_binary_operator = 28;
-    static RULE_unary_operator = 29;
-    static RULE_value_expr = 30;
-    static RULE_function_def_expr = 31;
-    static RULE_function_expr = 32;
-    static RULE_function_args_expr = 33;
-    static RULE_atom_expr = 34;
-    static RULE_trailer_expr = 35;
-    static RULE_net_namespace_expr = 36;
-    static RULE_function_return_expr = 37;
-    static RULE_create_component_expr = 38;
-    static RULE_create_graphic_expr = 39;
-    static RULE_sub_expr = 40;
-    static RULE_property_expr = 41;
-    static RULE_property_key_expr = 42;
-    static RULE_property_value_expr = 43;
-    static RULE_blank_expr = 44;
-    static RULE_wire_expr = 45;
-    static RULE_point_expr = 46;
-    static RULE_import_expr = 47;
-    static RULE_frame_expr = 48;
-    static literalNames = [null, "':'",
-        "','", "'='",
-        "'..'", "'.'",
-        "'['", "']'",
-        "'frame'", "'break'",
-        "'branch'",
-        "'create'",
-        "'component'",
-        "'graphic'",
-        "'wire'", "'pin'",
-        "'add'", "'at'",
-        "'to'", "'point'",
-        "'join'", "'parallel'",
-        "'return'",
-        "'def'", "'import'",
-        "'if'", "'!'",
-        "'=='", "'!='",
-        "'+'", "'-'",
-        "'/'", "'*'",
-        "'('", "')'"];
-    static symbolicNames = [null, null,
-        null, null,
-        null, null,
-        null, null,
-        null, "Break",
-        "Branch", "Create",
-        "Component",
-        "Graphic",
-        "Wire", "Pin",
-        "Add", "At",
-        "To", "Point",
-        "Join", "Parallel",
-        "Return", "Define",
-        "Import", "If",
-        "Not", "Equals",
-        "NotEquals",
-        "Addition",
-        "Minus", "Divide",
-        "Multiply",
-        "OPEN_PAREN",
-        "CLOSE_PAREN",
-        "NOT_CONNECTED",
-        "BOOLEAN_VALUE",
-        "ID", "INTEGER_VALUE",
-        "DECIMAL_VALUE",
-        "NUMERIC_VALUE",
-        "STRING_VALUE",
-        "PERCENTAGE_VALUE",
-        "ALPHA_NUMERIC",
-        "WS", "NEWLINE",
-        "SKIP_", "INDENT",
-        "DEDENT"];
-    static ruleNames = [
-        "script", "expression", "path_blocks", "path_block_inner", "property_set_expr2",
-        "assignment_expr2", "data_expr_with_assignment", "add_component_expr",
-        "component_select_expr", "pin_select_expr", "pin_select_expr2", "at_component_expr",
-        "to_component_expr", "at_to_multiple_expr", "at_to_multiple_line_expr",
-        "at_to_multiple_line_expr_to_pin", "at_block", "at_block_expressions",
-        "at_block_pin_expr", "at_block_pin_expression_simple", "at_block_pin_expression_complex",
-        "break_keyword", "assignment_expr", "keyword_assignment_expr", "parameters",
-        "property_set_expr", "double_dot_property_set_expr", "data_expr", "binary_operator",
-        "unary_operator", "value_expr", "function_def_expr", "function_expr",
-        "function_args_expr", "atom_expr", "trailer_expr", "net_namespace_expr",
-        "function_return_expr", "create_component_expr", "create_graphic_expr",
-        "sub_expr", "property_expr", "property_key_expr", "property_value_expr",
-        "blank_expr", "wire_expr", "point_expr", "import_expr", "frame_expr",
-    ];
-    get grammarFileName() { return "CircuitScript.g4"; }
-    get literalNames() { return CircuitScriptParser.literalNames; }
-    get symbolicNames() { return CircuitScriptParser.symbolicNames; }
-    get ruleNames() { return CircuitScriptParser.ruleNames; }
-    get serializedATN() { return CircuitScriptParser._serializedATN; }
-    createFailedPredicateException(predicate, message) {
-        return new FailedPredicateException(this, predicate, message);
-    }
-    constructor(input) {
-        super(input);
-        this._interp = new ParserATNSimulator(this, CircuitScriptParser._ATN, CircuitScriptParser.DecisionsToDFA, new PredictionContextCache());
-    }
-    script() {
-        let localctx = new ScriptContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 0, CircuitScriptParser.RULE_script);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 100;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 100;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 4:
-                            case 8:
-                            case 9:
-                            case 10:
-                            case 14:
-                            case 16:
-                            case 17:
-                            case 18:
-                            case 19:
-                            case 20:
-                            case 21:
-                            case 23:
-                            case 24:
-                            case 29:
-                            case 31:
-                            case 37:
-                                {
-                                    this.state = 98;
-                                    this.expression();
-                                }
-                                break;
-                            case 45:
-                                {
-                                    this.state = 99;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 102;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2713667344) !== 0) || _la === 37 || _la === 45);
-                this.state = 104;
-                this.match(CircuitScriptParser.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;
-    }
-    expression() {
-        let localctx = new ExpressionContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 2, CircuitScriptParser.RULE_expression);
-        try {
-            this.state = 122;
-            this._errHandler.sync(this);
-            switch (this._interp.adaptivePredict(this._input, 2, this._ctx)) {
-                case 1:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 106;
-                        this.add_component_expr();
-                    }
-                    break;
-                case 2:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 107;
-                        this.to_component_expr();
-                    }
-                    break;
-                case 3:
-                    this.enterOuterAlt(localctx, 3);
-                    {
-                        this.state = 108;
-                        this.at_component_expr();
-                    }
-                    break;
-                case 4:
-                    this.enterOuterAlt(localctx, 4);
-                    {
-                        this.state = 109;
-                        this.assignment_expr();
-                    }
-                    break;
-                case 5:
-                    this.enterOuterAlt(localctx, 5);
-                    {
-                        this.state = 110;
-                        this.property_set_expr();
-                    }
-                    break;
-                case 6:
-                    this.enterOuterAlt(localctx, 6);
-                    {
-                        this.state = 111;
-                        this.property_set_expr2();
-                    }
-                    break;
-                case 7:
-                    this.enterOuterAlt(localctx, 7);
-                    {
-                        this.state = 112;
-                        this.double_dot_property_set_expr();
-                    }
-                    break;
-                case 8:
-                    this.enterOuterAlt(localctx, 8);
-                    {
-                        this.state = 113;
-                        this.break_keyword();
-                    }
-                    break;
-                case 9:
-                    this.enterOuterAlt(localctx, 9);
-                    {
-                        this.state = 114;
-                        this.function_def_expr();
-                    }
-                    break;
-                case 10:
-                    this.enterOuterAlt(localctx, 10);
-                    {
-                        this.state = 115;
-                        this.wire_expr();
-                    }
-                    break;
-                case 11:
-                    this.enterOuterAlt(localctx, 11);
-                    {
-                        this.state = 116;
-                        this.import_expr();
-                    }
-                    break;
-                case 12:
-                    this.enterOuterAlt(localctx, 12);
-                    {
-                        this.state = 117;
-                        this.frame_expr();
-                    }
-                    break;
-                case 13:
-                    this.enterOuterAlt(localctx, 13);
-                    {
-                        this.state = 118;
-                        this.atom_expr();
-                    }
-                    break;
-                case 14:
-                    this.enterOuterAlt(localctx, 14);
-                    {
-                        this.state = 119;
-                        this.at_block();
-                    }
-                    break;
-                case 15:
-                    this.enterOuterAlt(localctx, 15);
-                    {
-                        this.state = 120;
-                        this.path_blocks();
-                    }
-                    break;
-                case 16:
-                    this.enterOuterAlt(localctx, 16);
-                    {
-                        this.state = 121;
-                        this.point_expr();
-                    }
-                    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;
-    }
-    path_blocks() {
-        let localctx = new Path_blocksContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 4, CircuitScriptParser.RULE_path_blocks);
-        try {
-            let _alt;
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 125;
-                this._errHandler.sync(this);
-                _alt = 1;
-                do {
-                    switch (_alt) {
-                        case 1:
-                            {
-                                {
-                                    this.state = 124;
-                                    this.path_block_inner();
-                                }
-                            }
-                            break;
-                        default:
-                            throw new NoViableAltException(this);
-                    }
-                    this.state = 127;
-                    this._errHandler.sync(this);
-                    _alt = this._interp.adaptivePredict(this._input, 3, this._ctx);
-                } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
-            }
-        }
-        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;
-    }
-    path_block_inner() {
-        let localctx = new Path_block_innerContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 6, CircuitScriptParser.RULE_path_block_inner);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 129;
-                _la = this._input.LA(1);
-                if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & 3671040) !== 0))) {
-                    this._errHandler.recoverInline(this);
-                }
-                else {
-                    this._errHandler.reportMatch(this);
-                    this.consume();
-                }
-                this.state = 130;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 131;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 132;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 135;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 135;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 133;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 4:
-                            case 8:
-                            case 9:
-                            case 10:
-                            case 14:
-                            case 16:
-                            case 17:
-                            case 18:
-                            case 19:
-                            case 20:
-                            case 21:
-                            case 23:
-                            case 24:
-                            case 29:
-                            case 31:
-                            case 37:
-                                {
-                                    this.state = 134;
-                                    this.expression();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 137;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2713667344) !== 0) || _la === 37 || _la === 45);
-                this.state = 139;
-                this.match(CircuitScriptParser.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;
-    }
-    property_set_expr2() {
-        let localctx = new Property_set_expr2Context(this, this._ctx, this.state);
-        this.enterRule(localctx, 8, CircuitScriptParser.RULE_property_set_expr2);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 141;
-                this.atom_expr();
-                this.state = 142;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 143;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 144;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 147;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 147;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 145;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 37:
-                            case 38:
-                                {
-                                    this.state = 146;
-                                    this.assignment_expr2();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 149;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while (((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 259) !== 0));
-                this.state = 151;
-                this.match(CircuitScriptParser.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;
-    }
-    assignment_expr2() {
-        let localctx = new Assignment_expr2Context(this, this._ctx, this.state);
-        this.enterRule(localctx, 10, CircuitScriptParser.RULE_assignment_expr2);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 153;
-                _la = this._input.LA(1);
-                if (!(_la === 37 || _la === 38)) {
-                    this._errHandler.recoverInline(this);
-                }
-                else {
-                    this._errHandler.reportMatch(this);
-                    this.consume();
-                }
-                this.state = 154;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 155;
-                this.value_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;
-    }
-    data_expr_with_assignment() {
-        let localctx = new Data_expr_with_assignmentContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 12, CircuitScriptParser.RULE_data_expr_with_assignment);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 159;
-                this._errHandler.sync(this);
-                switch (this._interp.adaptivePredict(this._input, 8, this._ctx)) {
-                    case 1:
-                        {
-                            this.state = 157;
-                            this.data_expr(0);
-                        }
-                        break;
-                    case 2:
-                        {
-                            this.state = 158;
-                            this.assignment_expr();
-                        }
-                        break;
-                }
-                this.state = 162;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                if (_la === 15) {
-                    {
-                        this.state = 161;
-                        this.pin_select_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;
-    }
-    add_component_expr() {
-        let localctx = new Add_component_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 14, CircuitScriptParser.RULE_add_component_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 164;
-                this.match(CircuitScriptParser.Add);
-                this.state = 165;
-                this.data_expr_with_assignment();
-                this.state = 167;
-                this._errHandler.sync(this);
-                switch (this._interp.adaptivePredict(this._input, 10, this._ctx)) {
-                    case 1:
-                        {
-                            this.state = 166;
-                            this.match(CircuitScriptParser.ID);
-                        }
-                        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;
-    }
-    component_select_expr() {
-        let localctx = new Component_select_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 16, CircuitScriptParser.RULE_component_select_expr);
-        try {
-            this.state = 171;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 6:
-                case 11:
-                case 26:
-                case 29:
-                case 30:
-                case 31:
-                case 33:
-                case 36:
-                case 37:
-                case 38:
-                case 39:
-                case 40:
-                case 41:
-                case 42:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 169;
-                        this.data_expr_with_assignment();
-                    }
-                    break;
-                case 15:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 170;
-                        this.pin_select_expr();
-                    }
-                    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;
-    }
-    pin_select_expr() {
-        let localctx = new Pin_select_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 18, CircuitScriptParser.RULE_pin_select_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 173;
-                this.match(CircuitScriptParser.Pin);
-                this.state = 174;
-                _la = this._input.LA(1);
-                if (!(_la === 38 || _la === 41)) {
-                    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;
-    }
-    pin_select_expr2() {
-        let localctx = new Pin_select_expr2Context(this, this._ctx, this.state);
-        this.enterRule(localctx, 20, CircuitScriptParser.RULE_pin_select_expr2);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 176;
-                _la = this._input.LA(1);
-                if (!(_la === 38 || _la === 41)) {
-                    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;
-    }
-    at_component_expr() {
-        let localctx = new At_component_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 22, CircuitScriptParser.RULE_at_component_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 178;
-                this.match(CircuitScriptParser.At);
-                this.state = 184;
-                this._errHandler.sync(this);
-                switch (this._input.LA(1)) {
-                    case 6:
-                    case 11:
-                    case 15:
-                    case 26:
-                    case 29:
-                    case 30:
-                    case 31:
-                    case 33:
-                    case 36:
-                    case 37:
-                    case 38:
-                    case 39:
-                    case 40:
-                    case 41:
-                    case 42:
-                        {
-                            {
-                                this.state = 179;
-                                this.component_select_expr();
-                                this.state = 181;
-                                this._errHandler.sync(this);
-                                switch (this._interp.adaptivePredict(this._input, 12, this._ctx)) {
-                                    case 1:
-                                        {
-                                            this.state = 180;
-                                            this.match(CircuitScriptParser.ID);
-                                        }
-                                        break;
-                                }
-                            }
-                        }
-                        break;
-                    case 19:
-                        {
-                            this.state = 183;
-                            this.match(CircuitScriptParser.Point);
-                        }
-                        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;
-    }
-    to_component_expr() {
-        let localctx = new To_component_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 24, CircuitScriptParser.RULE_to_component_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 186;
-                this.match(CircuitScriptParser.To);
-                this.state = 199;
-                this._errHandler.sync(this);
-                switch (this._input.LA(1)) {
-                    case 6:
-                    case 11:
-                    case 15:
-                    case 26:
-                    case 29:
-                    case 30:
-                    case 31:
-                    case 33:
-                    case 36:
-                    case 37:
-                    case 38:
-                    case 39:
-                    case 40:
-                    case 41:
-                    case 42:
-                        {
-                            {
-                                this.state = 187;
-                                this.component_select_expr();
-                                this.state = 192;
-                                this._errHandler.sync(this);
-                                _la = this._input.LA(1);
-                                while (_la === 2) {
-                                    {
-                                        {
-                                            this.state = 188;
-                                            this.match(CircuitScriptParser.T__1);
-                                            this.state = 189;
-                                            this.component_select_expr();
-                                        }
-                                    }
-                                    this.state = 194;
-                                    this._errHandler.sync(this);
-                                    _la = this._input.LA(1);
-                                }
-                                this.state = 196;
-                                this._errHandler.sync(this);
-                                switch (this._interp.adaptivePredict(this._input, 15, this._ctx)) {
-                                    case 1:
-                                        {
-                                            this.state = 195;
-                                            this.match(CircuitScriptParser.ID);
-                                        }
-                                        break;
-                                }
-                            }
-                        }
-                        break;
-                    case 19:
-                        {
-                            this.state = 198;
-                            this.match(CircuitScriptParser.Point);
-                        }
-                        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;
-    }
-    at_to_multiple_expr() {
-        let localctx = new At_to_multiple_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 26, CircuitScriptParser.RULE_at_to_multiple_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 201;
-                this.match(CircuitScriptParser.At);
-                this.state = 202;
-                this.component_select_expr();
-                this.state = 203;
-                this.match(CircuitScriptParser.To);
-                this.state = 204;
-                this.component_select_expr();
-                this.state = 209;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                while (_la === 2) {
-                    {
-                        {
-                            this.state = 205;
-                            this.match(CircuitScriptParser.T__1);
-                            this.state = 206;
-                            this.component_select_expr();
-                        }
-                    }
-                    this.state = 211;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                }
-                this.state = 212;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 213;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 214;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 217;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 217;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 215;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 38:
-                            case 41:
-                                {
-                                    this.state = 216;
-                                    this.at_to_multiple_line_expr();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 219;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while (((((_la - 38)) & ~0x1F) === 0 && ((1 << (_la - 38)) & 137) !== 0));
-                this.state = 221;
-                this.match(CircuitScriptParser.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;
-    }
-    at_to_multiple_line_expr() {
-        let localctx = new At_to_multiple_line_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 28, CircuitScriptParser.RULE_at_to_multiple_line_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 223;
-                this.pin_select_expr2();
-                this.state = 224;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 225;
-                this.at_to_multiple_line_expr_to_pin();
-                this.state = 230;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                while (_la === 2) {
-                    {
-                        {
-                            this.state = 226;
-                            this.match(CircuitScriptParser.T__1);
-                            this.state = 227;
-                            this.at_to_multiple_line_expr_to_pin();
-                        }
-                    }
-                    this.state = 232;
-                    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;
-    }
-    at_to_multiple_line_expr_to_pin() {
-        let localctx = new At_to_multiple_line_expr_to_pinContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 30, CircuitScriptParser.RULE_at_to_multiple_line_expr_to_pin);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 233;
-                _la = this._input.LA(1);
-                if (!(_la === 35 || _la === 38)) {
-                    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;
-    }
-    at_block() {
-        let localctx = new At_blockContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 32, CircuitScriptParser.RULE_at_block);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 235;
-                this.at_component_expr();
-                this.state = 236;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 237;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 238;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 241;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 241;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 239;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 4:
-                            case 8:
-                            case 9:
-                            case 10:
-                            case 14:
-                            case 16:
-                            case 17:
-                            case 18:
-                            case 19:
-                            case 20:
-                            case 21:
-                            case 23:
-                            case 24:
-                            case 29:
-                            case 31:
-                            case 37:
-                            case 38:
-                            case 41:
-                                {
-                                    this.state = 240;
-                                    this.at_block_expressions();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 243;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2713667344) !== 0) || ((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 275) !== 0));
-                this.state = 245;
-                this.match(CircuitScriptParser.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;
-    }
-    at_block_expressions() {
-        let localctx = new At_block_expressionsContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 34, CircuitScriptParser.RULE_at_block_expressions);
-        try {
-            this.state = 249;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 4:
-                case 8:
-                case 9:
-                case 10:
-                case 14:
-                case 16:
-                case 17:
-                case 18:
-                case 19:
-                case 20:
-                case 21:
-                case 23:
-                case 24:
-                case 29:
-                case 31:
-                case 37:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 247;
-                        this.expression();
-                    }
-                    break;
-                case 38:
-                case 41:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 248;
-                        this.at_block_pin_expr();
-                    }
-                    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;
-    }
-    at_block_pin_expr() {
-        let localctx = new At_block_pin_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 36, CircuitScriptParser.RULE_at_block_pin_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 251;
-                this.pin_select_expr2();
-                this.state = 252;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 255;
-                this._errHandler.sync(this);
-                switch (this._input.LA(1)) {
-                    case 4:
-                    case 8:
-                    case 9:
-                    case 10:
-                    case 14:
-                    case 16:
-                    case 17:
-                    case 18:
-                    case 19:
-                    case 20:
-                    case 21:
-                    case 23:
-                    case 24:
-                    case 29:
-                    case 31:
-                    case 35:
-                    case 37:
-                        {
-                            this.state = 253;
-                            this.at_block_pin_expression_simple();
-                        }
-                        break;
-                    case 45:
-                        {
-                            this.state = 254;
-                            this.at_block_pin_expression_complex();
-                        }
-                        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;
-    }
-    at_block_pin_expression_simple() {
-        let localctx = new At_block_pin_expression_simpleContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 38, CircuitScriptParser.RULE_at_block_pin_expression_simple);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 259;
-                this._errHandler.sync(this);
-                switch (this._input.LA(1)) {
-                    case 4:
-                    case 8:
-                    case 9:
-                    case 10:
-                    case 14:
-                    case 16:
-                    case 17:
-                    case 18:
-                    case 19:
-                    case 20:
-                    case 21:
-                    case 23:
-                    case 24:
-                    case 29:
-                    case 31:
-                    case 37:
-                        {
-                            this.state = 257;
-                            this.expression();
-                        }
-                        break;
-                    case 35:
-                        {
-                            this.state = 258;
-                            this.match(CircuitScriptParser.NOT_CONNECTED);
-                        }
-                        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;
-    }
-    at_block_pin_expression_complex() {
-        let localctx = new At_block_pin_expression_complexContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 40, CircuitScriptParser.RULE_at_block_pin_expression_complex);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 261;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 262;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 265;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 265;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 263;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 4:
-                            case 8:
-                            case 9:
-                            case 10:
-                            case 14:
-                            case 16:
-                            case 17:
-                            case 18:
-                            case 19:
-                            case 20:
-                            case 21:
-                            case 23:
-                            case 24:
-                            case 29:
-                            case 31:
-                            case 37:
-                                {
-                                    this.state = 264;
-                                    this.expression();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 267;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2713667344) !== 0) || _la === 37 || _la === 45);
-                this.state = 269;
-                this.match(CircuitScriptParser.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;
-    }
-    break_keyword() {
-        let localctx = new Break_keywordContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 42, CircuitScriptParser.RULE_break_keyword);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 271;
-                this.match(CircuitScriptParser.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;
-    }
-    assignment_expr() {
-        let localctx = new Assignment_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 44, CircuitScriptParser.RULE_assignment_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 273;
-                this.atom_expr();
-                this.state = 274;
-                this.match(CircuitScriptParser.T__2);
-                this.state = 275;
-                this.data_expr(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;
-    }
-    keyword_assignment_expr() {
-        let localctx = new Keyword_assignment_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 46, CircuitScriptParser.RULE_keyword_assignment_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 277;
-                this.match(CircuitScriptParser.ID);
-                this.state = 278;
-                this.match(CircuitScriptParser.T__2);
-                this.state = 279;
-                this.data_expr(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;
-    }
-    parameters() {
-        let localctx = new ParametersContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 48, CircuitScriptParser.RULE_parameters);
-        let _la;
-        try {
-            let _alt;
-            this.state = 304;
-            this._errHandler.sync(this);
-            switch (this._interp.adaptivePredict(this._input, 31, this._ctx)) {
-                case 1:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        {
-                            this.state = 281;
-                            this.data_expr(0);
-                            this.state = 286;
-                            this._errHandler.sync(this);
-                            _alt = this._interp.adaptivePredict(this._input, 28, this._ctx);
-                            while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
-                                if (_alt === 1) {
-                                    {
-                                        {
-                                            this.state = 282;
-                                            this.match(CircuitScriptParser.T__1);
-                                            this.state = 283;
-                                            this.data_expr(0);
-                                        }
-                                    }
-                                }
-                                this.state = 288;
-                                this._errHandler.sync(this);
-                                _alt = this._interp.adaptivePredict(this._input, 28, this._ctx);
-                            }
-                            this.state = 293;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                            while (_la === 2) {
-                                {
-                                    {
-                                        this.state = 289;
-                                        this.match(CircuitScriptParser.T__1);
-                                        this.state = 290;
-                                        this.keyword_assignment_expr();
-                                    }
-                                }
-                                this.state = 295;
-                                this._errHandler.sync(this);
-                                _la = this._input.LA(1);
-                            }
-                        }
-                    }
-                    break;
-                case 2:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        {
-                            this.state = 296;
-                            this.keyword_assignment_expr();
-                            this.state = 301;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                            while (_la === 2) {
-                                {
-                                    {
-                                        this.state = 297;
-                                        this.match(CircuitScriptParser.T__1);
-                                        this.state = 298;
-                                        this.keyword_assignment_expr();
-                                    }
-                                }
-                                this.state = 303;
-                                this._errHandler.sync(this);
-                                _la = this._input.LA(1);
-                            }
-                        }
-                    }
-                    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;
-    }
-    property_set_expr() {
-        let localctx = new Property_set_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 50, CircuitScriptParser.RULE_property_set_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 306;
-                this.atom_expr();
-                this.state = 307;
-                this.match(CircuitScriptParser.T__2);
-                this.state = 308;
-                this.data_expr(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;
-    }
-    double_dot_property_set_expr() {
-        let localctx = new Double_dot_property_set_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 52, CircuitScriptParser.RULE_double_dot_property_set_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 310;
-                this.match(CircuitScriptParser.T__3);
-                this.state = 311;
-                this.match(CircuitScriptParser.ID);
-                this.state = 312;
-                this.match(CircuitScriptParser.T__2);
-                this.state = 313;
-                this.data_expr(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;
-    }
-    data_expr(_p) {
-        if (_p === undefined) {
-            _p = 0;
-        }
-        let _parentctx = this._ctx;
-        let _parentState = this.state;
-        let localctx = new Data_exprContext(this, this._ctx, _parentState);
-        let _prevctx = localctx;
-        let _startState = 54;
-        this.enterRecursionRule(localctx, 54, CircuitScriptParser.RULE_data_expr, _p);
-        let _la;
-        try {
-            let _alt;
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 329;
-                this._errHandler.sync(this);
-                switch (this._interp.adaptivePredict(this._input, 33, this._ctx)) {
-                    case 1:
-                        {
-                            localctx = new RoundedBracketsExprContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 316;
-                            this.match(CircuitScriptParser.OPEN_PAREN);
-                            this.state = 317;
-                            this.data_expr(0);
-                            this.state = 318;
-                            this.match(CircuitScriptParser.CLOSE_PAREN);
-                        }
-                        break;
-                    case 2:
-                        {
-                            localctx = new ValueAtomExprContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 322;
-                            this._errHandler.sync(this);
-                            switch (this._input.LA(1)) {
-                                case 6:
-                                case 30:
-                                case 36:
-                                case 38:
-                                case 39:
-                                case 40:
-                                case 41:
-                                case 42:
-                                    {
-                                        this.state = 320;
-                                        this.value_expr();
-                                    }
-                                    break;
-                                case 29:
-                                case 31:
-                                case 37:
-                                    {
-                                        this.state = 321;
-                                        this.atom_expr();
-                                    }
-                                    break;
-                                default:
-                                    throw new NoViableAltException(this);
-                            }
-                        }
-                        break;
-                    case 3:
-                        {
-                            localctx = new UnaryOperatorExprContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 324;
-                            this.unary_operator();
-                            this.state = 325;
-                            this.data_expr(6);
-                        }
-                        break;
-                    case 4:
-                        {
-                            localctx = new DataExprContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 327;
-                            this.create_component_expr();
-                        }
-                        break;
-                    case 5:
-                        {
-                            localctx = new DataExprContext(this, localctx);
-                            this._ctx = localctx;
-                            _prevctx = localctx;
-                            this.state = 328;
-                            this.create_graphic_expr();
-                        }
-                        break;
-                }
-                this._ctx.stop = this._input.LT(-1);
-                this.state = 343;
-                this._errHandler.sync(this);
-                _alt = this._interp.adaptivePredict(this._input, 35, this._ctx);
-                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
-                    if (_alt === 1) {
-                        if (this._parseListeners != null) {
-                            this.triggerExitRuleEvent();
-                        }
-                        _prevctx = localctx;
-                        {
-                            this.state = 341;
-                            this._errHandler.sync(this);
-                            switch (this._interp.adaptivePredict(this._input, 34, this._ctx)) {
-                                case 1:
-                                    {
-                                        localctx = new MultiplyExprContext(this, new Data_exprContext(this, _parentctx, _parentState));
-                                        this.pushNewRecursionContext(localctx, _startState, CircuitScriptParser.RULE_data_expr);
-                                        this.state = 331;
-                                        if (!(this.precpred(this._ctx, 5))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
-                                        }
-                                        this.state = 332;
-                                        _la = this._input.LA(1);
-                                        if (!(_la === 31 || _la === 32)) {
-                                            this._errHandler.recoverInline(this);
-                                        }
-                                        else {
-                                            this._errHandler.reportMatch(this);
-                                            this.consume();
-                                        }
-                                        this.state = 333;
-                                        this.data_expr(6);
-                                    }
-                                    break;
-                                case 2:
-                                    {
-                                        localctx = new AdditionExprContext(this, new Data_exprContext(this, _parentctx, _parentState));
-                                        this.pushNewRecursionContext(localctx, _startState, CircuitScriptParser.RULE_data_expr);
-                                        this.state = 334;
-                                        if (!(this.precpred(this._ctx, 4))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
-                                        }
-                                        this.state = 335;
-                                        _la = this._input.LA(1);
-                                        if (!(_la === 29 || _la === 30)) {
-                                            this._errHandler.recoverInline(this);
-                                        }
-                                        else {
-                                            this._errHandler.reportMatch(this);
-                                            this.consume();
-                                        }
-                                        this.state = 336;
-                                        this.data_expr(5);
-                                    }
-                                    break;
-                                case 3:
-                                    {
-                                        localctx = new BinaryOperatorExprContext(this, new Data_exprContext(this, _parentctx, _parentState));
-                                        this.pushNewRecursionContext(localctx, _startState, CircuitScriptParser.RULE_data_expr);
-                                        this.state = 337;
-                                        if (!(this.precpred(this._ctx, 3))) {
-                                            throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
-                                        }
-                                        this.state = 338;
-                                        this.binary_operator();
-                                        this.state = 339;
-                                        this.data_expr(4);
-                                    }
-                                    break;
-                            }
-                        }
-                    }
-                    this.state = 345;
-                    this._errHandler.sync(this);
-                    _alt = this._interp.adaptivePredict(this._input, 35, 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;
-    }
-    binary_operator() {
-        let localctx = new Binary_operatorContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 56, CircuitScriptParser.RULE_binary_operator);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 346;
-                _la = this._input.LA(1);
-                if (!(_la === 27 || _la === 28)) {
-                    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;
-    }
-    unary_operator() {
-        let localctx = new Unary_operatorContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 58, CircuitScriptParser.RULE_unary_operator);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 348;
-                _la = this._input.LA(1);
-                if (!(_la === 26 || _la === 30)) {
-                    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;
-    }
-    value_expr() {
-        let localctx = new Value_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 60, CircuitScriptParser.RULE_value_expr);
-        let _la;
-        try {
-            this.state = 355;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 30:
-                case 36:
-                case 38:
-                case 39:
-                case 40:
-                case 41:
-                case 42:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        {
-                            this.state = 351;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                            if (_la === 30) {
-                                {
-                                    this.state = 350;
-                                    this.match(CircuitScriptParser.Minus);
-                                }
-                            }
-                            this.state = 353;
-                            _la = this._input.LA(1);
-                            if (!(((((_la - 36)) & ~0x1F) === 0 && ((1 << (_la - 36)) & 125) !== 0))) {
-                                this._errHandler.recoverInline(this);
-                            }
-                            else {
-                                this._errHandler.reportMatch(this);
-                                this.consume();
-                            }
-                        }
-                    }
-                    break;
-                case 6:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 354;
-                        this.blank_expr();
-                    }
-                    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;
-    }
-    function_def_expr() {
-        let localctx = new Function_def_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 62, CircuitScriptParser.RULE_function_def_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 357;
-                this.match(CircuitScriptParser.Define);
-                this.state = 358;
-                this.match(CircuitScriptParser.ID);
-                this.state = 359;
-                this.match(CircuitScriptParser.OPEN_PAREN);
-                this.state = 361;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                if (_la === 37) {
-                    {
-                        this.state = 360;
-                        this.function_args_expr();
-                    }
-                }
-                this.state = 363;
-                this.match(CircuitScriptParser.CLOSE_PAREN);
-                this.state = 364;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 365;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 366;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 369;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 369;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 367;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 4:
-                            case 8:
-                            case 9:
-                            case 10:
-                            case 14:
-                            case 16:
-                            case 17:
-                            case 18:
-                            case 19:
-                            case 20:
-                            case 21:
-                            case 22:
-                            case 23:
-                            case 24:
-                            case 29:
-                            case 31:
-                            case 37:
-                                {
-                                    this.state = 368;
-                                    this.function_expr();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 371;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2717861648) !== 0) || _la === 37 || _la === 45);
-                this.state = 373;
-                this.match(CircuitScriptParser.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;
-    }
-    function_expr() {
-        let localctx = new Function_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 64, CircuitScriptParser.RULE_function_expr);
-        try {
-            this.state = 377;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 4:
-                case 8:
-                case 9:
-                case 10:
-                case 14:
-                case 16:
-                case 17:
-                case 18:
-                case 19:
-                case 20:
-                case 21:
-                case 23:
-                case 24:
-                case 29:
-                case 31:
-                case 37:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 375;
-                        this.expression();
-                    }
-                    break;
-                case 22:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 376;
-                        this.function_return_expr();
-                    }
-                    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;
-    }
-    function_args_expr() {
-        let localctx = new Function_args_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 66, CircuitScriptParser.RULE_function_args_expr);
-        let _la;
-        try {
-            let _alt;
-            this.state = 408;
-            this._errHandler.sync(this);
-            switch (this._interp.adaptivePredict(this._input, 45, this._ctx)) {
-                case 1:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 379;
-                        this.match(CircuitScriptParser.ID);
-                        this.state = 384;
-                        this._errHandler.sync(this);
-                        _alt = this._interp.adaptivePredict(this._input, 42, this._ctx);
-                        while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
-                            if (_alt === 1) {
-                                {
-                                    {
-                                        this.state = 380;
-                                        this.match(CircuitScriptParser.T__1);
-                                        this.state = 381;
-                                        this.match(CircuitScriptParser.ID);
-                                    }
-                                }
-                            }
-                            this.state = 386;
-                            this._errHandler.sync(this);
-                            _alt = this._interp.adaptivePredict(this._input, 42, this._ctx);
-                        }
-                        this.state = 393;
-                        this._errHandler.sync(this);
-                        _la = this._input.LA(1);
-                        while (_la === 2) {
-                            {
-                                {
-                                    this.state = 387;
-                                    this.match(CircuitScriptParser.T__1);
-                                    this.state = 388;
-                                    this.match(CircuitScriptParser.ID);
-                                    this.state = 389;
-                                    this.match(CircuitScriptParser.T__2);
-                                    this.state = 390;
-                                    this.value_expr();
-                                }
-                            }
-                            this.state = 395;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                        }
-                    }
-                    break;
-                case 2:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 396;
-                        this.match(CircuitScriptParser.ID);
-                        this.state = 397;
-                        this.match(CircuitScriptParser.T__2);
-                        this.state = 398;
-                        this.value_expr();
-                        this.state = 405;
-                        this._errHandler.sync(this);
-                        _la = this._input.LA(1);
-                        while (_la === 2) {
-                            {
-                                {
-                                    this.state = 399;
-                                    this.match(CircuitScriptParser.T__1);
-                                    this.state = 400;
-                                    this.match(CircuitScriptParser.ID);
-                                    this.state = 401;
-                                    this.match(CircuitScriptParser.T__2);
-                                    this.state = 402;
-                                    this.value_expr();
-                                }
-                            }
-                            this.state = 407;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                        }
-                    }
-                    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;
-    }
-    atom_expr() {
-        let localctx = new Atom_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 68, CircuitScriptParser.RULE_atom_expr);
-        let _la;
-        try {
-            let _alt;
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 411;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                if (_la === 29 || _la === 31) {
-                    {
-                        this.state = 410;
-                        this.net_namespace_expr();
-                    }
-                }
-                this.state = 413;
-                this.match(CircuitScriptParser.ID);
-                this.state = 417;
-                this._errHandler.sync(this);
-                _alt = this._interp.adaptivePredict(this._input, 47, this._ctx);
-                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
-                    if (_alt === 1) {
-                        {
-                            {
-                                this.state = 414;
-                                this.trailer_expr();
-                            }
-                        }
-                    }
-                    this.state = 419;
-                    this._errHandler.sync(this);
-                    _alt = this._interp.adaptivePredict(this._input, 47, 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.exitRule();
-        }
-        return localctx;
-    }
-    trailer_expr() {
-        let localctx = new Trailer_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 70, CircuitScriptParser.RULE_trailer_expr);
-        let _la;
-        try {
-            this.state = 427;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 33:
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 420;
-                        this.match(CircuitScriptParser.OPEN_PAREN);
-                        this.state = 422;
-                        this._errHandler.sync(this);
-                        _la = this._input.LA(1);
-                        if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 3825207360) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 1017) !== 0)) {
-                            {
-                                this.state = 421;
-                                this.parameters();
-                            }
-                        }
-                        this.state = 424;
-                        this.match(CircuitScriptParser.CLOSE_PAREN);
-                    }
-                    break;
-                case 5:
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 425;
-                        this.match(CircuitScriptParser.T__4);
-                        this.state = 426;
-                        this.match(CircuitScriptParser.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;
-    }
-    net_namespace_expr() {
-        let localctx = new Net_namespace_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 72, CircuitScriptParser.RULE_net_namespace_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 430;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                if (_la === 29) {
-                    {
-                        this.state = 429;
-                        this.match(CircuitScriptParser.Addition);
-                    }
-                }
-                this.state = 432;
-                this.match(CircuitScriptParser.Divide);
-                this.state = 434;
-                this._errHandler.sync(this);
-                switch (this._interp.adaptivePredict(this._input, 51, this._ctx)) {
-                    case 1:
-                        {
-                            this.state = 433;
-                            this.data_expr(0);
-                        }
-                        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;
-    }
-    function_return_expr() {
-        let localctx = new Function_return_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 74, CircuitScriptParser.RULE_function_return_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 436;
-                this.match(CircuitScriptParser.Return);
-                this.state = 437;
-                this.data_expr(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;
-    }
-    create_component_expr() {
-        let localctx = new Create_component_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 76, CircuitScriptParser.RULE_create_component_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 439;
-                this.match(CircuitScriptParser.Create);
-                this.state = 440;
-                this.match(CircuitScriptParser.Component);
-                this.state = 441;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 442;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 443;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 446;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 446;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 444;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 37:
-                            case 38:
-                            case 41:
-                                {
-                                    this.state = 445;
-                                    this.property_expr();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 448;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while (((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 275) !== 0));
-                this.state = 450;
-                this.match(CircuitScriptParser.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;
-    }
-    create_graphic_expr() {
-        let localctx = new Create_graphic_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 78, CircuitScriptParser.RULE_create_graphic_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 452;
-                this.match(CircuitScriptParser.Create);
-                this.state = 453;
-                this.match(CircuitScriptParser.Graphic);
-                this.state = 454;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 455;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 456;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 459;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 459;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 457;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 15:
-                            case 37:
-                                {
-                                    this.state = 458;
-                                    this.sub_expr();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 461;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while (((((_la - 15)) & ~0x1F) === 0 && ((1 << (_la - 15)) & 1077936129) !== 0));
-                this.state = 463;
-                this.match(CircuitScriptParser.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;
-    }
-    sub_expr() {
-        let localctx = new Sub_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 80, CircuitScriptParser.RULE_sub_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 465;
-                _la = this._input.LA(1);
-                if (!(_la === 15 || _la === 37)) {
-                    this._errHandler.recoverInline(this);
-                }
-                else {
-                    this._errHandler.reportMatch(this);
-                    this.consume();
-                }
-                this.state = 466;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 472;
-                this._errHandler.sync(this);
-                switch (this._interp.adaptivePredict(this._input, 56, this._ctx)) {
-                    case 1:
-                        {
-                            this.state = 467;
-                            this.parameters();
-                        }
-                        break;
-                    case 2:
-                        {
-                            this.state = 468;
-                            this.match(CircuitScriptParser.OPEN_PAREN);
-                            this.state = 469;
-                            this.parameters();
-                            this.state = 470;
-                            this.match(CircuitScriptParser.CLOSE_PAREN);
-                        }
-                        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;
-    }
-    property_expr() {
-        let localctx = new Property_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 82, CircuitScriptParser.RULE_property_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 474;
-                this.property_key_expr();
-                this.state = 475;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 476;
-                this.property_value_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;
-    }
-    property_key_expr() {
-        let localctx = new Property_key_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 84, CircuitScriptParser.RULE_property_key_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 478;
-                _la = this._input.LA(1);
-                if (!(((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 19) !== 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;
-    }
-    property_value_expr() {
-        let localctx = new Property_value_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 86, CircuitScriptParser.RULE_property_value_expr);
-        let _la;
-        try {
-            this.state = 497;
-            this._errHandler.sync(this);
-            switch (this._input.LA(1)) {
-                case 45:
-                    localctx = new Nested_propertiesContext(this, localctx);
-                    this.enterOuterAlt(localctx, 1);
-                    {
-                        this.state = 480;
-                        this.match(CircuitScriptParser.NEWLINE);
-                        this.state = 481;
-                        this.match(CircuitScriptParser.INDENT);
-                        this.state = 484;
-                        this._errHandler.sync(this);
-                        _la = this._input.LA(1);
-                        do {
-                            {
-                                this.state = 484;
-                                this._errHandler.sync(this);
-                                switch (this._input.LA(1)) {
-                                    case 45:
-                                        {
-                                            this.state = 482;
-                                            this.match(CircuitScriptParser.NEWLINE);
-                                        }
-                                        break;
-                                    case 37:
-                                    case 38:
-                                    case 41:
-                                        {
-                                            this.state = 483;
-                                            this.property_expr();
-                                        }
-                                        break;
-                                    default:
-                                        throw new NoViableAltException(this);
-                                }
-                            }
-                            this.state = 486;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                        } while (((((_la - 37)) & ~0x1F) === 0 && ((1 << (_la - 37)) & 275) !== 0));
-                        this.state = 488;
-                        this.match(CircuitScriptParser.DEDENT);
-                    }
-                    break;
-                case 6:
-                case 11:
-                case 26:
-                case 29:
-                case 30:
-                case 31:
-                case 33:
-                case 36:
-                case 37:
-                case 38:
-                case 39:
-                case 40:
-                case 41:
-                case 42:
-                    localctx = new Single_line_propertyContext(this, localctx);
-                    this.enterOuterAlt(localctx, 2);
-                    {
-                        this.state = 489;
-                        this.data_expr(0);
-                        this.state = 494;
-                        this._errHandler.sync(this);
-                        _la = this._input.LA(1);
-                        while (_la === 2) {
-                            {
-                                {
-                                    this.state = 490;
-                                    this.match(CircuitScriptParser.T__1);
-                                    this.state = 491;
-                                    this.data_expr(0);
-                                }
-                            }
-                            this.state = 496;
-                            this._errHandler.sync(this);
-                            _la = this._input.LA(1);
-                        }
-                    }
-                    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;
-    }
-    blank_expr() {
-        let localctx = new Blank_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 88, CircuitScriptParser.RULE_blank_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 499;
-                this.match(CircuitScriptParser.T__5);
-                this.state = 500;
-                this.match(CircuitScriptParser.INTEGER_VALUE);
-                this.state = 501;
-                this.match(CircuitScriptParser.T__6);
-            }
-        }
-        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;
-    }
-    wire_expr() {
-        let localctx = new Wire_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 90, CircuitScriptParser.RULE_wire_expr);
-        let _la;
-        try {
-            let _alt;
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 503;
-                this.match(CircuitScriptParser.Wire);
-                this.state = 504;
-                this.match(CircuitScriptParser.ID);
-                this.state = 508;
-                this._errHandler.sync(this);
-                _alt = this._interp.adaptivePredict(this._input, 61, this._ctx);
-                while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
-                    if (_alt === 1) {
-                        {
-                            {
-                                this.state = 505;
-                                _la = this._input.LA(1);
-                                if (!(_la === 37 || _la === 38)) {
-                                    this._errHandler.recoverInline(this);
-                                }
-                                else {
-                                    this._errHandler.reportMatch(this);
-                                    this.consume();
-                                }
-                            }
-                        }
-                    }
-                    this.state = 510;
-                    this._errHandler.sync(this);
-                    _alt = this._interp.adaptivePredict(this._input, 61, 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.exitRule();
-        }
-        return localctx;
-    }
-    point_expr() {
-        let localctx = new Point_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 92, CircuitScriptParser.RULE_point_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 511;
-                this.match(CircuitScriptParser.Point);
-                this.state = 512;
-                this.match(CircuitScriptParser.ID);
-            }
-        }
-        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;
-    }
-    import_expr() {
-        let localctx = new Import_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 94, CircuitScriptParser.RULE_import_expr);
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 514;
-                this.match(CircuitScriptParser.Import);
-                this.state = 515;
-                this.match(CircuitScriptParser.ID);
-            }
-        }
-        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;
-    }
-    frame_expr() {
-        let localctx = new Frame_exprContext(this, this._ctx, this.state);
-        this.enterRule(localctx, 96, CircuitScriptParser.RULE_frame_expr);
-        let _la;
-        try {
-            this.enterOuterAlt(localctx, 1);
-            {
-                this.state = 517;
-                this.match(CircuitScriptParser.T__7);
-                this.state = 518;
-                this.match(CircuitScriptParser.T__0);
-                this.state = 519;
-                this.match(CircuitScriptParser.NEWLINE);
-                this.state = 520;
-                this.match(CircuitScriptParser.INDENT);
-                this.state = 523;
-                this._errHandler.sync(this);
-                _la = this._input.LA(1);
-                do {
-                    {
-                        this.state = 523;
-                        this._errHandler.sync(this);
-                        switch (this._input.LA(1)) {
-                            case 45:
-                                {
-                                    this.state = 521;
-                                    this.match(CircuitScriptParser.NEWLINE);
-                                }
-                                break;
-                            case 4:
-                            case 8:
-                            case 9:
-                            case 10:
-                            case 14:
-                            case 16:
-                            case 17:
-                            case 18:
-                            case 19:
-                            case 20:
-                            case 21:
-                            case 23:
-                            case 24:
-                            case 29:
-                            case 31:
-                            case 37:
-                                {
-                                    this.state = 522;
-                                    this.expression();
-                                }
-                                break;
-                            default:
-                                throw new NoViableAltException(this);
-                        }
-                    }
-                    this.state = 525;
-                    this._errHandler.sync(this);
-                    _la = this._input.LA(1);
-                } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2713667344) !== 0) || _la === 37 || _la === 45);
-                this.state = 527;
-                this.match(CircuitScriptParser.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;
-    }
-    sempred(localctx, ruleIndex, predIndex) {
-        switch (ruleIndex) {
-            case 27:
-                return this.data_expr_sempred(localctx, predIndex);
-        }
-        return true;
-    }
-    data_expr_sempred(localctx, predIndex) {
-        switch (predIndex) {
-            case 0:
-                return this.precpred(this._ctx, 5);
-            case 1:
-                return this.precpred(this._ctx, 4);
-            case 2:
-                return this.precpred(this._ctx, 3);
-        }
-        return true;
-    }
-    static _serializedATN = [4, 1, 48, 530, 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, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2,
-        39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46,
-        7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 1, 0, 1, 0, 4, 0, 101, 8, 0, 11, 0, 12, 0, 102, 1, 0, 1, 0, 1, 1,
-        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 123, 8, 1,
-        1, 2, 4, 2, 126, 8, 2, 11, 2, 12, 2, 127, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 4, 3, 136, 8, 3, 11, 3,
-        12, 3, 137, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 4, 4, 148, 8, 4, 11, 4, 12, 4, 149, 1, 4,
-        1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 3, 6, 160, 8, 6, 1, 6, 3, 6, 163, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7,
-        168, 8, 7, 1, 8, 1, 8, 3, 8, 172, 8, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 3, 11, 182,
-        8, 11, 1, 11, 3, 11, 185, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 191, 8, 12, 10, 12, 12, 12, 194,
-        9, 12, 1, 12, 3, 12, 197, 8, 12, 1, 12, 3, 12, 200, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13,
-        5, 13, 208, 8, 13, 10, 13, 12, 13, 211, 9, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 4, 13, 218, 8,
-        13, 11, 13, 12, 13, 219, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 5, 14, 229, 8, 14, 10,
-        14, 12, 14, 232, 9, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 4, 16, 242, 8, 16,
-        11, 16, 12, 16, 243, 1, 16, 1, 16, 1, 17, 1, 17, 3, 17, 250, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 3,
-        18, 256, 8, 18, 1, 19, 1, 19, 3, 19, 260, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 4, 20, 266, 8, 20, 11,
-        20, 12, 20, 267, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23,
-        1, 24, 1, 24, 1, 24, 5, 24, 285, 8, 24, 10, 24, 12, 24, 288, 9, 24, 1, 24, 1, 24, 5, 24, 292, 8,
-        24, 10, 24, 12, 24, 295, 9, 24, 1, 24, 1, 24, 1, 24, 5, 24, 300, 8, 24, 10, 24, 12, 24, 303, 9,
-        24, 3, 24, 305, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27,
-        1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 323, 8, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 330,
-        8, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 342, 8, 27, 10,
-        27, 12, 27, 345, 9, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 3, 30, 352, 8, 30, 1, 30, 1, 30, 3, 30,
-        356, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 362, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31,
-        4, 31, 370, 8, 31, 11, 31, 12, 31, 371, 1, 31, 1, 31, 1, 32, 1, 32, 3, 32, 378, 8, 32, 1, 33, 1,
-        33, 1, 33, 5, 33, 383, 8, 33, 10, 33, 12, 33, 386, 9, 33, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 392,
-        8, 33, 10, 33, 12, 33, 395, 9, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 404, 8,
-        33, 10, 33, 12, 33, 407, 9, 33, 3, 33, 409, 8, 33, 1, 34, 3, 34, 412, 8, 34, 1, 34, 1, 34, 5, 34,
-        416, 8, 34, 10, 34, 12, 34, 419, 9, 34, 1, 35, 1, 35, 3, 35, 423, 8, 35, 1, 35, 1, 35, 1, 35, 3,
-        35, 428, 8, 35, 1, 36, 3, 36, 431, 8, 36, 1, 36, 1, 36, 3, 36, 435, 8, 36, 1, 37, 1, 37, 1, 37, 1,
-        38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 4, 38, 447, 8, 38, 11, 38, 12, 38, 448, 1, 38, 1, 38,
-        1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 4, 39, 460, 8, 39, 11, 39, 12, 39, 461, 1, 39, 1,
-        39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 473, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41,
-        1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 4, 43, 485, 8, 43, 11, 43, 12, 43, 486, 1, 43, 1, 43, 1,
-        43, 1, 43, 5, 43, 493, 8, 43, 10, 43, 12, 43, 496, 9, 43, 3, 43, 498, 8, 43, 1, 44, 1, 44, 1, 44,
-        1, 44, 1, 45, 1, 45, 1, 45, 5, 45, 507, 8, 45, 10, 45, 12, 45, 510, 9, 45, 1, 46, 1, 46, 1, 46, 1,
-        47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 4, 48, 524, 8, 48, 11, 48, 12, 48, 525,
-        1, 48, 1, 48, 1, 48, 0, 1, 54, 49, 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, 70, 72, 74, 76, 78, 80,
-        82, 84, 86, 88, 90, 92, 94, 96, 0, 11, 2, 0, 10, 10, 19, 21, 1, 0, 37, 38, 2, 0, 38, 38, 41, 41,
-        2, 0, 35, 35, 38, 38, 1, 0, 31, 32, 1, 0, 29, 30, 1, 0, 27, 28, 2, 0, 26, 26, 30, 30, 2, 0, 36, 36,
-        38, 42, 2, 0, 15, 15, 37, 37, 2, 0, 37, 38, 41, 41, 562, 0, 100, 1, 0, 0, 0, 2, 122, 1, 0, 0, 0, 4,
-        125, 1, 0, 0, 0, 6, 129, 1, 0, 0, 0, 8, 141, 1, 0, 0, 0, 10, 153, 1, 0, 0, 0, 12, 159, 1, 0, 0, 0, 14,
-        164, 1, 0, 0, 0, 16, 171, 1, 0, 0, 0, 18, 173, 1, 0, 0, 0, 20, 176, 1, 0, 0, 0, 22, 178, 1, 0, 0, 0,
-        24, 186, 1, 0, 0, 0, 26, 201, 1, 0, 0, 0, 28, 223, 1, 0, 0, 0, 30, 233, 1, 0, 0, 0, 32, 235, 1, 0,
-        0, 0, 34, 249, 1, 0, 0, 0, 36, 251, 1, 0, 0, 0, 38, 259, 1, 0, 0, 0, 40, 261, 1, 0, 0, 0, 42, 271,
-        1, 0, 0, 0, 44, 273, 1, 0, 0, 0, 46, 277, 1, 0, 0, 0, 48, 304, 1, 0, 0, 0, 50, 306, 1, 0, 0, 0, 52,
-        310, 1, 0, 0, 0, 54, 329, 1, 0, 0, 0, 56, 346, 1, 0, 0, 0, 58, 348, 1, 0, 0, 0, 60, 355, 1, 0, 0, 0,
-        62, 357, 1, 0, 0, 0, 64, 377, 1, 0, 0, 0, 66, 408, 1, 0, 0, 0, 68, 411, 1, 0, 0, 0, 70, 427, 1, 0,
-        0, 0, 72, 430, 1, 0, 0, 0, 74, 436, 1, 0, 0, 0, 76, 439, 1, 0, 0, 0, 78, 452, 1, 0, 0, 0, 80, 465,
-        1, 0, 0, 0, 82, 474, 1, 0, 0, 0, 84, 478, 1, 0, 0, 0, 86, 497, 1, 0, 0, 0, 88, 499, 1, 0, 0, 0, 90,
-        503, 1, 0, 0, 0, 92, 511, 1, 0, 0, 0, 94, 514, 1, 0, 0, 0, 96, 517, 1, 0, 0, 0, 98, 101, 3, 2, 1, 0,
-        99, 101, 5, 45, 0, 0, 100, 98, 1, 0, 0, 0, 100, 99, 1, 0, 0, 0, 101, 102, 1, 0, 0, 0, 102, 100, 1,
-        0, 0, 0, 102, 103, 1, 0, 0, 0, 103, 104, 1, 0, 0, 0, 104, 105, 5, 0, 0, 1, 105, 1, 1, 0, 0, 0, 106,
-        123, 3, 14, 7, 0, 107, 123, 3, 24, 12, 0, 108, 123, 3, 22, 11, 0, 109, 123, 3, 44, 22, 0, 110,
-        123, 3, 50, 25, 0, 111, 123, 3, 8, 4, 0, 112, 123, 3, 52, 26, 0, 113, 123, 3, 42, 21, 0, 114, 123,
-        3, 62, 31, 0, 115, 123, 3, 90, 45, 0, 116, 123, 3, 94, 47, 0, 117, 123, 3, 96, 48, 0, 118, 123,
-        3, 68, 34, 0, 119, 123, 3, 32, 16, 0, 120, 123, 3, 4, 2, 0, 121, 123, 3, 92, 46, 0, 122, 106, 1,
-        0, 0, 0, 122, 107, 1, 0, 0, 0, 122, 108, 1, 0, 0, 0, 122, 109, 1, 0, 0, 0, 122, 110, 1, 0, 0, 0, 122,
-        111, 1, 0, 0, 0, 122, 112, 1, 0, 0, 0, 122, 113, 1, 0, 0, 0, 122, 114, 1, 0, 0, 0, 122, 115, 1, 0,
-        0, 0, 122, 116, 1, 0, 0, 0, 122, 117, 1, 0, 0, 0, 122, 118, 1, 0, 0, 0, 122, 119, 1, 0, 0, 0, 122,
-        120, 1, 0, 0, 0, 122, 121, 1, 0, 0, 0, 123, 3, 1, 0, 0, 0, 124, 126, 3, 6, 3, 0, 125, 124, 1, 0, 0,
-        0, 126, 127, 1, 0, 0, 0, 127, 125, 1, 0, 0, 0, 127, 128, 1, 0, 0, 0, 128, 5, 1, 0, 0, 0, 129, 130,
-        7, 0, 0, 0, 130, 131, 5, 1, 0, 0, 131, 132, 5, 45, 0, 0, 132, 135, 5, 47, 0, 0, 133, 136, 5, 45,
-        0, 0, 134, 136, 3, 2, 1, 0, 135, 133, 1, 0, 0, 0, 135, 134, 1, 0, 0, 0, 136, 137, 1, 0, 0, 0, 137,
-        135, 1, 0, 0, 0, 137, 138, 1, 0, 0, 0, 138, 139, 1, 0, 0, 0, 139, 140, 5, 48, 0, 0, 140, 7, 1, 0,
-        0, 0, 141, 142, 3, 68, 34, 0, 142, 143, 5, 1, 0, 0, 143, 144, 5, 45, 0, 0, 144, 147, 5, 47, 0, 0,
-        145, 148, 5, 45, 0, 0, 146, 148, 3, 10, 5, 0, 147, 145, 1, 0, 0, 0, 147, 146, 1, 0, 0, 0, 148, 149,
-        1, 0, 0, 0, 149, 147, 1, 0, 0, 0, 149, 150, 1, 0, 0, 0, 150, 151, 1, 0, 0, 0, 151, 152, 5, 48, 0,
-        0, 152, 9, 1, 0, 0, 0, 153, 154, 7, 1, 0, 0, 154, 155, 5, 1, 0, 0, 155, 156, 3, 60, 30, 0, 156, 11,
-        1, 0, 0, 0, 157, 160, 3, 54, 27, 0, 158, 160, 3, 44, 22, 0, 159, 157, 1, 0, 0, 0, 159, 158, 1, 0,
-        0, 0, 160, 162, 1, 0, 0, 0, 161, 163, 3, 18, 9, 0, 162, 161, 1, 0, 0, 0, 162, 163, 1, 0, 0, 0, 163,
-        13, 1, 0, 0, 0, 164, 165, 5, 16, 0, 0, 165, 167, 3, 12, 6, 0, 166, 168, 5, 37, 0, 0, 167, 166, 1,
-        0, 0, 0, 167, 168, 1, 0, 0, 0, 168, 15, 1, 0, 0, 0, 169, 172, 3, 12, 6, 0, 170, 172, 3, 18, 9, 0,
-        171, 169, 1, 0, 0, 0, 171, 170, 1, 0, 0, 0, 172, 17, 1, 0, 0, 0, 173, 174, 5, 15, 0, 0, 174, 175,
-        7, 2, 0, 0, 175, 19, 1, 0, 0, 0, 176, 177, 7, 2, 0, 0, 177, 21, 1, 0, 0, 0, 178, 184, 5, 17, 0, 0,
-        179, 181, 3, 16, 8, 0, 180, 182, 5, 37, 0, 0, 181, 180, 1, 0, 0, 0, 181, 182, 1, 0, 0, 0, 182, 185,
-        1, 0, 0, 0, 183, 185, 5, 19, 0, 0, 184, 179, 1, 0, 0, 0, 184, 183, 1, 0, 0, 0, 185, 23, 1, 0, 0, 0,
-        186, 199, 5, 18, 0, 0, 187, 192, 3, 16, 8, 0, 188, 189, 5, 2, 0, 0, 189, 191, 3, 16, 8, 0, 190,
-        188, 1, 0, 0, 0, 191, 194, 1, 0, 0, 0, 192, 190, 1, 0, 0, 0, 192, 193, 1, 0, 0, 0, 193, 196, 1, 0,
-        0, 0, 194, 192, 1, 0, 0, 0, 195, 197, 5, 37, 0, 0, 196, 195, 1, 0, 0, 0, 196, 197, 1, 0, 0, 0, 197,
-        200, 1, 0, 0, 0, 198, 200, 5, 19, 0, 0, 199, 187, 1, 0, 0, 0, 199, 198, 1, 0, 0, 0, 200, 25, 1, 0,
-        0, 0, 201, 202, 5, 17, 0, 0, 202, 203, 3, 16, 8, 0, 203, 204, 5, 18, 0, 0, 204, 209, 3, 16, 8, 0,
-        205, 206, 5, 2, 0, 0, 206, 208, 3, 16, 8, 0, 207, 205, 1, 0, 0, 0, 208, 211, 1, 0, 0, 0, 209, 207,
-        1, 0, 0, 0, 209, 210, 1, 0, 0, 0, 210, 212, 1, 0, 0, 0, 211, 209, 1, 0, 0, 0, 212, 213, 5, 1, 0, 0,
-        213, 214, 5, 45, 0, 0, 214, 217, 5, 47, 0, 0, 215, 218, 5, 45, 0, 0, 216, 218, 3, 28, 14, 0, 217,
-        215, 1, 0, 0, 0, 217, 216, 1, 0, 0, 0, 218, 219, 1, 0, 0, 0, 219, 217, 1, 0, 0, 0, 219, 220, 1, 0,
-        0, 0, 220, 221, 1, 0, 0, 0, 221, 222, 5, 48, 0, 0, 222, 27, 1, 0, 0, 0, 223, 224, 3, 20, 10, 0, 224,
-        225, 5, 1, 0, 0, 225, 230, 3, 30, 15, 0, 226, 227, 5, 2, 0, 0, 227, 229, 3, 30, 15, 0, 228, 226,
-        1, 0, 0, 0, 229, 232, 1, 0, 0, 0, 230, 228, 1, 0, 0, 0, 230, 231, 1, 0, 0, 0, 231, 29, 1, 0, 0, 0,
-        232, 230, 1, 0, 0, 0, 233, 234, 7, 3, 0, 0, 234, 31, 1, 0, 0, 0, 235, 236, 3, 22, 11, 0, 236, 237,
-        5, 1, 0, 0, 237, 238, 5, 45, 0, 0, 238, 241, 5, 47, 0, 0, 239, 242, 5, 45, 0, 0, 240, 242, 3, 34,
-        17, 0, 241, 239, 1, 0, 0, 0, 241, 240, 1, 0, 0, 0, 242, 243, 1, 0, 0, 0, 243, 241, 1, 0, 0, 0, 243,
-        244, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 246, 5, 48, 0, 0, 246, 33, 1, 0, 0, 0, 247, 250, 3, 2,
-        1, 0, 248, 250, 3, 36, 18, 0, 249, 247, 1, 0, 0, 0, 249, 248, 1, 0, 0, 0, 250, 35, 1, 0, 0, 0, 251,
-        252, 3, 20, 10, 0, 252, 255, 5, 1, 0, 0, 253, 256, 3, 38, 19, 0, 254, 256, 3, 40, 20, 0, 255, 253,
-        1, 0, 0, 0, 255, 254, 1, 0, 0, 0, 256, 37, 1, 0, 0, 0, 257, 260, 3, 2, 1, 0, 258, 260, 5, 35, 0, 0,
-        259, 257, 1, 0, 0, 0, 259, 258, 1, 0, 0, 0, 260, 39, 1, 0, 0, 0, 261, 262, 5, 45, 0, 0, 262, 265,
-        5, 47, 0, 0, 263, 266, 5, 45, 0, 0, 264, 266, 3, 2, 1, 0, 265, 263, 1, 0, 0, 0, 265, 264, 1, 0, 0,
-        0, 266, 267, 1, 0, 0, 0, 267, 265, 1, 0, 0, 0, 267, 268, 1, 0, 0, 0, 268, 269, 1, 0, 0, 0, 269, 270,
-        5, 48, 0, 0, 270, 41, 1, 0, 0, 0, 271, 272, 5, 9, 0, 0, 272, 43, 1, 0, 0, 0, 273, 274, 3, 68, 34,
-        0, 274, 275, 5, 3, 0, 0, 275, 276, 3, 54, 27, 0, 276, 45, 1, 0, 0, 0, 277, 278, 5, 37, 0, 0, 278,
-        279, 5, 3, 0, 0, 279, 280, 3, 54, 27, 0, 280, 47, 1, 0, 0, 0, 281, 286, 3, 54, 27, 0, 282, 283,
-        5, 2, 0, 0, 283, 285, 3, 54, 27, 0, 284, 282, 1, 0, 0, 0, 285, 288, 1, 0, 0, 0, 286, 284, 1, 0, 0,
-        0, 286, 287, 1, 0, 0, 0, 287, 293, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 289, 290, 5, 2, 0, 0, 290, 292,
-        3, 46, 23, 0, 291, 289, 1, 0, 0, 0, 292, 295, 1, 0, 0, 0, 293, 291, 1, 0, 0, 0, 293, 294, 1, 0, 0,
-        0, 294, 305, 1, 0, 0, 0, 295, 293, 1, 0, 0, 0, 296, 301, 3, 46, 23, 0, 297, 298, 5, 2, 0, 0, 298,
-        300, 3, 46, 23, 0, 299, 297, 1, 0, 0, 0, 300, 303, 1, 0, 0, 0, 301, 299, 1, 0, 0, 0, 301, 302, 1,
-        0, 0, 0, 302, 305, 1, 0, 0, 0, 303, 301, 1, 0, 0, 0, 304, 281, 1, 0, 0, 0, 304, 296, 1, 0, 0, 0, 305,
-        49, 1, 0, 0, 0, 306, 307, 3, 68, 34, 0, 307, 308, 5, 3, 0, 0, 308, 309, 3, 54, 27, 0, 309, 51, 1,
-        0, 0, 0, 310, 311, 5, 4, 0, 0, 311, 312, 5, 37, 0, 0, 312, 313, 5, 3, 0, 0, 313, 314, 3, 54, 27,
-        0, 314, 53, 1, 0, 0, 0, 315, 316, 6, 27, -1, 0, 316, 317, 5, 33, 0, 0, 317, 318, 3, 54, 27, 0, 318,
-        319, 5, 34, 0, 0, 319, 330, 1, 0, 0, 0, 320, 323, 3, 60, 30, 0, 321, 323, 3, 68, 34, 0, 322, 320,
-        1, 0, 0, 0, 322, 321, 1, 0, 0, 0, 323, 330, 1, 0, 0, 0, 324, 325, 3, 58, 29, 0, 325, 326, 3, 54,
-        27, 6, 326, 330, 1, 0, 0, 0, 327, 330, 3, 76, 38, 0, 328, 330, 3, 78, 39, 0, 329, 315, 1, 0, 0,
-        0, 329, 322, 1, 0, 0, 0, 329, 324, 1, 0, 0, 0, 329, 327, 1, 0, 0, 0, 329, 328, 1, 0, 0, 0, 330, 343,
-        1, 0, 0, 0, 331, 332, 10, 5, 0, 0, 332, 333, 7, 4, 0, 0, 333, 342, 3, 54, 27, 6, 334, 335, 10, 4,
-        0, 0, 335, 336, 7, 5, 0, 0, 336, 342, 3, 54, 27, 5, 337, 338, 10, 3, 0, 0, 338, 339, 3, 56, 28,
-        0, 339, 340, 3, 54, 27, 4, 340, 342, 1, 0, 0, 0, 341, 331, 1, 0, 0, 0, 341, 334, 1, 0, 0, 0, 341,
-        337, 1, 0, 0, 0, 342, 345, 1, 0, 0, 0, 343, 341, 1, 0, 0, 0, 343, 344, 1, 0, 0, 0, 344, 55, 1, 0,
-        0, 0, 345, 343, 1, 0, 0, 0, 346, 347, 7, 6, 0, 0, 347, 57, 1, 0, 0, 0, 348, 349, 7, 7, 0, 0, 349,
-        59, 1, 0, 0, 0, 350, 352, 5, 30, 0, 0, 351, 350, 1, 0, 0, 0, 351, 352, 1, 0, 0, 0, 352, 353, 1, 0,
-        0, 0, 353, 356, 7, 8, 0, 0, 354, 356, 3, 88, 44, 0, 355, 351, 1, 0, 0, 0, 355, 354, 1, 0, 0, 0, 356,
-        61, 1, 0, 0, 0, 357, 358, 5, 23, 0, 0, 358, 359, 5, 37, 0, 0, 359, 361, 5, 33, 0, 0, 360, 362, 3,
-        66, 33, 0, 361, 360, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 364, 5, 34, 0,
-        0, 364, 365, 5, 1, 0, 0, 365, 366, 5, 45, 0, 0, 366, 369, 5, 47, 0, 0, 367, 370, 5, 45, 0, 0, 368,
-        370, 3, 64, 32, 0, 369, 367, 1, 0, 0, 0, 369, 368, 1, 0, 0, 0, 370, 371, 1, 0, 0, 0, 371, 369, 1,
-        0, 0, 0, 371, 372, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 374, 5, 48, 0, 0, 374, 63, 1, 0, 0, 0, 375,
-        378, 3, 2, 1, 0, 376, 378, 3, 74, 37, 0, 377, 375, 1, 0, 0, 0, 377, 376, 1, 0, 0, 0, 378, 65, 1,
-        0, 0, 0, 379, 384, 5, 37, 0, 0, 380, 381, 5, 2, 0, 0, 381, 383, 5, 37, 0, 0, 382, 380, 1, 0, 0, 0,
-        383, 386, 1, 0, 0, 0, 384, 382, 1, 0, 0, 0, 384, 385, 1, 0, 0, 0, 385, 393, 1, 0, 0, 0, 386, 384,
-        1, 0, 0, 0, 387, 388, 5, 2, 0, 0, 388, 389, 5, 37, 0, 0, 389, 390, 5, 3, 0, 0, 390, 392, 3, 60, 30,
-        0, 391, 387, 1, 0, 0, 0, 392, 395, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 393, 394, 1, 0, 0, 0, 394, 409,
-        1, 0, 0, 0, 395, 393, 1, 0, 0, 0, 396, 397, 5, 37, 0, 0, 397, 398, 5, 3, 0, 0, 398, 405, 3, 60, 30,
-        0, 399, 400, 5, 2, 0, 0, 400, 401, 5, 37, 0, 0, 401, 402, 5, 3, 0, 0, 402, 404, 3, 60, 30, 0, 403,
-        399, 1, 0, 0, 0, 404, 407, 1, 0, 0, 0, 405, 403, 1, 0, 0, 0, 405, 406, 1, 0, 0, 0, 406, 409, 1, 0,
-        0, 0, 407, 405, 1, 0, 0, 0, 408, 379, 1, 0, 0, 0, 408, 396, 1, 0, 0, 0, 409, 67, 1, 0, 0, 0, 410,
-        412, 3, 72, 36, 0, 411, 410, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 413, 1, 0, 0, 0, 413, 417, 5,
-        37, 0, 0, 414, 416, 3, 70, 35, 0, 415, 414, 1, 0, 0, 0, 416, 419, 1, 0, 0, 0, 417, 415, 1, 0, 0,
-        0, 417, 418, 1, 0, 0, 0, 418, 69, 1, 0, 0, 0, 419, 417, 1, 0, 0, 0, 420, 422, 5, 33, 0, 0, 421, 423,
-        3, 48, 24, 0, 422, 421, 1, 0, 0, 0, 422, 423, 1, 0, 0, 0, 423, 424, 1, 0, 0, 0, 424, 428, 5, 34,
-        0, 0, 425, 426, 5, 5, 0, 0, 426, 428, 5, 37, 0, 0, 427, 420, 1, 0, 0, 0, 427, 425, 1, 0, 0, 0, 428,
-        71, 1, 0, 0, 0, 429, 431, 5, 29, 0, 0, 430, 429, 1, 0, 0, 0, 430, 431, 1, 0, 0, 0, 431, 432, 1, 0,
-        0, 0, 432, 434, 5, 31, 0, 0, 433, 435, 3, 54, 27, 0, 434, 433, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0,
-        435, 73, 1, 0, 0, 0, 436, 437, 5, 22, 0, 0, 437, 438, 3, 54, 27, 0, 438, 75, 1, 0, 0, 0, 439, 440,
-        5, 11, 0, 0, 440, 441, 5, 12, 0, 0, 441, 442, 5, 1, 0, 0, 442, 443, 5, 45, 0, 0, 443, 446, 5, 47,
-        0, 0, 444, 447, 5, 45, 0, 0, 445, 447, 3, 82, 41, 0, 446, 444, 1, 0, 0, 0, 446, 445, 1, 0, 0, 0,
-        447, 448, 1, 0, 0, 0, 448, 446, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 450, 1, 0, 0, 0, 450, 451,
-        5, 48, 0, 0, 451, 77, 1, 0, 0, 0, 452, 453, 5, 11, 0, 0, 453, 454, 5, 13, 0, 0, 454, 455, 5, 1, 0,
-        0, 455, 456, 5, 45, 0, 0, 456, 459, 5, 47, 0, 0, 457, 460, 5, 45, 0, 0, 458, 460, 3, 80, 40, 0,
-        459, 457, 1, 0, 0, 0, 459, 458, 1, 0, 0, 0, 460, 461, 1, 0, 0, 0, 461, 459, 1, 0, 0, 0, 461, 462,
-        1, 0, 0, 0, 462, 463, 1, 0, 0, 0, 463, 464, 5, 48, 0, 0, 464, 79, 1, 0, 0, 0, 465, 466, 7, 9, 0, 0,
-        466, 472, 5, 1, 0, 0, 467, 473, 3, 48, 24, 0, 468, 469, 5, 33, 0, 0, 469, 470, 3, 48, 24, 0, 470,
-        471, 5, 34, 0, 0, 471, 473, 1, 0, 0, 0, 472, 467, 1, 0, 0, 0, 472, 468, 1, 0, 0, 0, 473, 81, 1, 0,
-        0, 0, 474, 475, 3, 84, 42, 0, 475, 476, 5, 1, 0, 0, 476, 477, 3, 86, 43, 0, 477, 83, 1, 0, 0, 0,
-        478, 479, 7, 10, 0, 0, 479, 85, 1, 0, 0, 0, 480, 481, 5, 45, 0, 0, 481, 484, 5, 47, 0, 0, 482, 485,
-        5, 45, 0, 0, 483, 485, 3, 82, 41, 0, 484, 482, 1, 0, 0, 0, 484, 483, 1, 0, 0, 0, 485, 486, 1, 0,
-        0, 0, 486, 484, 1, 0, 0, 0, 486, 487, 1, 0, 0, 0, 487, 488, 1, 0, 0, 0, 488, 498, 5, 48, 0, 0, 489,
-        494, 3, 54, 27, 0, 490, 491, 5, 2, 0, 0, 491, 493, 3, 54, 27, 0, 492, 490, 1, 0, 0, 0, 493, 496,
-        1, 0, 0, 0, 494, 492, 1, 0, 0, 0, 494, 495, 1, 0, 0, 0, 495, 498, 1, 0, 0, 0, 496, 494, 1, 0, 0, 0,
-        497, 480, 1, 0, 0, 0, 497, 489, 1, 0, 0, 0, 498, 87, 1, 0, 0, 0, 499, 500, 5, 6, 0, 0, 500, 501,
-        5, 38, 0, 0, 501, 502, 5, 7, 0, 0, 502, 89, 1, 0, 0, 0, 503, 504, 5, 14, 0, 0, 504, 508, 5, 37, 0,
-        0, 505, 507, 7, 1, 0, 0, 506, 505, 1, 0, 0, 0, 507, 510, 1, 0, 0, 0, 508, 506, 1, 0, 0, 0, 508, 509,
-        1, 0, 0, 0, 509, 91, 1, 0, 0, 0, 510, 508, 1, 0, 0, 0, 511, 512, 5, 19, 0, 0, 512, 513, 5, 37, 0,
-        0, 513, 93, 1, 0, 0, 0, 514, 515, 5, 24, 0, 0, 515, 516, 5, 37, 0, 0, 516, 95, 1, 0, 0, 0, 517, 518,
-        5, 8, 0, 0, 518, 519, 5, 1, 0, 0, 519, 520, 5, 45, 0, 0, 520, 523, 5, 47, 0, 0, 521, 524, 5, 45,
-        0, 0, 522, 524, 3, 2, 1, 0, 523, 521, 1, 0, 0, 0, 523, 522, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525,
-        523, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 526, 527, 1, 0, 0, 0, 527, 528, 5, 48, 0, 0, 528, 97, 1, 0,
-        0, 0, 64, 100, 102, 122, 127, 135, 137, 147, 149, 159, 162, 167, 171, 181, 184, 192, 196,
-        199, 209, 217, 219, 230, 241, 243, 249, 255, 259, 265, 267, 286, 293, 301, 304, 322, 329,
-        341, 343, 351, 355, 361, 369, 371, 377, 384, 393, 405, 408, 411, 417, 422, 427, 430, 434,
-        446, 448, 459, 461, 472, 484, 486, 494, 497, 508, 523, 525];
-    static __ATN;
-    static get _ATN() {
-        if (!CircuitScriptParser.__ATN) {
-            CircuitScriptParser.__ATN = new ATNDeserializer().deserialize(CircuitScriptParser._serializedATN);
-        }
-        return CircuitScriptParser.__ATN;
-    }
-    static DecisionsToDFA = CircuitScriptParser._ATN.decisionToState.map((ds, index) => new DFA(ds, index));
-}
-export class ScriptContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    EOF() {
-        return this.getToken(CircuitScriptParser.EOF, 0);
-    }
-    expression_list() {
-        return this.getTypedRuleContexts(ExpressionContext);
-    }
-    expression(i) {
-        return this.getTypedRuleContext(ExpressionContext, i);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_script;
-    }
-    accept(visitor) {
-        if (visitor.visitScript) {
-            return visitor.visitScript(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class ExpressionContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    add_component_expr() {
-        return this.getTypedRuleContext(Add_component_exprContext, 0);
-    }
-    to_component_expr() {
-        return this.getTypedRuleContext(To_component_exprContext, 0);
-    }
-    at_component_expr() {
-        return this.getTypedRuleContext(At_component_exprContext, 0);
-    }
-    assignment_expr() {
-        return this.getTypedRuleContext(Assignment_exprContext, 0);
-    }
-    property_set_expr() {
-        return this.getTypedRuleContext(Property_set_exprContext, 0);
-    }
-    property_set_expr2() {
-        return this.getTypedRuleContext(Property_set_expr2Context, 0);
-    }
-    double_dot_property_set_expr() {
-        return this.getTypedRuleContext(Double_dot_property_set_exprContext, 0);
-    }
-    break_keyword() {
-        return this.getTypedRuleContext(Break_keywordContext, 0);
-    }
-    function_def_expr() {
-        return this.getTypedRuleContext(Function_def_exprContext, 0);
-    }
-    wire_expr() {
-        return this.getTypedRuleContext(Wire_exprContext, 0);
-    }
-    import_expr() {
-        return this.getTypedRuleContext(Import_exprContext, 0);
-    }
-    frame_expr() {
-        return this.getTypedRuleContext(Frame_exprContext, 0);
-    }
-    atom_expr() {
-        return this.getTypedRuleContext(Atom_exprContext, 0);
-    }
-    at_block() {
-        return this.getTypedRuleContext(At_blockContext, 0);
-    }
-    path_blocks() {
-        return this.getTypedRuleContext(Path_blocksContext, 0);
-    }
-    point_expr() {
-        return this.getTypedRuleContext(Point_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_expression;
-    }
-    accept(visitor) {
-        if (visitor.visitExpression) {
-            return visitor.visitExpression(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Path_blocksContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    path_block_inner_list() {
-        return this.getTypedRuleContexts(Path_block_innerContext);
-    }
-    path_block_inner(i) {
-        return this.getTypedRuleContext(Path_block_innerContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_path_blocks;
-    }
-    accept(visitor) {
-        if (visitor.visitPath_blocks) {
-            return visitor.visitPath_blocks(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Path_block_innerContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    Branch() {
-        return this.getToken(CircuitScriptParser.Branch, 0);
-    }
-    Join() {
-        return this.getToken(CircuitScriptParser.Join, 0);
-    }
-    Parallel() {
-        return this.getToken(CircuitScriptParser.Parallel, 0);
-    }
-    Point() {
-        return this.getToken(CircuitScriptParser.Point, 0);
-    }
-    expression_list() {
-        return this.getTypedRuleContexts(ExpressionContext);
-    }
-    expression(i) {
-        return this.getTypedRuleContext(ExpressionContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_path_block_inner;
-    }
-    accept(visitor) {
-        if (visitor.visitPath_block_inner) {
-            return visitor.visitPath_block_inner(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Property_set_expr2Context extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    atom_expr() {
-        return this.getTypedRuleContext(Atom_exprContext, 0);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    assignment_expr2_list() {
-        return this.getTypedRuleContexts(Assignment_expr2Context);
-    }
-    assignment_expr2(i) {
-        return this.getTypedRuleContext(Assignment_expr2Context, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_property_set_expr2;
-    }
-    accept(visitor) {
-        if (visitor.visitProperty_set_expr2) {
-            return visitor.visitProperty_set_expr2(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Assignment_expr2Context extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    value_expr() {
-        return this.getTypedRuleContext(Value_exprContext, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_assignment_expr2;
-    }
-    accept(visitor) {
-        if (visitor.visitAssignment_expr2) {
-            return visitor.visitAssignment_expr2(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Data_expr_with_assignmentContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    assignment_expr() {
-        return this.getTypedRuleContext(Assignment_exprContext, 0);
-    }
-    pin_select_expr() {
-        return this.getTypedRuleContext(Pin_select_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_data_expr_with_assignment;
-    }
-    accept(visitor) {
-        if (visitor.visitData_expr_with_assignment) {
-            return visitor.visitData_expr_with_assignment(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Add_component_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Add() {
-        return this.getToken(CircuitScriptParser.Add, 0);
-    }
-    data_expr_with_assignment() {
-        return this.getTypedRuleContext(Data_expr_with_assignmentContext, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_add_component_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAdd_component_expr) {
-            return visitor.visitAdd_component_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Component_select_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    data_expr_with_assignment() {
-        return this.getTypedRuleContext(Data_expr_with_assignmentContext, 0);
-    }
-    pin_select_expr() {
-        return this.getTypedRuleContext(Pin_select_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_component_select_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitComponent_select_expr) {
-            return visitor.visitComponent_select_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Pin_select_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Pin() {
-        return this.getToken(CircuitScriptParser.Pin, 0);
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    STRING_VALUE() {
-        return this.getToken(CircuitScriptParser.STRING_VALUE, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_pin_select_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitPin_select_expr) {
-            return visitor.visitPin_select_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Pin_select_expr2Context extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    STRING_VALUE() {
-        return this.getToken(CircuitScriptParser.STRING_VALUE, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_pin_select_expr2;
-    }
-    accept(visitor) {
-        if (visitor.visitPin_select_expr2) {
-            return visitor.visitPin_select_expr2(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_component_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    At() {
-        return this.getToken(CircuitScriptParser.At, 0);
-    }
-    Point() {
-        return this.getToken(CircuitScriptParser.Point, 0);
-    }
-    component_select_expr() {
-        return this.getTypedRuleContext(Component_select_exprContext, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_component_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_component_expr) {
-            return visitor.visitAt_component_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class To_component_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    To() {
-        return this.getToken(CircuitScriptParser.To, 0);
-    }
-    Point() {
-        return this.getToken(CircuitScriptParser.Point, 0);
-    }
-    component_select_expr_list() {
-        return this.getTypedRuleContexts(Component_select_exprContext);
-    }
-    component_select_expr(i) {
-        return this.getTypedRuleContext(Component_select_exprContext, i);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_to_component_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitTo_component_expr) {
-            return visitor.visitTo_component_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_to_multiple_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    At() {
-        return this.getToken(CircuitScriptParser.At, 0);
-    }
-    component_select_expr_list() {
-        return this.getTypedRuleContexts(Component_select_exprContext);
-    }
-    component_select_expr(i) {
-        return this.getTypedRuleContext(Component_select_exprContext, i);
-    }
-    To() {
-        return this.getToken(CircuitScriptParser.To, 0);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    at_to_multiple_line_expr_list() {
-        return this.getTypedRuleContexts(At_to_multiple_line_exprContext);
-    }
-    at_to_multiple_line_expr(i) {
-        return this.getTypedRuleContext(At_to_multiple_line_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_to_multiple_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_to_multiple_expr) {
-            return visitor.visitAt_to_multiple_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_to_multiple_line_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    pin_select_expr2() {
-        return this.getTypedRuleContext(Pin_select_expr2Context, 0);
-    }
-    at_to_multiple_line_expr_to_pin_list() {
-        return this.getTypedRuleContexts(At_to_multiple_line_expr_to_pinContext);
-    }
-    at_to_multiple_line_expr_to_pin(i) {
-        return this.getTypedRuleContext(At_to_multiple_line_expr_to_pinContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_to_multiple_line_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_to_multiple_line_expr) {
-            return visitor.visitAt_to_multiple_line_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_to_multiple_line_expr_to_pinContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    NOT_CONNECTED() {
-        return this.getToken(CircuitScriptParser.NOT_CONNECTED, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_to_multiple_line_expr_to_pin;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_to_multiple_line_expr_to_pin) {
-            return visitor.visitAt_to_multiple_line_expr_to_pin(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_blockContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    at_component_expr() {
-        return this.getTypedRuleContext(At_component_exprContext, 0);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    at_block_expressions_list() {
-        return this.getTypedRuleContexts(At_block_expressionsContext);
-    }
-    at_block_expressions(i) {
-        return this.getTypedRuleContext(At_block_expressionsContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_block;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_block) {
-            return visitor.visitAt_block(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_block_expressionsContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    expression() {
-        return this.getTypedRuleContext(ExpressionContext, 0);
-    }
-    at_block_pin_expr() {
-        return this.getTypedRuleContext(At_block_pin_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_block_expressions;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_block_expressions) {
-            return visitor.visitAt_block_expressions(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_block_pin_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    pin_select_expr2() {
-        return this.getTypedRuleContext(Pin_select_expr2Context, 0);
-    }
-    at_block_pin_expression_simple() {
-        return this.getTypedRuleContext(At_block_pin_expression_simpleContext, 0);
-    }
-    at_block_pin_expression_complex() {
-        return this.getTypedRuleContext(At_block_pin_expression_complexContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_block_pin_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_block_pin_expr) {
-            return visitor.visitAt_block_pin_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_block_pin_expression_simpleContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    expression() {
-        return this.getTypedRuleContext(ExpressionContext, 0);
-    }
-    NOT_CONNECTED() {
-        return this.getToken(CircuitScriptParser.NOT_CONNECTED, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_block_pin_expression_simple;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_block_pin_expression_simple) {
-            return visitor.visitAt_block_pin_expression_simple(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class At_block_pin_expression_complexContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    expression_list() {
-        return this.getTypedRuleContexts(ExpressionContext);
-    }
-    expression(i) {
-        return this.getTypedRuleContext(ExpressionContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_at_block_pin_expression_complex;
-    }
-    accept(visitor) {
-        if (visitor.visitAt_block_pin_expression_complex) {
-            return visitor.visitAt_block_pin_expression_complex(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Break_keywordContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Break() {
-        return this.getToken(CircuitScriptParser.Break, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_break_keyword;
-    }
-    accept(visitor) {
-        if (visitor.visitBreak_keyword) {
-            return visitor.visitBreak_keyword(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Assignment_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    atom_expr() {
-        return this.getTypedRuleContext(Atom_exprContext, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_assignment_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAssignment_expr) {
-            return visitor.visitAssignment_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Keyword_assignment_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_keyword_assignment_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitKeyword_assignment_expr) {
-            return visitor.visitKeyword_assignment_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class ParametersContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    data_expr_list() {
-        return this.getTypedRuleContexts(Data_exprContext);
-    }
-    data_expr(i) {
-        return this.getTypedRuleContext(Data_exprContext, i);
-    }
-    keyword_assignment_expr_list() {
-        return this.getTypedRuleContexts(Keyword_assignment_exprContext);
-    }
-    keyword_assignment_expr(i) {
-        return this.getTypedRuleContext(Keyword_assignment_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_parameters;
-    }
-    accept(visitor) {
-        if (visitor.visitParameters) {
-            return visitor.visitParameters(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Property_set_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    atom_expr() {
-        return this.getTypedRuleContext(Atom_exprContext, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_property_set_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitProperty_set_expr) {
-            return visitor.visitProperty_set_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Double_dot_property_set_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_double_dot_property_set_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitDouble_dot_property_set_expr) {
-            return visitor.visitDouble_dot_property_set_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Data_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_data_expr;
-    }
-    copyFrom(ctx) {
-        super.copyFrom(ctx);
-    }
-}
-export class AdditionExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    data_expr_list() {
-        return this.getTypedRuleContexts(Data_exprContext);
-    }
-    data_expr(i) {
-        return this.getTypedRuleContext(Data_exprContext, i);
-    }
-    Addition() {
-        return this.getToken(CircuitScriptParser.Addition, 0);
-    }
-    Minus() {
-        return this.getToken(CircuitScriptParser.Minus, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitAdditionExpr) {
-            return visitor.visitAdditionExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class MultiplyExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    data_expr_list() {
-        return this.getTypedRuleContexts(Data_exprContext);
-    }
-    data_expr(i) {
-        return this.getTypedRuleContext(Data_exprContext, i);
-    }
-    Multiply() {
-        return this.getToken(CircuitScriptParser.Multiply, 0);
-    }
-    Divide() {
-        return this.getToken(CircuitScriptParser.Divide, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitMultiplyExpr) {
-            return visitor.visitMultiplyExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class DataExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    create_component_expr() {
-        return this.getTypedRuleContext(Create_component_exprContext, 0);
-    }
-    create_graphic_expr() {
-        return this.getTypedRuleContext(Create_graphic_exprContext, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitDataExpr) {
-            return visitor.visitDataExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class UnaryOperatorExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    unary_operator() {
-        return this.getTypedRuleContext(Unary_operatorContext, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitUnaryOperatorExpr) {
-            return visitor.visitUnaryOperatorExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class ValueAtomExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    value_expr() {
-        return this.getTypedRuleContext(Value_exprContext, 0);
-    }
-    atom_expr() {
-        return this.getTypedRuleContext(Atom_exprContext, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitValueAtomExpr) {
-            return visitor.visitValueAtomExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class BinaryOperatorExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    data_expr_list() {
-        return this.getTypedRuleContexts(Data_exprContext);
-    }
-    data_expr(i) {
-        return this.getTypedRuleContext(Data_exprContext, i);
-    }
-    binary_operator() {
-        return this.getTypedRuleContext(Binary_operatorContext, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitBinaryOperatorExpr) {
-            return visitor.visitBinaryOperatorExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class RoundedBracketsExprContext extends Data_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    OPEN_PAREN() {
-        return this.getToken(CircuitScriptParser.OPEN_PAREN, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    CLOSE_PAREN() {
-        return this.getToken(CircuitScriptParser.CLOSE_PAREN, 0);
-    }
-    accept(visitor) {
-        if (visitor.visitRoundedBracketsExpr) {
-            return visitor.visitRoundedBracketsExpr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Binary_operatorContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Equals() {
-        return this.getToken(CircuitScriptParser.Equals, 0);
-    }
-    NotEquals() {
-        return this.getToken(CircuitScriptParser.NotEquals, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_binary_operator;
-    }
-    accept(visitor) {
-        if (visitor.visitBinary_operator) {
-            return visitor.visitBinary_operator(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Unary_operatorContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Not() {
-        return this.getToken(CircuitScriptParser.Not, 0);
-    }
-    Minus() {
-        return this.getToken(CircuitScriptParser.Minus, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_unary_operator;
-    }
-    accept(visitor) {
-        if (visitor.visitUnary_operator) {
-            return visitor.visitUnary_operator(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Value_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    NUMERIC_VALUE() {
-        return this.getToken(CircuitScriptParser.NUMERIC_VALUE, 0);
-    }
-    DECIMAL_VALUE() {
-        return this.getToken(CircuitScriptParser.DECIMAL_VALUE, 0);
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    STRING_VALUE() {
-        return this.getToken(CircuitScriptParser.STRING_VALUE, 0);
-    }
-    PERCENTAGE_VALUE() {
-        return this.getToken(CircuitScriptParser.PERCENTAGE_VALUE, 0);
-    }
-    BOOLEAN_VALUE() {
-        return this.getToken(CircuitScriptParser.BOOLEAN_VALUE, 0);
-    }
-    Minus() {
-        return this.getToken(CircuitScriptParser.Minus, 0);
-    }
-    blank_expr() {
-        return this.getTypedRuleContext(Blank_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_value_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitValue_expr) {
-            return visitor.visitValue_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Function_def_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Define() {
-        return this.getToken(CircuitScriptParser.Define, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    OPEN_PAREN() {
-        return this.getToken(CircuitScriptParser.OPEN_PAREN, 0);
-    }
-    CLOSE_PAREN() {
-        return this.getToken(CircuitScriptParser.CLOSE_PAREN, 0);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    function_args_expr() {
-        return this.getTypedRuleContext(Function_args_exprContext, 0);
-    }
-    function_expr_list() {
-        return this.getTypedRuleContexts(Function_exprContext);
-    }
-    function_expr(i) {
-        return this.getTypedRuleContext(Function_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_function_def_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitFunction_def_expr) {
-            return visitor.visitFunction_def_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Function_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    expression() {
-        return this.getTypedRuleContext(ExpressionContext, 0);
-    }
-    function_return_expr() {
-        return this.getTypedRuleContext(Function_return_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_function_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitFunction_expr) {
-            return visitor.visitFunction_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Function_args_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    ID_list() {
-        return this.getTokens(CircuitScriptParser.ID);
-    }
-    ID(i) {
-        return this.getToken(CircuitScriptParser.ID, i);
-    }
-    value_expr_list() {
-        return this.getTypedRuleContexts(Value_exprContext);
-    }
-    value_expr(i) {
-        return this.getTypedRuleContext(Value_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_function_args_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitFunction_args_expr) {
-            return visitor.visitFunction_args_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Atom_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    net_namespace_expr() {
-        return this.getTypedRuleContext(Net_namespace_exprContext, 0);
-    }
-    trailer_expr_list() {
-        return this.getTypedRuleContexts(Trailer_exprContext);
-    }
-    trailer_expr(i) {
-        return this.getTypedRuleContext(Trailer_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_atom_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitAtom_expr) {
-            return visitor.visitAtom_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Trailer_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    OPEN_PAREN() {
-        return this.getToken(CircuitScriptParser.OPEN_PAREN, 0);
-    }
-    CLOSE_PAREN() {
-        return this.getToken(CircuitScriptParser.CLOSE_PAREN, 0);
-    }
-    parameters() {
-        return this.getTypedRuleContext(ParametersContext, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_trailer_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitTrailer_expr) {
-            return visitor.visitTrailer_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Net_namespace_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Divide() {
-        return this.getToken(CircuitScriptParser.Divide, 0);
-    }
-    Addition() {
-        return this.getToken(CircuitScriptParser.Addition, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_net_namespace_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitNet_namespace_expr) {
-            return visitor.visitNet_namespace_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Function_return_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Return() {
-        return this.getToken(CircuitScriptParser.Return, 0);
-    }
-    data_expr() {
-        return this.getTypedRuleContext(Data_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_function_return_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitFunction_return_expr) {
-            return visitor.visitFunction_return_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Create_component_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Create() {
-        return this.getToken(CircuitScriptParser.Create, 0);
-    }
-    Component() {
-        return this.getToken(CircuitScriptParser.Component, 0);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    property_expr_list() {
-        return this.getTypedRuleContexts(Property_exprContext);
-    }
-    property_expr(i) {
-        return this.getTypedRuleContext(Property_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_create_component_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitCreate_component_expr) {
-            return visitor.visitCreate_component_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Create_graphic_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Create() {
-        return this.getToken(CircuitScriptParser.Create, 0);
-    }
-    Graphic() {
-        return this.getToken(CircuitScriptParser.Graphic, 0);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    sub_expr_list() {
-        return this.getTypedRuleContexts(Sub_exprContext);
-    }
-    sub_expr(i) {
-        return this.getTypedRuleContext(Sub_exprContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_create_graphic_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitCreate_graphic_expr) {
-            return visitor.visitCreate_graphic_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Sub_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    Pin() {
-        return this.getToken(CircuitScriptParser.Pin, 0);
-    }
-    parameters() {
-        return this.getTypedRuleContext(ParametersContext, 0);
-    }
-    OPEN_PAREN() {
-        return this.getToken(CircuitScriptParser.OPEN_PAREN, 0);
-    }
-    CLOSE_PAREN() {
-        return this.getToken(CircuitScriptParser.CLOSE_PAREN, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_sub_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitSub_expr) {
-            return visitor.visitSub_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Property_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    property_key_expr() {
-        return this.getTypedRuleContext(Property_key_exprContext, 0);
-    }
-    property_value_expr() {
-        return this.getTypedRuleContext(Property_value_exprContext, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_property_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitProperty_expr) {
-            return visitor.visitProperty_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Property_key_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    STRING_VALUE() {
-        return this.getToken(CircuitScriptParser.STRING_VALUE, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_property_key_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitProperty_key_expr) {
-            return visitor.visitProperty_key_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Property_value_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_property_value_expr;
-    }
-    copyFrom(ctx) {
-        super.copyFrom(ctx);
-    }
-}
-export class Single_line_propertyContext extends Property_value_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    data_expr_list() {
-        return this.getTypedRuleContexts(Data_exprContext);
-    }
-    data_expr(i) {
-        return this.getTypedRuleContext(Data_exprContext, i);
-    }
-    accept(visitor) {
-        if (visitor.visitSingle_line_property) {
-            return visitor.visitSingle_line_property(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Nested_propertiesContext extends Property_value_exprContext {
-    constructor(parser, ctx) {
-        super(parser, ctx.parentCtx, ctx.invokingState);
-        super.copyFrom(ctx);
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    property_expr_list() {
-        return this.getTypedRuleContexts(Property_exprContext);
-    }
-    property_expr(i) {
-        return this.getTypedRuleContext(Property_exprContext, i);
-    }
-    accept(visitor) {
-        if (visitor.visitNested_properties) {
-            return visitor.visitNested_properties(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Blank_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    INTEGER_VALUE() {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_blank_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitBlank_expr) {
-            return visitor.visitBlank_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Wire_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Wire() {
-        return this.getToken(CircuitScriptParser.Wire, 0);
-    }
-    ID_list() {
-        return this.getTokens(CircuitScriptParser.ID);
-    }
-    ID(i) {
-        return this.getToken(CircuitScriptParser.ID, i);
-    }
-    INTEGER_VALUE_list() {
-        return this.getTokens(CircuitScriptParser.INTEGER_VALUE);
-    }
-    INTEGER_VALUE(i) {
-        return this.getToken(CircuitScriptParser.INTEGER_VALUE, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_wire_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitWire_expr) {
-            return visitor.visitWire_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Point_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Point() {
-        return this.getToken(CircuitScriptParser.Point, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_point_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitPoint_expr) {
-            return visitor.visitPoint_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Import_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    Import() {
-        return this.getToken(CircuitScriptParser.Import, 0);
-    }
-    ID() {
-        return this.getToken(CircuitScriptParser.ID, 0);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_import_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitImport_expr) {
-            return visitor.visitImport_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}
-export class Frame_exprContext extends ParserRuleContext {
-    constructor(parser, parent, invokingState) {
-        super(parent, invokingState);
-        this.parser = parser;
-    }
-    NEWLINE_list() {
-        return this.getTokens(CircuitScriptParser.NEWLINE);
-    }
-    NEWLINE(i) {
-        return this.getToken(CircuitScriptParser.NEWLINE, i);
-    }
-    INDENT() {
-        return this.getToken(CircuitScriptParser.INDENT, 0);
-    }
-    DEDENT() {
-        return this.getToken(CircuitScriptParser.DEDENT, 0);
-    }
-    expression_list() {
-        return this.getTypedRuleContexts(ExpressionContext);
-    }
-    expression(i) {
-        return this.getTypedRuleContext(ExpressionContext, i);
-    }
-    get ruleIndex() {
-        return CircuitScriptParser.RULE_frame_expr;
-    }
-    accept(visitor) {
-        if (visitor.visitFrame_expr) {
-            return visitor.visitFrame_expr(this);
-        }
-        else {
-            return visitor.visitChildren(this);
-        }
-    }
-}