Source code for pyfcstm.dsl.grammar.GrammarParser

# Generated from ./pyfcstm/dsl/grammar/Grammar.g4 by ANTLR 4.9.3
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys

if sys.version_info[1] > 5:
    from typing import TextIO
else:
    from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3D")
        buf.write("\u023a\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\3\2\3\2\3\2\3\3\7")
        buf.write("\3=\n\3\f\3\16\3@\13\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4")
        buf.write("\3\4\3\4\3\5\5\5M\n\5\3\5\3\5\3\5\3\5\5\5S\n\5\3\5\3\5")
        buf.write("\3\5\3\5\7\5Y\n\5\f\5\16\5\\\13\5\3\5\5\5_\n\5\3\6\3\6")
        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6m\n\6\3\6")
        buf.write("\3\6\3\6\3\6\7\6s\n\6\f\6\16\6v\13\6\3\6\5\6y\n\6\3\6")
        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5")
        buf.write("\6\u0089\n\6\3\6\3\6\3\6\3\6\7\6\u008f\n\6\f\6\16\6\u0092")
        buf.write("\13\6\3\6\5\6\u0095\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
        buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00a5\n\6\3\6\3\6\3\6\3")
        buf.write("\6\7\6\u00ab\n\6\f\6\16\6\u00ae\13\6\3\6\5\6\u00b1\n\6")
        buf.write("\5\6\u00b3\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\5\7\u00c4\n\7\3\7\3\7\3\7\3\7\3\7")
        buf.write("\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u00d6")
        buf.write("\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\5\7\u00e6\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\3\7\5\7\u00f6\n\7\3\7\5\7\u00f9\n\7")
        buf.write("\3\b\3\b\5\b\u00fd\n\b\3\b\3\b\7\b\u0101\n\b\f\b\16\b")
        buf.write("\u0104\13\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u010e")
        buf.write("\n\b\3\b\5\b\u0111\n\b\3\t\3\t\5\t\u0115\n\t\3\t\3\t\7")
        buf.write("\t\u0119\n\t\f\t\16\t\u011c\13\t\3\t\3\t\3\t\3\t\3\t\3")
        buf.write("\t\3\t\3\t\5\t\u0126\n\t\3\t\5\t\u0129\n\t\3\n\3\n\5\n")
        buf.write("\u012d\n\n\3\n\5\n\u0130\n\n\3\n\3\n\7\n\u0134\n\n\f\n")
        buf.write("\16\n\u0137\13\n\3\n\3\n\3\n\5\n\u013c\n\n\3\n\3\n\3\n")
        buf.write("\3\n\3\n\5\n\u0143\n\n\3\n\3\n\5\n\u0147\n\n\3\n\5\n\u014a")
        buf.write("\n\n\3\13\3\13\3\13\3\13\5\13\u0150\n\13\3\13\3\13\7\13")
        buf.write("\u0154\n\13\f\13\16\13\u0157\13\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u0165\n")
        buf.write("\13\3\13\5\13\u0168\n\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\5")
        buf.write("\r\u0171\n\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5")
        buf.write("\16\u017b\n\16\3\17\7\17\u017e\n\17\f\17\16\17\u0181\13")
        buf.write("\17\3\17\3\17\3\20\7\20\u0186\n\20\f\20\16\20\u0189\13")
        buf.write("\20\3\20\3\20\3\21\3\21\5\21\u018f\n\21\3\22\3\22\3\22")
        buf.write("\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24")
        buf.write("\3\24\3\25\3\25\5\25\u01a2\n\25\3\26\3\26\3\26\3\26\3")
        buf.write("\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26")
        buf.write("\u01b2\n\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3")
        buf.write("\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26")
        buf.write("\3\26\3\26\7\26\u01c9\n\26\f\26\16\26\u01cc\13\26\3\27")
        buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27")
        buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27")
        buf.write("\5\27\u01e5\n\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3")
        buf.write("\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27")
        buf.write("\3\27\3\27\3\27\7\27\u01fc\n\27\f\27\16\27\u01ff\13\27")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
        buf.write("\3\30\3\30\5\30\u0219\n\30\3\30\3\30\3\30\3\30\3\30\3")
        buf.write("\30\3\30\3\30\3\30\7\30\u0224\n\30\f\30\16\30\u0227\13")
        buf.write("\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34\5\34\u0230\n\34")
        buf.write("\3\34\3\34\3\34\7\34\u0235\n\34\f\34\16\34\u0238\13\34")
        buf.write("\3\34\2\5*,.\35\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
        buf.write(' "$&(*,.\60\62\64\66\2\20\3\2\4\5\3\2\16\17\3\2\32\33')
        buf.write("\3\2 !\4\2\25\25#$\4\2\34\34%%\4\2\24\24**\3\2+.\3\2/")
        buf.write("\60\3\2\61\62\3\2\63\64\3\29;\3\2<=\3\2\65\67\2\u0285")
        buf.write("\28\3\2\2\2\4>\3\2\2\2\6D\3\2\2\2\b^\3\2\2\2\n\u00b2\3")
        buf.write("\2\2\2\f\u00f8\3\2\2\2\16\u0110\3\2\2\2\20\u0128\3\2\2")
        buf.write("\2\22\u0149\3\2\2\2\24\u0167\3\2\2\2\26\u0169\3\2\2\2")
        buf.write("\30\u0170\3\2\2\2\32\u017a\3\2\2\2\34\u017f\3\2\2\2\36")
        buf.write('\u0187\3\2\2\2 \u018e\3\2\2\2"\u0190\3\2\2\2$\u0195\3')
        buf.write("\2\2\2&\u019a\3\2\2\2(\u01a1\3\2\2\2*\u01b1\3\2\2\2,\u01e4")
        buf.write("\3\2\2\2.\u0218\3\2\2\2\60\u0228\3\2\2\2\62\u022a\3\2")
        buf.write("\2\2\64\u022c\3\2\2\2\66\u022f\3\2\2\289\5.\30\29:\7\2")
        buf.write("\2\3:\3\3\2\2\2;=\5\6\4\2<;\3\2\2\2=@\3\2\2\2><\3\2\2")
        buf.write("\2>?\3\2\2\2?A\3\2\2\2@>\3\2\2\2AB\5\b\5\2BC\7\2\2\3C")
        buf.write("\5\3\2\2\2DE\7\3\2\2EF\t\2\2\2FG\7?\2\2GH\7\6\2\2HI\5")
        buf.write("*\26\2IJ\7\7\2\2J\7\3\2\2\2KM\7\b\2\2LK\3\2\2\2LM\3\2")
        buf.write("\2\2MN\3\2\2\2NO\7\t\2\2OP\7?\2\2P_\7\7\2\2QS\7\b\2\2")
        buf.write("RQ\3\2\2\2RS\3\2\2\2ST\3\2\2\2TU\7\t\2\2UV\7?\2\2VZ\7")
        buf.write("\n\2\2WY\5\32\16\2XW\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3")
        buf.write("\2\2\2[]\3\2\2\2\\Z\3\2\2\2]_\7\13\2\2^L\3\2\2\2^R\3\2")
        buf.write("\2\2_\t\3\2\2\2`a\7\f\2\2ab\7\r\2\2bl\7?\2\2cm\3\2\2\2")
        buf.write("de\t\3\2\2em\5\66\34\2fg\7\16\2\2gh\7\20\2\2hi\7\21\2")
        buf.write("\2ij\5.\30\2jk\7\22\2\2km\3\2\2\2lc\3\2\2\2ld\3\2\2\2")
        buf.write("lf\3\2\2\2mx\3\2\2\2ny\7\7\2\2op\7\23\2\2pt\7\n\2\2qs")
        buf.write("\5\30\r\2rq\3\2\2\2sv\3\2\2\2tr\3\2\2\2tu\3\2\2\2uw\3")
        buf.write("\2\2\2vt\3\2\2\2wy\7\13\2\2xn\3\2\2\2xo\3\2\2\2y\u00b3")
        buf.write("\3\2\2\2z{\7?\2\2{|\7\r\2\2|\u0088\7?\2\2}\u0089\3\2\2")
        buf.write("\2~\177\7\17\2\2\177\u0089\7?\2\2\u0080\u0081\7\16\2\2")
        buf.write("\u0081\u0089\5\66\34\2\u0082\u0083\7\16\2\2\u0083\u0084")
        buf.write("\7\20\2\2\u0084\u0085\7\21\2\2\u0085\u0086\5.\30\2\u0086")
        buf.write("\u0087\7\22\2\2\u0087\u0089\3\2\2\2\u0088}\3\2\2\2\u0088")
        buf.write("~\3\2\2\2\u0088\u0080\3\2\2\2\u0088\u0082\3\2\2\2\u0089")
        buf.write("\u0094\3\2\2\2\u008a\u0095\7\7\2\2\u008b\u008c\7\23\2")
        buf.write("\2\u008c\u0090\7\n\2\2\u008d\u008f\5\30\r\2\u008e\u008d")
        buf.write("\3\2\2\2\u008f\u0092\3\2\2\2\u0090\u008e\3\2\2\2\u0090")
        buf.write("\u0091\3\2\2\2\u0091\u0093\3\2\2\2\u0092\u0090\3\2\2\2")
        buf.write("\u0093\u0095\7\13\2\2\u0094\u008a\3\2\2\2\u0094\u008b")
        buf.write("\3\2\2\2\u0095\u00b3\3\2\2\2\u0096\u0097\7?\2\2\u0097")
        buf.write("\u0098\7\r\2\2\u0098\u00a4\7\f\2\2\u0099\u00a5\3\2\2\2")
        buf.write("\u009a\u009b\7\17\2\2\u009b\u00a5\7?\2\2\u009c\u009d\7")
        buf.write("\16\2\2\u009d\u00a5\5\66\34\2\u009e\u009f\7\16\2\2\u009f")
        buf.write("\u00a0\7\20\2\2\u00a0\u00a1\7\21\2\2\u00a1\u00a2\5.\30")
        buf.write("\2\u00a2\u00a3\7\22\2\2\u00a3\u00a5\3\2\2\2\u00a4\u0099")
        buf.write("\3\2\2\2\u00a4\u009a\3\2\2\2\u00a4\u009c\3\2\2\2\u00a4")
        buf.write("\u009e\3\2\2\2\u00a5\u00b0\3\2\2\2\u00a6\u00b1\7\7\2\2")
        buf.write("\u00a7\u00a8\7\23\2\2\u00a8\u00ac\7\n\2\2\u00a9\u00ab")
        buf.write("\5\30\r\2\u00aa\u00a9\3\2\2\2\u00ab\u00ae\3\2\2\2\u00ac")
        buf.write("\u00aa\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00af\3\2\2\2")
        buf.write("\u00ae\u00ac\3\2\2\2\u00af\u00b1\7\13\2\2\u00b0\u00a6")
        buf.write("\3\2\2\2\u00b0\u00a7\3\2\2\2\u00b1\u00b3\3\2\2\2\u00b2")
        buf.write("`\3\2\2\2\u00b2z\3\2\2\2\u00b2\u0096\3\2\2\2\u00b3\13")
        buf.write("\3\2\2\2\u00b4\u00b5\7\24\2\2\u00b5\u00b6\7?\2\2\u00b6")
        buf.write("\u00b7\7\r\2\2\u00b7\u00c3\7?\2\2\u00b8\u00c4\3\2\2\2")
        buf.write("\u00b9\u00ba\7\17\2\2\u00ba\u00c4\7?\2\2\u00bb\u00bc\7")
        buf.write("\16\2\2\u00bc\u00c4\5\66\34\2\u00bd\u00be\7\16\2\2\u00be")
        buf.write("\u00bf\7\20\2\2\u00bf\u00c0\7\21\2\2\u00c0\u00c1\5.\30")
        buf.write("\2\u00c1\u00c2\7\22\2\2\u00c2\u00c4\3\2\2\2\u00c3\u00b8")
        buf.write("\3\2\2\2\u00c3\u00b9\3\2\2\2\u00c3\u00bb\3\2\2\2\u00c3")
        buf.write("\u00bd\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00f9\7\7\2\2")
        buf.write("\u00c6\u00c7\7\24\2\2\u00c7\u00c8\7?\2\2\u00c8\u00c9\7")
        buf.write("\r\2\2\u00c9\u00d5\7\f\2\2\u00ca\u00d6\3\2\2\2\u00cb\u00cc")
        buf.write("\7\17\2\2\u00cc\u00d6\7?\2\2\u00cd\u00ce\7\16\2\2\u00ce")
        buf.write("\u00d6\5\66\34\2\u00cf\u00d0\7\16\2\2\u00d0\u00d1\7\20")
        buf.write("\2\2\u00d1\u00d2\7\21\2\2\u00d2\u00d3\5.\30\2\u00d3\u00d4")
        buf.write("\7\22\2\2\u00d4\u00d6\3\2\2\2\u00d5\u00ca\3\2\2\2\u00d5")
        buf.write("\u00cb\3\2\2\2\u00d5\u00cd\3\2\2\2\u00d5\u00cf\3\2\2\2")
        buf.write("\u00d6\u00d7\3\2\2\2\u00d7\u00f9\7\7\2\2\u00d8\u00d9\7")
        buf.write("\24\2\2\u00d9\u00da\7\25\2\2\u00da\u00db\7\r\2\2\u00db")
        buf.write("\u00e5\7?\2\2\u00dc\u00e6\3\2\2\2\u00dd\u00de\t\3\2\2")
        buf.write("\u00de\u00e6\5\66\34\2\u00df\u00e0\7\16\2\2\u00e0\u00e1")
        buf.write("\7\20\2\2\u00e1\u00e2\7\21\2\2\u00e2\u00e3\5.\30\2\u00e3")
        buf.write("\u00e4\7\22\2\2\u00e4\u00e6\3\2\2\2\u00e5\u00dc\3\2\2")
        buf.write("\2\u00e5\u00dd\3\2\2\2\u00e5\u00df\3\2\2\2\u00e6\u00e7")
        buf.write("\3\2\2\2\u00e7\u00f9\7\7\2\2\u00e8\u00e9\7\24\2\2\u00e9")
        buf.write("\u00ea\7\25\2\2\u00ea\u00eb\7\r\2\2\u00eb\u00f5\7\f\2")
        buf.write("\2\u00ec\u00f6\3\2\2\2\u00ed\u00ee\t\3\2\2\u00ee\u00f6")
        buf.write("\5\66\34\2\u00ef\u00f0\7\16\2\2\u00f0\u00f1\7\20\2\2\u00f1")
        buf.write("\u00f2\7\21\2\2\u00f2\u00f3\5.\30\2\u00f3\u00f4\7\22\2")
        buf.write("\2\u00f4\u00f6\3\2\2\2\u00f5\u00ec\3\2\2\2\u00f5\u00ed")
        buf.write("\3\2\2\2\u00f5\u00ef\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7")
        buf.write("\u00f9\7\7\2\2\u00f8\u00b4\3\2\2\2\u00f8\u00c6\3\2\2\2")
        buf.write("\u00f8\u00d8\3\2\2\2\u00f8\u00e8\3\2\2\2\u00f9\r\3\2\2")
        buf.write("\2\u00fa\u00fc\7\26\2\2\u00fb\u00fd\7?\2\2\u00fc\u00fb")
        buf.write("\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe")
        buf.write("\u0102\7\n\2\2\u00ff\u0101\5\30\r\2\u0100\u00ff\3\2\2")
        buf.write("\2\u0101\u0104\3\2\2\2\u0102\u0100\3\2\2\2\u0102\u0103")
        buf.write("\3\2\2\2\u0103\u0105\3\2\2\2\u0104\u0102\3\2\2\2\u0105")
        buf.write("\u0111\7\13\2\2\u0106\u0107\7\26\2\2\u0107\u0108\7\27")
        buf.write("\2\2\u0108\u0109\7?\2\2\u0109\u0111\7\7\2\2\u010a\u010b")
        buf.write("\7\26\2\2\u010b\u010d\7\27\2\2\u010c\u010e\7?\2\2\u010d")
        buf.write("\u010c\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u010f\3\2\2\2")
        buf.write("\u010f\u0111\7B\2\2\u0110\u00fa\3\2\2\2\u0110\u0106\3")
        buf.write("\2\2\2\u0110\u010a\3\2\2\2\u0111\17\3\2\2\2\u0112\u0114")
        buf.write("\7\30\2\2\u0113\u0115\7?\2\2\u0114\u0113\3\2\2\2\u0114")
        buf.write("\u0115\3\2\2\2\u0115\u0116\3\2\2\2\u0116\u011a\7\n\2\2")
        buf.write("\u0117\u0119\5\30\r\2\u0118\u0117\3\2\2\2\u0119\u011c")
        buf.write("\3\2\2\2\u011a\u0118\3\2\2\2\u011a\u011b\3\2\2\2\u011b")
        buf.write("\u011d\3\2\2\2\u011c\u011a\3\2\2\2\u011d\u0129\7\13\2")
        buf.write("\2\u011e\u011f\7\30\2\2\u011f\u0120\7\27\2\2\u0120\u0121")
        buf.write("\7?\2\2\u0121\u0129\7\7\2\2\u0122\u0123\7\30\2\2\u0123")
        buf.write("\u0125\7\27\2\2\u0124\u0126\7?\2\2\u0125\u0124\3\2\2\2")
        buf.write("\u0125\u0126\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u0129\7")
        buf.write("B\2\2\u0128\u0112\3\2\2\2\u0128\u011e\3\2\2\2\u0128\u0122")
        buf.write("\3\2\2\2\u0129\21\3\2\2\2\u012a\u012c\7\31\2\2\u012b\u012d")
        buf.write("\t\4\2\2\u012c\u012b\3\2\2\2\u012c\u012d\3\2\2\2\u012d")
        buf.write("\u012f\3\2\2\2\u012e\u0130\7?\2\2\u012f\u012e\3\2\2\2")
        buf.write("\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0135\7")
        buf.write("\n\2\2\u0132\u0134\5\30\r\2\u0133\u0132\3\2\2\2\u0134")
        buf.write("\u0137\3\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2")
        buf.write("\u0136\u0138\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u014a\7")
        buf.write("\13\2\2\u0139\u013b\7\31\2\2\u013a\u013c\t\4\2\2\u013b")
        buf.write("\u013a\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013d\3\2\2\2")
        buf.write("\u013d\u013e\7\27\2\2\u013e\u013f\7?\2\2\u013f\u014a\7")
        buf.write("\7\2\2\u0140\u0142\7\31\2\2\u0141\u0143\t\4\2\2\u0142")
        buf.write("\u0141\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0144\3\2\2\2")
        buf.write("\u0144\u0146\7\27\2\2\u0145\u0147\7?\2\2\u0146\u0145\3")
        buf.write("\2\2\2\u0146\u0147\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a")
        buf.write("\7B\2\2\u0149\u012a\3\2\2\2\u0149\u0139\3\2\2\2\u0149")
        buf.write("\u0140\3\2\2\2\u014a\23\3\2\2\2\u014b\u014c\7\34\2\2\u014c")
        buf.write("\u014d\7\31\2\2\u014d\u014f\t\4\2\2\u014e\u0150\7?\2\2")
        buf.write("\u014f\u014e\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151\3")
        buf.write("\2\2\2\u0151\u0155\7\n\2\2\u0152\u0154\5\30\r\2\u0153")
        buf.write("\u0152\3\2\2\2\u0154\u0157\3\2\2\2\u0155\u0153\3\2\2\2")
        buf.write("\u0155\u0156\3\2\2\2\u0156\u0158\3\2\2\2\u0157\u0155\3")
        buf.write("\2\2\2\u0158\u0168\7\13\2\2\u0159\u015a\7\34\2\2\u015a")
        buf.write("\u015b\7\31\2\2\u015b\u015c\t\4\2\2\u015c\u015d\7\27\2")
        buf.write("\2\u015d\u015e\7?\2\2\u015e\u0168\7\7\2\2\u015f\u0160")
        buf.write("\7\34\2\2\u0160\u0161\7\31\2\2\u0161\u0162\t\4\2\2\u0162")
        buf.write("\u0164\7\27\2\2\u0163\u0165\7?\2\2\u0164\u0163\3\2\2\2")
        buf.write("\u0164\u0165\3\2\2\2\u0165\u0166\3\2\2\2\u0166\u0168\7")
        buf.write("B\2\2\u0167\u014b\3\2\2\2\u0167\u0159\3\2\2\2\u0167\u015f")
        buf.write("\3\2\2\2\u0168\25\3\2\2\2\u0169\u016a\7?\2\2\u016a\u016b")
        buf.write("\7\6\2\2\u016b\u016c\5,\27\2\u016c\u016d\7\7\2\2\u016d")
        buf.write("\27\3\2\2\2\u016e\u0171\5\26\f\2\u016f\u0171\7\7\2\2\u0170")
        buf.write("\u016e\3\2\2\2\u0170\u016f\3\2\2\2\u0171\31\3\2\2\2\u0172")
        buf.write("\u017b\5\b\5\2\u0173\u017b\5\n\6\2\u0174\u017b\5\f\7\2")
        buf.write("\u0175\u017b\5\16\b\2\u0176\u017b\5\22\n\2\u0177\u017b")
        buf.write("\5\20\t\2\u0178\u017b\5\24\13\2\u0179\u017b\7\7\2\2\u017a")
        buf.write("\u0172\3\2\2\2\u017a\u0173\3\2\2\2\u017a\u0174\3\2\2\2")
        buf.write("\u017a\u0175\3\2\2\2\u017a\u0176\3\2\2\2\u017a\u0177\3")
        buf.write("\2\2\2\u017a\u0178\3\2\2\2\u017a\u0179\3\2\2\2\u017b\33")
        buf.write("\3\2\2\2\u017c\u017e\5&\24\2\u017d\u017c\3\2\2\2\u017e")
        buf.write("\u0181\3\2\2\2\u017f\u017d\3\2\2\2\u017f\u0180\3\2\2\2")
        buf.write("\u0180\u0182\3\2\2\2\u0181\u017f\3\2\2\2\u0182\u0183\7")
        buf.write("\2\2\3\u0183\35\3\2\2\2\u0184\u0186\5 \21\2\u0185\u0184")
        buf.write("\3\2\2\2\u0186\u0189\3\2\2\2\u0187\u0185\3\2\2\2\u0187")
        buf.write("\u0188\3\2\2\2\u0188\u018a\3\2\2\2\u0189\u0187\3\2\2\2")
        buf.write('\u018a\u018b\7\2\2\3\u018b\37\3\2\2\2\u018c\u018f\5"')
        buf.write("\22\2\u018d\u018f\5$\23\2\u018e\u018c\3\2\2\2\u018e\u018d")
        buf.write("\3\2\2\2\u018f!\3\2\2\2\u0190\u0191\7?\2\2\u0191\u0192")
        buf.write("\7\35\2\2\u0192\u0193\5*\26\2\u0193\u0194\7\7\2\2\u0194")
        buf.write("#\3\2\2\2\u0195\u0196\7?\2\2\u0196\u0197\7\6\2\2\u0197")
        buf.write("\u0198\5*\26\2\u0198\u0199\7\7\2\2\u0199%\3\2\2\2\u019a")
        buf.write("\u019b\7?\2\2\u019b\u019c\7\35\2\2\u019c\u019d\5,\27\2")
        buf.write("\u019d\u019e\7\7\2\2\u019e'\3\2\2\2\u019f\u01a2\5,\27")
        buf.write("\2\u01a0\u01a2\5.\30\2\u01a1\u019f\3\2\2\2\u01a1\u01a0")
        buf.write("\3\2\2\2\u01a2)\3\2\2\2\u01a3\u01a4\b\26\1\2\u01a4\u01a5")
        buf.write("\7\36\2\2\u01a5\u01a6\5*\26\2\u01a6\u01a7\7\37\2\2\u01a7")
        buf.write("\u01b2\3\2\2\2\u01a8\u01b2\5\60\31\2\u01a9\u01b2\5\64")
        buf.write("\33\2\u01aa\u01ab\t\5\2\2\u01ab\u01b2\5*\26\13\u01ac\u01ad")
        buf.write("\7>\2\2\u01ad\u01ae\7\36\2\2\u01ae\u01af\5*\26\2\u01af")
        buf.write("\u01b0\7\37\2\2\u01b0\u01b2\3\2\2\2\u01b1\u01a3\3\2\2")
        buf.write("\2\u01b1\u01a8\3\2\2\2\u01b1\u01a9\3\2\2\2\u01b1\u01aa")
        buf.write("\3\2\2\2\u01b1\u01ac\3\2\2\2\u01b2\u01ca\3\2\2\2\u01b3")
        buf.write('\u01b4\f\n\2\2\u01b4\u01b5\7"\2\2\u01b5\u01c9\5*\26\n')
        buf.write("\u01b6\u01b7\f\t\2\2\u01b7\u01b8\t\6\2\2\u01b8\u01c9\5")
        buf.write("*\26\n\u01b9\u01ba\f\b\2\2\u01ba\u01bb\t\5\2\2\u01bb\u01c9")
        buf.write("\5*\26\t\u01bc\u01bd\f\7\2\2\u01bd\u01be\t\7\2\2\u01be")
        buf.write("\u01c9\5*\26\b\u01bf\u01c0\f\6\2\2\u01c0\u01c1\7&\2\2")
        buf.write("\u01c1\u01c9\5*\26\7\u01c2\u01c3\f\5\2\2\u01c3\u01c4\7")
        buf.write("'\2\2\u01c4\u01c9\5*\26\6\u01c5\u01c6\f\4\2\2\u01c6\u01c7")
        buf.write("\7(\2\2\u01c7\u01c9\5*\26\5\u01c8\u01b3\3\2\2\2\u01c8")
        buf.write("\u01b6\3\2\2\2\u01c8\u01b9\3\2\2\2\u01c8\u01bc\3\2\2\2")
        buf.write("\u01c8\u01bf\3\2\2\2\u01c8\u01c2\3\2\2\2\u01c8\u01c5\3")
        buf.write("\2\2\2\u01c9\u01cc\3\2\2\2\u01ca\u01c8\3\2\2\2\u01ca\u01cb")
        buf.write("\3\2\2\2\u01cb+\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cd\u01ce")
        buf.write("\b\27\1\2\u01ce\u01cf\7\36\2\2\u01cf\u01d0\5,\27\2\u01d0")
        buf.write("\u01d1\7\37\2\2\u01d1\u01e5\3\2\2\2\u01d2\u01e5\5\60\31")
        buf.write("\2\u01d3\u01e5\7?\2\2\u01d4\u01e5\5\64\33\2\u01d5\u01d6")
        buf.write("\t\5\2\2\u01d6\u01e5\5,\27\f\u01d7\u01d8\7>\2\2\u01d8")
        buf.write("\u01d9\7\36\2\2\u01d9\u01da\5,\27\2\u01da\u01db\7\37\2")
        buf.write("\2\u01db\u01e5\3\2\2\2\u01dc\u01dd\7\36\2\2\u01dd\u01de")
        buf.write("\5.\30\2\u01de\u01df\7\37\2\2\u01df\u01e0\7)\2\2\u01e0")
        buf.write("\u01e1\5,\27\2\u01e1\u01e2\7\16\2\2\u01e2\u01e3\5,\27")
        buf.write("\3\u01e3\u01e5\3\2\2\2\u01e4\u01cd\3\2\2\2\u01e4\u01d2")
        buf.write("\3\2\2\2\u01e4\u01d3\3\2\2\2\u01e4\u01d4\3\2\2\2\u01e4")
        buf.write("\u01d5\3\2\2\2\u01e4\u01d7\3\2\2\2\u01e4\u01dc\3\2\2\2")
        buf.write("\u01e5\u01fd\3\2\2\2\u01e6\u01e7\f\13\2\2\u01e7\u01e8")
        buf.write('\7"\2\2\u01e8\u01fc\5,\27\13\u01e9\u01ea\f\n\2\2\u01ea')
        buf.write("\u01eb\t\6\2\2\u01eb\u01fc\5,\27\13\u01ec\u01ed\f\t\2")
        buf.write("\2\u01ed\u01ee\t\5\2\2\u01ee\u01fc\5,\27\n\u01ef\u01f0")
        buf.write("\f\b\2\2\u01f0\u01f1\t\7\2\2\u01f1\u01fc\5,\27\t\u01f2")
        buf.write("\u01f3\f\7\2\2\u01f3\u01f4\7&\2\2\u01f4\u01fc\5,\27\b")
        buf.write("\u01f5\u01f6\f\6\2\2\u01f6\u01f7\7'\2\2\u01f7\u01fc\5")
        buf.write(",\27\7\u01f8\u01f9\f\5\2\2\u01f9\u01fa\7(\2\2\u01fa\u01fc")
        buf.write("\5,\27\6\u01fb\u01e6\3\2\2\2\u01fb\u01e9\3\2\2\2\u01fb")
        buf.write("\u01ec\3\2\2\2\u01fb\u01ef\3\2\2\2\u01fb\u01f2\3\2\2\2")
        buf.write("\u01fb\u01f5\3\2\2\2\u01fb\u01f8\3\2\2\2\u01fc\u01ff\3")
        buf.write("\2\2\2\u01fd\u01fb\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe-")
        buf.write("\3\2\2\2\u01ff\u01fd\3\2\2\2\u0200\u0201\b\30\1\2\u0201")
        buf.write("\u0202\7\36\2\2\u0202\u0203\5.\30\2\u0203\u0204\7\37\2")
        buf.write("\2\u0204\u0219\3\2\2\2\u0205\u0219\5\62\32\2\u0206\u0207")
        buf.write("\t\b\2\2\u0207\u0219\5.\30\t\u0208\u0209\5,\27\2\u0209")
        buf.write("\u020a\t\t\2\2\u020a\u020b\5,\27\2\u020b\u0219\3\2\2\2")
        buf.write("\u020c\u020d\5,\27\2\u020d\u020e\t\n\2\2\u020e\u020f\5")
        buf.write(",\27\2\u020f\u0219\3\2\2\2\u0210\u0211\7\36\2\2\u0211")
        buf.write("\u0212\5.\30\2\u0212\u0213\7\37\2\2\u0213\u0214\7)\2\2")
        buf.write("\u0214\u0215\5.\30\2\u0215\u0216\7\16\2\2\u0216\u0217")
        buf.write("\5.\30\3\u0217\u0219\3\2\2\2\u0218\u0200\3\2\2\2\u0218")
        buf.write("\u0205\3\2\2\2\u0218\u0206\3\2\2\2\u0218\u0208\3\2\2\2")
        buf.write("\u0218\u020c\3\2\2\2\u0218\u0210\3\2\2\2\u0219\u0225\3")
        buf.write("\2\2\2\u021a\u021b\f\6\2\2\u021b\u021c\t\n\2\2\u021c\u0224")
        buf.write("\5.\30\7\u021d\u021e\f\5\2\2\u021e\u021f\t\13\2\2\u021f")
        buf.write("\u0224\5.\30\6\u0220\u0221\f\4\2\2\u0221\u0222\t\f\2\2")
        buf.write("\u0222\u0224\5.\30\5\u0223\u021a\3\2\2\2\u0223\u021d\3")
        buf.write("\2\2\2\u0223\u0220\3\2\2\2\u0224\u0227\3\2\2\2\u0225\u0223")
        buf.write("\3\2\2\2\u0225\u0226\3\2\2\2\u0226/\3\2\2\2\u0227\u0225")
        buf.write("\3\2\2\2\u0228\u0229\t\r\2\2\u0229\61\3\2\2\2\u022a\u022b")
        buf.write("\t\16\2\2\u022b\63\3\2\2\2\u022c\u022d\t\17\2\2\u022d")
        buf.write("\65\3\2\2\2\u022e\u0230\7#\2\2\u022f\u022e\3\2\2\2\u022f")
        buf.write("\u0230\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0236\7?\2\2")
        buf.write("\u0232\u0233\78\2\2\u0233\u0235\7?\2\2\u0234\u0232\3\2")
        buf.write("\2\2\u0235\u0238\3\2\2\2\u0236\u0234\3\2\2\2\u0236\u0237")
        buf.write("\3\2\2\2\u0237\67\3\2\2\2\u0238\u0236\3\2\2\2:>LRZ^lt")
        buf.write("x\u0088\u0090\u0094\u00a4\u00ac\u00b0\u00b2\u00c3\u00d5")
        buf.write("\u00e5\u00f5\u00f8\u00fc\u0102\u010d\u0110\u0114\u011a")
        buf.write("\u0125\u0128\u012c\u012f\u0135\u013b\u0142\u0146\u0149")
        buf.write("\u014f\u0155\u0164\u0167\u0170\u017a\u017f\u0187\u018e")
        buf.write("\u01a1\u01b1\u01c8\u01ca\u01e4\u01fb\u01fd\u0218\u0223")
        buf.write("\u0225\u022f\u0236")
        return buf.getvalue()




class GrammarParser(Parser):
    grammarFileName = "Grammar.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [
        "<INVALID>",
        "'def'",
        "'int'",
        "'float'",
        "'='",
        "';'",
        "'pseudo'",
        "'state'",
        "'{'",
        "'}'",
        "'[*]'",
        "'->'",
        "':'",
        "'::'",
        "'if'",
        "'['",
        "']'",
        "'effect'",
        "'!'",
        "'*'",
        "'enter'",
        "'abstract'",
        "'exit'",
        "'during'",
        "'before'",
        "'after'",
        "'>>'",
        "':='",
        "'('",
        "')'",
        "'+'",
        "'-'",
        "'**'",
        "'/'",
        "'%'",
        "'<<'",
        "'&'",
        "'^'",
        "'|'",
        "'?'",
        "'not'",
        "'<'",
        "'>'",
        "'<='",
        "'>='",
        "'=='",
        "'!='",
        "'&&'",
        "'and'",
        "'||'",
        "'or'",
        "'pi'",
        "'E'",
        "'tau'",
        "'.'",
    ]

    symbolicNames = [
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "FLOAT",
        "INT",
        "HEX_INT",
        "TRUE",
        "FALSE",
        "UFUNC_NAME",
        "ID",
        "STRING",
        "WS",
        "MULTILINE_COMMENT",
        "LINE_COMMENT",
        "PYTHON_COMMENT",
    ]

    RULE_condition = 0
    RULE_state_machine_dsl = 1
    RULE_def_assignment = 2
    RULE_state_definition = 3
    RULE_transition_definition = 4
    RULE_transition_force_definition = 5
    RULE_enter_definition = 6
    RULE_exit_definition = 7
    RULE_during_definition = 8
    RULE_during_aspect_definition = 9
    RULE_operation_assignment = 10
    RULE_operational_statement = 11
    RULE_state_inner_statement = 12
    RULE_operation_program = 13
    RULE_preamble_program = 14
    RULE_preamble_statement = 15
    RULE_initial_assignment = 16
    RULE_constant_definition = 17
    RULE_operational_assignment = 18
    RULE_generic_expression = 19
    RULE_init_expression = 20
    RULE_num_expression = 21
    RULE_cond_expression = 22
    RULE_num_literal = 23
    RULE_bool_literal = 24
    RULE_math_const = 25
    RULE_chain_id = 26

    ruleNames = [
        "condition",
        "state_machine_dsl",
        "def_assignment",
        "state_definition",
        "transition_definition",
        "transition_force_definition",
        "enter_definition",
        "exit_definition",
        "during_definition",
        "during_aspect_definition",
        "operation_assignment",
        "operational_statement",
        "state_inner_statement",
        "operation_program",
        "preamble_program",
        "preamble_statement",
        "initial_assignment",
        "constant_definition",
        "operational_assignment",
        "generic_expression",
        "init_expression",
        "num_expression",
        "cond_expression",
        "num_literal",
        "bool_literal",
        "math_const",
        "chain_id",
    ]

    EOF = Token.EOF
    T__0 = 1
    T__1 = 2
    T__2 = 3
    T__3 = 4
    T__4 = 5
    T__5 = 6
    T__6 = 7
    T__7 = 8
    T__8 = 9
    T__9 = 10
    T__10 = 11
    T__11 = 12
    T__12 = 13
    T__13 = 14
    T__14 = 15
    T__15 = 16
    T__16 = 17
    T__17 = 18
    T__18 = 19
    T__19 = 20
    T__20 = 21
    T__21 = 22
    T__22 = 23
    T__23 = 24
    T__24 = 25
    T__25 = 26
    T__26 = 27
    T__27 = 28
    T__28 = 29
    T__29 = 30
    T__30 = 31
    T__31 = 32
    T__32 = 33
    T__33 = 34
    T__34 = 35
    T__35 = 36
    T__36 = 37
    T__37 = 38
    T__38 = 39
    T__39 = 40
    T__40 = 41
    T__41 = 42
    T__42 = 43
    T__43 = 44
    T__44 = 45
    T__45 = 46
    T__46 = 47
    T__47 = 48
    T__48 = 49
    T__49 = 50
    T__50 = 51
    T__51 = 52
    T__52 = 53
    T__53 = 54
    FLOAT = 55
    INT = 56
    HEX_INT = 57
    TRUE = 58
    FALSE = 59
    UFUNC_NAME = 60
    ID = 61
    STRING = 62
    WS = 63
    MULTILINE_COMMENT = 64
    LINE_COMMENT = 65
    PYTHON_COMMENT = 66

    def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.3")
        self._interp = ParserATNSimulator(
            self, self.atn, self.decisionsToDFA, self.sharedContextCache
        )
        self._predicates = None

    class ConditionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

        def getRuleIndex(self):
            return GrammarParser.RULE_condition

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

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

    def condition(self):
        localctx = GrammarParser.ConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_condition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 54
            self.cond_expression(0)
            self.state = 55
            self.match(GrammarParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class State_machine_dslContext(ParserRuleContext):
        __slots__ = "parser"

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

        def state_definition(self):
            return self.getTypedRuleContext(GrammarParser.State_definitionContext, 0)

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

        def def_assignment(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Def_assignmentContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Def_assignmentContext, i)

        def getRuleIndex(self):
            return GrammarParser.RULE_state_machine_dsl

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

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

    def state_machine_dsl(self):
        localctx = GrammarParser.State_machine_dslContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_state_machine_dsl)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 60
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == GrammarParser.T__0:
                self.state = 57
                self.def_assignment()
                self.state = 62
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 63
            self.state_definition()
            self.state = 64
            self.match(GrammarParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Def_assignmentContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def init_expression(self):
            return self.getTypedRuleContext(GrammarParser.Init_expressionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_def_assignment

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

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

    def def_assignment(self):
        localctx = GrammarParser.Def_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_def_assignment)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 66
            self.match(GrammarParser.T__0)
            self.state = 67
            localctx.deftype = self._input.LT(1)
            _la = self._input.LA(1)
            if not (_la == GrammarParser.T__1 or _la == GrammarParser.T__2):
                localctx.deftype = self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 68
            self.match(GrammarParser.ID)
            self.state = 69
            self.match(GrammarParser.T__3)
            self.state = 70
            self.init_expression(0)
            self.state = 71
            self.match(GrammarParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class State_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_state_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class LeafStateDefinitionContext(State_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.State_definitionContext
            super().__init__(parser)
            self.pseudo = None  # Token
            self.state_id = None  # Token
            self.copyFrom(ctx)

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

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

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

    class CompositeStateDefinitionContext(State_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.State_definitionContext
            super().__init__(parser)
            self.pseudo = None  # Token
            self.state_id = None  # Token
            self.copyFrom(ctx)

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

        def state_inner_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.State_inner_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.State_inner_statementContext, i
                )

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

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

    def state_definition(self):
        localctx = GrammarParser.State_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_state_definition)
        self._la = 0  # Token type
        try:
            self.state = 92
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 4, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.LeafStateDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 74
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.T__5:
                    self.state = 73
                    localctx.pseudo = self.match(GrammarParser.T__5)

                self.state = 76
                self.match(GrammarParser.T__6)
                self.state = 77
                localctx.state_id = self.match(GrammarParser.ID)
                self.state = 78
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 2:
                localctx = GrammarParser.CompositeStateDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 80
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.T__5:
                    self.state = 79
                    localctx.pseudo = self.match(GrammarParser.T__5)

                self.state = 82
                self.match(GrammarParser.T__6)
                self.state = 83
                localctx.state_id = self.match(GrammarParser.ID)
                self.state = 84
                self.match(GrammarParser.T__7)
                self.state = 88
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((_la) & ~0x3F) == 0 and (
                    (1 << _la)
                    & (
                        (1 << GrammarParser.T__4)
                        | (1 << GrammarParser.T__5)
                        | (1 << GrammarParser.T__6)
                        | (1 << GrammarParser.T__9)
                        | (1 << GrammarParser.T__17)
                        | (1 << GrammarParser.T__19)
                        | (1 << GrammarParser.T__21)
                        | (1 << GrammarParser.T__22)
                        | (1 << GrammarParser.T__25)
                        | (1 << GrammarParser.ID)
                    )
                ) != 0:
                    self.state = 85
                    self.state_inner_statement()
                    self.state = 90
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 91
                self.match(GrammarParser.T__8)
                pass

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

    class Transition_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_transition_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class NormalTransitionDefinitionContext(Transition_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_definitionContext
            super().__init__(parser)
            self.from_state = None  # Token
            self.to_state = None  # Token
            self.from_id = None  # Token
            self.copyFrom(ctx)

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

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

    class EntryTransitionDefinitionContext(Transition_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_definitionContext
            super().__init__(parser)
            self.to_state = None  # Token
            self.copyFrom(ctx)

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

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

    class ExitTransitionDefinitionContext(Transition_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_definitionContext
            super().__init__(parser)
            self.from_state = None  # Token
            self.from_id = None  # Token
            self.copyFrom(ctx)

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

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

    def transition_definition(self):
        localctx = GrammarParser.Transition_definitionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 8, self.RULE_transition_definition)
        self._la = 0  # Token type
        try:
            self.state = 176
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 14, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.EntryTransitionDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 1)
                self.state = 94
                self.match(GrammarParser.T__9)
                self.state = 95
                self.match(GrammarParser.T__10)
                self.state = 96
                localctx.to_state = self.match(GrammarParser.ID)
                self.state = 106
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 5, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 98
                    _la = self._input.LA(1)
                    if not (_la == GrammarParser.T__11 or _la == GrammarParser.T__12):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 99
                    self.chain_id()
                    pass

                elif la_ == 3:
                    self.state = 100
                    self.match(GrammarParser.T__11)
                    self.state = 101
                    self.match(GrammarParser.T__13)
                    self.state = 102
                    self.match(GrammarParser.T__14)
                    self.state = 103
                    self.cond_expression(0)
                    self.state = 104
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 118
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [GrammarParser.T__4]:
                    self.state = 108
                    self.match(GrammarParser.T__4)
                    pass
                elif token in [GrammarParser.T__16]:
                    self.state = 109
                    self.match(GrammarParser.T__16)
                    self.state = 110
                    self.match(GrammarParser.T__7)
                    self.state = 114
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                        self.state = 111
                        self.operational_statement()
                        self.state = 116
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 117
                    self.match(GrammarParser.T__8)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                localctx = GrammarParser.NormalTransitionDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 2)
                self.state = 120
                localctx.from_state = self.match(GrammarParser.ID)
                self.state = 121
                self.match(GrammarParser.T__10)
                self.state = 122
                localctx.to_state = self.match(GrammarParser.ID)
                self.state = 134
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 8, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 124
                    self.match(GrammarParser.T__12)
                    self.state = 125
                    localctx.from_id = self.match(GrammarParser.ID)
                    pass

                elif la_ == 3:
                    self.state = 126
                    self.match(GrammarParser.T__11)
                    self.state = 127
                    self.chain_id()
                    pass

                elif la_ == 4:
                    self.state = 128
                    self.match(GrammarParser.T__11)
                    self.state = 129
                    self.match(GrammarParser.T__13)
                    self.state = 130
                    self.match(GrammarParser.T__14)
                    self.state = 131
                    self.cond_expression(0)
                    self.state = 132
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 146
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [GrammarParser.T__4]:
                    self.state = 136
                    self.match(GrammarParser.T__4)
                    pass
                elif token in [GrammarParser.T__16]:
                    self.state = 137
                    self.match(GrammarParser.T__16)
                    self.state = 138
                    self.match(GrammarParser.T__7)
                    self.state = 142
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                        self.state = 139
                        self.operational_statement()
                        self.state = 144
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 145
                    self.match(GrammarParser.T__8)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 3:
                localctx = GrammarParser.ExitTransitionDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 148
                localctx.from_state = self.match(GrammarParser.ID)
                self.state = 149
                self.match(GrammarParser.T__10)
                self.state = 150
                self.match(GrammarParser.T__9)
                self.state = 162
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 11, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 152
                    self.match(GrammarParser.T__12)
                    self.state = 153
                    localctx.from_id = self.match(GrammarParser.ID)
                    pass

                elif la_ == 3:
                    self.state = 154
                    self.match(GrammarParser.T__11)
                    self.state = 155
                    self.chain_id()
                    pass

                elif la_ == 4:
                    self.state = 156
                    self.match(GrammarParser.T__11)
                    self.state = 157
                    self.match(GrammarParser.T__13)
                    self.state = 158
                    self.match(GrammarParser.T__14)
                    self.state = 159
                    self.cond_expression(0)
                    self.state = 160
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 174
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [GrammarParser.T__4]:
                    self.state = 164
                    self.match(GrammarParser.T__4)
                    pass
                elif token in [GrammarParser.T__16]:
                    self.state = 165
                    self.match(GrammarParser.T__16)
                    self.state = 166
                    self.match(GrammarParser.T__7)
                    self.state = 170
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                        self.state = 167
                        self.operational_statement()
                        self.state = 172
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 173
                    self.match(GrammarParser.T__8)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

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

    class Transition_force_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_transition_force_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class NormalForceTransitionDefinitionContext(Transition_force_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_force_definitionContext
            super().__init__(parser)
            self.from_state = None  # Token
            self.to_state = None  # Token
            self.from_id = None  # Token
            self.copyFrom(ctx)

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

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

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

    class ExitAllForceTransitionDefinitionContext(Transition_force_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_force_definitionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

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

    class NormalAllForceTransitionDefinitionContext(Transition_force_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_force_definitionContext
            super().__init__(parser)
            self.to_state = None  # Token
            self.copyFrom(ctx)

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

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

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

    class ExitForceTransitionDefinitionContext(Transition_force_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Transition_force_definitionContext
            super().__init__(parser)
            self.from_state = None  # Token
            self.from_id = None  # Token
            self.copyFrom(ctx)

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

        def chain_id(self):
            return self.getTypedRuleContext(GrammarParser.Chain_idContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

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

    def transition_force_definition(self):
        localctx = GrammarParser.Transition_force_definitionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 10, self.RULE_transition_force_definition)
        self._la = 0  # Token type
        try:
            self.state = 246
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 19, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.NormalForceTransitionDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 1)
                self.state = 178
                self.match(GrammarParser.T__17)
                self.state = 179
                localctx.from_state = self.match(GrammarParser.ID)
                self.state = 180
                self.match(GrammarParser.T__10)
                self.state = 181
                localctx.to_state = self.match(GrammarParser.ID)
                self.state = 193
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 15, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 183
                    self.match(GrammarParser.T__12)
                    self.state = 184
                    localctx.from_id = self.match(GrammarParser.ID)
                    pass

                elif la_ == 3:
                    self.state = 185
                    self.match(GrammarParser.T__11)
                    self.state = 186
                    self.chain_id()
                    pass

                elif la_ == 4:
                    self.state = 187
                    self.match(GrammarParser.T__11)
                    self.state = 188
                    self.match(GrammarParser.T__13)
                    self.state = 189
                    self.match(GrammarParser.T__14)
                    self.state = 190
                    self.cond_expression(0)
                    self.state = 191
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 195
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 2:
                localctx = GrammarParser.ExitForceTransitionDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 2)
                self.state = 196
                self.match(GrammarParser.T__17)
                self.state = 197
                localctx.from_state = self.match(GrammarParser.ID)
                self.state = 198
                self.match(GrammarParser.T__10)
                self.state = 199
                self.match(GrammarParser.T__9)
                self.state = 211
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 16, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 201
                    self.match(GrammarParser.T__12)
                    self.state = 202
                    localctx.from_id = self.match(GrammarParser.ID)
                    pass

                elif la_ == 3:
                    self.state = 203
                    self.match(GrammarParser.T__11)
                    self.state = 204
                    self.chain_id()
                    pass

                elif la_ == 4:
                    self.state = 205
                    self.match(GrammarParser.T__11)
                    self.state = 206
                    self.match(GrammarParser.T__13)
                    self.state = 207
                    self.match(GrammarParser.T__14)
                    self.state = 208
                    self.cond_expression(0)
                    self.state = 209
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 213
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 3:
                localctx = GrammarParser.NormalAllForceTransitionDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 3)
                self.state = 214
                self.match(GrammarParser.T__17)
                self.state = 215
                self.match(GrammarParser.T__18)
                self.state = 216
                self.match(GrammarParser.T__10)
                self.state = 217
                localctx.to_state = self.match(GrammarParser.ID)
                self.state = 227
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 17, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 219
                    _la = self._input.LA(1)
                    if not (_la == GrammarParser.T__11 or _la == GrammarParser.T__12):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 220
                    self.chain_id()
                    pass

                elif la_ == 3:
                    self.state = 221
                    self.match(GrammarParser.T__11)
                    self.state = 222
                    self.match(GrammarParser.T__13)
                    self.state = 223
                    self.match(GrammarParser.T__14)
                    self.state = 224
                    self.cond_expression(0)
                    self.state = 225
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 229
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 4:
                localctx = GrammarParser.ExitAllForceTransitionDefinitionContext(
                    self, localctx
                )
                self.enterOuterAlt(localctx, 4)
                self.state = 230
                self.match(GrammarParser.T__17)
                self.state = 231
                self.match(GrammarParser.T__18)
                self.state = 232
                self.match(GrammarParser.T__10)
                self.state = 233
                self.match(GrammarParser.T__9)
                self.state = 243
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 18, self._ctx)
                if la_ == 1:
                    pass

                elif la_ == 2:
                    self.state = 235
                    _la = self._input.LA(1)
                    if not (_la == GrammarParser.T__11 or _la == GrammarParser.T__12):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 236
                    self.chain_id()
                    pass

                elif la_ == 3:
                    self.state = 237
                    self.match(GrammarParser.T__11)
                    self.state = 238
                    self.match(GrammarParser.T__13)
                    self.state = 239
                    self.match(GrammarParser.T__14)
                    self.state = 240
                    self.cond_expression(0)
                    self.state = 241
                    self.match(GrammarParser.T__15)
                    pass

                self.state = 245
                self.match(GrammarParser.T__4)
                pass

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

    class Enter_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_enter_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class EnterOperationsContext(Enter_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Enter_definitionContext
            super().__init__(parser)
            self.func_name = None  # Token
            self.copyFrom(ctx)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

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

    class EnterAbstractFuncContext(Enter_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Enter_definitionContext
            super().__init__(parser)
            self.func_name = None  # Token
            self.raw_doc = None  # Token
            self.copyFrom(ctx)

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

        def MULTILINE_COMMENT(self):
            return self.getToken(GrammarParser.MULTILINE_COMMENT, 0)

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

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

    def enter_definition(self):
        localctx = GrammarParser.Enter_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_enter_definition)
        self._la = 0  # Token type
        try:
            self.state = 270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 23, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.EnterOperationsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 248
                self.match(GrammarParser.T__19)
                self.state = 250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 249
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 252
                self.match(GrammarParser.T__7)
                self.state = 256
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                    self.state = 253
                    self.operational_statement()
                    self.state = 258
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 259
                self.match(GrammarParser.T__8)
                pass

            elif la_ == 2:
                localctx = GrammarParser.EnterAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 260
                self.match(GrammarParser.T__19)
                self.state = 261
                self.match(GrammarParser.T__20)
                self.state = 262
                localctx.func_name = self.match(GrammarParser.ID)
                self.state = 263
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 3:
                localctx = GrammarParser.EnterAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 264
                self.match(GrammarParser.T__19)
                self.state = 265
                self.match(GrammarParser.T__20)
                self.state = 267
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 266
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 269
                localctx.raw_doc = self.match(GrammarParser.MULTILINE_COMMENT)
                pass

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

    class Exit_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_exit_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class ExitOperationsContext(Exit_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Exit_definitionContext
            super().__init__(parser)
            self.func_name = None  # Token
            self.copyFrom(ctx)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

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

    class ExitAbstractFuncContext(Exit_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Exit_definitionContext
            super().__init__(parser)
            self.func_name = None  # Token
            self.raw_doc = None  # Token
            self.copyFrom(ctx)

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

        def MULTILINE_COMMENT(self):
            return self.getToken(GrammarParser.MULTILINE_COMMENT, 0)

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

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

    def exit_definition(self):
        localctx = GrammarParser.Exit_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_exit_definition)
        self._la = 0  # Token type
        try:
            self.state = 294
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 27, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.ExitOperationsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 272
                self.match(GrammarParser.T__21)
                self.state = 274
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 273
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 276
                self.match(GrammarParser.T__7)
                self.state = 280
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                    self.state = 277
                    self.operational_statement()
                    self.state = 282
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 283
                self.match(GrammarParser.T__8)
                pass

            elif la_ == 2:
                localctx = GrammarParser.ExitAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 284
                self.match(GrammarParser.T__21)
                self.state = 285
                self.match(GrammarParser.T__20)
                self.state = 286
                localctx.func_name = self.match(GrammarParser.ID)
                self.state = 287
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 3:
                localctx = GrammarParser.ExitAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 288
                self.match(GrammarParser.T__21)
                self.state = 289
                self.match(GrammarParser.T__20)
                self.state = 291
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 290
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 293
                localctx.raw_doc = self.match(GrammarParser.MULTILINE_COMMENT)
                pass

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

    class During_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_during_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class DuringOperationsContext(During_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.During_definitionContext
            super().__init__(parser)
            self.aspect = None  # Token
            self.func_name = None  # Token
            self.copyFrom(ctx)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

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

    class DuringAbstractFuncContext(During_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.During_definitionContext
            super().__init__(parser)
            self.aspect = None  # Token
            self.func_name = None  # Token
            self.raw_doc = None  # Token
            self.copyFrom(ctx)

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

        def MULTILINE_COMMENT(self):
            return self.getToken(GrammarParser.MULTILINE_COMMENT, 0)

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

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

    def during_definition(self):
        localctx = GrammarParser.During_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_during_definition)
        self._la = 0  # Token type
        try:
            self.state = 327
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 34, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.DuringOperationsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 296
                self.match(GrammarParser.T__22)
                self.state = 298
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.T__23 or _la == GrammarParser.T__24:
                    self.state = 297
                    localctx.aspect = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not (_la == GrammarParser.T__23 or _la == GrammarParser.T__24):
                        localctx.aspect = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

                self.state = 301
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 300
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 303
                self.match(GrammarParser.T__7)
                self.state = 307
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                    self.state = 304
                    self.operational_statement()
                    self.state = 309
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 310
                self.match(GrammarParser.T__8)
                pass

            elif la_ == 2:
                localctx = GrammarParser.DuringAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 311
                self.match(GrammarParser.T__22)
                self.state = 313
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.T__23 or _la == GrammarParser.T__24:
                    self.state = 312
                    localctx.aspect = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not (_la == GrammarParser.T__23 or _la == GrammarParser.T__24):
                        localctx.aspect = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

                self.state = 315
                self.match(GrammarParser.T__20)
                self.state = 316
                localctx.func_name = self.match(GrammarParser.ID)
                self.state = 317
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 3:
                localctx = GrammarParser.DuringAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 318
                self.match(GrammarParser.T__22)
                self.state = 320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.T__23 or _la == GrammarParser.T__24:
                    self.state = 319
                    localctx.aspect = self._input.LT(1)
                    _la = self._input.LA(1)
                    if not (_la == GrammarParser.T__23 or _la == GrammarParser.T__24):
                        localctx.aspect = self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

                self.state = 322
                self.match(GrammarParser.T__20)
                self.state = 324
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 323
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 326
                localctx.raw_doc = self.match(GrammarParser.MULTILINE_COMMENT)
                pass

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

    class During_aspect_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_during_aspect_definition

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class DuringAspectAbstractFuncContext(During_aspect_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.During_aspect_definitionContext
            super().__init__(parser)
            self.aspect = None  # Token
            self.func_name = None  # Token
            self.raw_doc = None  # Token
            self.copyFrom(ctx)

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

        def MULTILINE_COMMENT(self):
            return self.getToken(GrammarParser.MULTILINE_COMMENT, 0)

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

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

    class DuringAspectOperationsContext(During_aspect_definitionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.During_aspect_definitionContext
            super().__init__(parser)
            self.aspect = None  # Token
            self.func_name = None  # Token
            self.copyFrom(ctx)

        def operational_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_statementContext, i
                )

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

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

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

    def during_aspect_definition(self):
        localctx = GrammarParser.During_aspect_definitionContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 18, self.RULE_during_aspect_definition)
        self._la = 0  # Token type
        try:
            self.state = 357
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 38, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.DuringAspectOperationsContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 329
                self.match(GrammarParser.T__25)
                self.state = 330
                self.match(GrammarParser.T__22)
                self.state = 331
                localctx.aspect = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__23 or _la == GrammarParser.T__24):
                    localctx.aspect = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 333
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 332
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 335
                self.match(GrammarParser.T__7)
                self.state = 339
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == GrammarParser.T__4 or _la == GrammarParser.ID:
                    self.state = 336
                    self.operational_statement()
                    self.state = 341
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 342
                self.match(GrammarParser.T__8)
                pass

            elif la_ == 2:
                localctx = GrammarParser.DuringAspectAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 343
                self.match(GrammarParser.T__25)
                self.state = 344
                self.match(GrammarParser.T__22)
                self.state = 345
                localctx.aspect = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__23 or _la == GrammarParser.T__24):
                    localctx.aspect = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 346
                self.match(GrammarParser.T__20)
                self.state = 347
                localctx.func_name = self.match(GrammarParser.ID)
                self.state = 348
                self.match(GrammarParser.T__4)
                pass

            elif la_ == 3:
                localctx = GrammarParser.DuringAspectAbstractFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 349
                self.match(GrammarParser.T__25)
                self.state = 350
                self.match(GrammarParser.T__22)
                self.state = 351
                localctx.aspect = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__23 or _la == GrammarParser.T__24):
                    localctx.aspect = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 352
                self.match(GrammarParser.T__20)
                self.state = 354
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == GrammarParser.ID:
                    self.state = 353
                    localctx.func_name = self.match(GrammarParser.ID)

                self.state = 356
                localctx.raw_doc = self.match(GrammarParser.MULTILINE_COMMENT)
                pass

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

    class Operation_assignmentContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def num_expression(self):
            return self.getTypedRuleContext(GrammarParser.Num_expressionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_operation_assignment

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

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

    def operation_assignment(self):
        localctx = GrammarParser.Operation_assignmentContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 20, self.RULE_operation_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 359
            self.match(GrammarParser.ID)
            self.state = 360
            self.match(GrammarParser.T__3)
            self.state = 361
            self.num_expression(0)
            self.state = 362
            self.match(GrammarParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Operational_statementContext(ParserRuleContext):
        __slots__ = "parser"

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

        def operation_assignment(self):
            return self.getTypedRuleContext(
                GrammarParser.Operation_assignmentContext, 0
            )

        def getRuleIndex(self):
            return GrammarParser.RULE_operational_statement

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

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

    def operational_statement(self):
        localctx = GrammarParser.Operational_statementContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 22, self.RULE_operational_statement)
        try:
            self.state = 366
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GrammarParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 364
                self.operation_assignment()
                pass
            elif token in [GrammarParser.T__4]:
                self.enterOuterAlt(localctx, 2)
                self.state = 365
                self.match(GrammarParser.T__4)
                pass
            else:
                raise NoViableAltException(self)

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

    class State_inner_statementContext(ParserRuleContext):
        __slots__ = "parser"

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

        def state_definition(self):
            return self.getTypedRuleContext(GrammarParser.State_definitionContext, 0)

        def transition_definition(self):
            return self.getTypedRuleContext(
                GrammarParser.Transition_definitionContext, 0
            )

        def transition_force_definition(self):
            return self.getTypedRuleContext(
                GrammarParser.Transition_force_definitionContext, 0
            )

        def enter_definition(self):
            return self.getTypedRuleContext(GrammarParser.Enter_definitionContext, 0)

        def during_definition(self):
            return self.getTypedRuleContext(GrammarParser.During_definitionContext, 0)

        def exit_definition(self):
            return self.getTypedRuleContext(GrammarParser.Exit_definitionContext, 0)

        def during_aspect_definition(self):
            return self.getTypedRuleContext(
                GrammarParser.During_aspect_definitionContext, 0
            )

        def getRuleIndex(self):
            return GrammarParser.RULE_state_inner_statement

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

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

    def state_inner_statement(self):
        localctx = GrammarParser.State_inner_statementContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 24, self.RULE_state_inner_statement)
        try:
            self.state = 376
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GrammarParser.T__5, GrammarParser.T__6]:
                self.enterOuterAlt(localctx, 1)
                self.state = 368
                self.state_definition()
                pass
            elif token in [GrammarParser.T__9, GrammarParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 369
                self.transition_definition()
                pass
            elif token in [GrammarParser.T__17]:
                self.enterOuterAlt(localctx, 3)
                self.state = 370
                self.transition_force_definition()
                pass
            elif token in [GrammarParser.T__19]:
                self.enterOuterAlt(localctx, 4)
                self.state = 371
                self.enter_definition()
                pass
            elif token in [GrammarParser.T__22]:
                self.enterOuterAlt(localctx, 5)
                self.state = 372
                self.during_definition()
                pass
            elif token in [GrammarParser.T__21]:
                self.enterOuterAlt(localctx, 6)
                self.state = 373
                self.exit_definition()
                pass
            elif token in [GrammarParser.T__25]:
                self.enterOuterAlt(localctx, 7)
                self.state = 374
                self.during_aspect_definition()
                pass
            elif token in [GrammarParser.T__4]:
                self.enterOuterAlt(localctx, 8)
                self.state = 375
                self.match(GrammarParser.T__4)
                pass
            else:
                raise NoViableAltException(self)

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

    class Operation_programContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def operational_assignment(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Operational_assignmentContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Operational_assignmentContext, i
                )

        def getRuleIndex(self):
            return GrammarParser.RULE_operation_program

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

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

    def operation_program(self):
        localctx = GrammarParser.Operation_programContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_operation_program)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 381
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == GrammarParser.ID:
                self.state = 378
                self.operational_assignment()
                self.state = 383
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class Preamble_programContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def preamble_statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(
                    GrammarParser.Preamble_statementContext
                )
            else:
                return self.getTypedRuleContext(
                    GrammarParser.Preamble_statementContext, i
                )

        def getRuleIndex(self):
            return GrammarParser.RULE_preamble_program

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

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

    def preamble_program(self):
        localctx = GrammarParser.Preamble_programContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_preamble_program)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 389
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == GrammarParser.ID:
                self.state = 386
                self.preamble_statement()
                self.state = 391
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class Preamble_statementContext(ParserRuleContext):
        __slots__ = "parser"

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

        def initial_assignment(self):
            return self.getTypedRuleContext(GrammarParser.Initial_assignmentContext, 0)

        def constant_definition(self):
            return self.getTypedRuleContext(GrammarParser.Constant_definitionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_preamble_statement

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

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

    def preamble_statement(self):
        localctx = GrammarParser.Preamble_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_preamble_statement)
        try:
            self.state = 396
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 43, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 394
                self.initial_assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 395
                self.constant_definition()
                pass

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

    class Initial_assignmentContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def init_expression(self):
            return self.getTypedRuleContext(GrammarParser.Init_expressionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_initial_assignment

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

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

    def initial_assignment(self):
        localctx = GrammarParser.Initial_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_initial_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 398
            self.match(GrammarParser.ID)
            self.state = 399
            self.match(GrammarParser.T__26)
            self.state = 400
            self.init_expression(0)
            self.state = 401
            self.match(GrammarParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Constant_definitionContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def init_expression(self):
            return self.getTypedRuleContext(GrammarParser.Init_expressionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_constant_definition

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

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

    def constant_definition(self):
        localctx = GrammarParser.Constant_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_constant_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 403
            self.match(GrammarParser.ID)
            self.state = 404
            self.match(GrammarParser.T__3)
            self.state = 405
            self.init_expression(0)
            self.state = 406
            self.match(GrammarParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Operational_assignmentContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def num_expression(self):
            return self.getTypedRuleContext(GrammarParser.Num_expressionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_operational_assignment

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

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

    def operational_assignment(self):
        localctx = GrammarParser.Operational_assignmentContext(
            self, self._ctx, self.state
        )
        self.enterRule(localctx, 36, self.RULE_operational_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.match(GrammarParser.ID)
            self.state = 409
            self.match(GrammarParser.T__26)
            self.state = 410
            self.num_expression(0)
            self.state = 411
            self.match(GrammarParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Generic_expressionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def num_expression(self):
            return self.getTypedRuleContext(GrammarParser.Num_expressionContext, 0)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_generic_expression

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

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

    def generic_expression(self):
        localctx = GrammarParser.Generic_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_generic_expression)
        try:
            self.state = 415
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 44, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 413
                self.num_expression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 414
                self.cond_expression(0)
                pass

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

    class Init_expressionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_init_expression

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class FuncExprInitContext(Init_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Init_expressionContext
            super().__init__(parser)
            self.function = None  # Token
            self.copyFrom(ctx)

        def init_expression(self):
            return self.getTypedRuleContext(GrammarParser.Init_expressionContext, 0)

        def UFUNC_NAME(self):
            return self.getToken(GrammarParser.UFUNC_NAME, 0)

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

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

    class UnaryExprInitContext(Init_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Init_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def init_expression(self):
            return self.getTypedRuleContext(GrammarParser.Init_expressionContext, 0)

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

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

    class BinaryExprInitContext(Init_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Init_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def init_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Init_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Init_expressionContext, i)

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

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

    class LiteralExprInitContext(Init_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Init_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def num_literal(self):
            return self.getTypedRuleContext(GrammarParser.Num_literalContext, 0)

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

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

    class MathConstExprInitContext(Init_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Init_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def math_const(self):
            return self.getTypedRuleContext(GrammarParser.Math_constContext, 0)

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

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

    class ParenExprInitContext(Init_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Init_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def init_expression(self):
            return self.getTypedRuleContext(GrammarParser.Init_expressionContext, 0)

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

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

    def init_expression(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = GrammarParser.Init_expressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 40
        self.enterRecursionRule(localctx, 40, self.RULE_init_expression, _p)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 431
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [GrammarParser.T__27]:
                localctx = GrammarParser.ParenExprInitContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 418
                self.match(GrammarParser.T__27)
                self.state = 419
                self.init_expression(0)
                self.state = 420
                self.match(GrammarParser.T__28)
                pass
            elif token in [
                GrammarParser.FLOAT,
                GrammarParser.INT,
                GrammarParser.HEX_INT,
            ]:
                localctx = GrammarParser.LiteralExprInitContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 422
                self.num_literal()
                pass
            elif token in [
                GrammarParser.T__50,
                GrammarParser.T__51,
                GrammarParser.T__52,
            ]:
                localctx = GrammarParser.MathConstExprInitContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 423
                self.math_const()
                pass
            elif token in [GrammarParser.T__29, GrammarParser.T__30]:
                localctx = GrammarParser.UnaryExprInitContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 424
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__29 or _la == GrammarParser.T__30):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 425
                self.init_expression(9)
                pass
            elif token in [GrammarParser.UFUNC_NAME]:
                localctx = GrammarParser.FuncExprInitContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 426
                localctx.function = self.match(GrammarParser.UFUNC_NAME)
                self.state = 427
                self.match(GrammarParser.T__27)
                self.state = 428
                self.init_expression(0)
                self.state = 429
                self.match(GrammarParser.T__28)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 456
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 47, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 454
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input, 46, self._ctx)
                    if la_ == 1:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 433
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 8)"
                            )
                        self.state = 434
                        localctx.op = self.match(GrammarParser.T__31)
                        self.state = 435
                        self.init_expression(8)
                        pass

                    elif la_ == 2:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 436
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 7)"
                            )
                        self.state = 437
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << GrammarParser.T__18)
                                    | (1 << GrammarParser.T__32)
                                    | (1 << GrammarParser.T__33)
                                )
                            )
                            != 0
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 438
                        self.init_expression(8)
                        pass

                    elif la_ == 3:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 439
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 6)"
                            )
                        self.state = 440
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__29 or _la == GrammarParser.T__30
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 441
                        self.init_expression(7)
                        pass

                    elif la_ == 4:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 442
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 5)"
                            )
                        self.state = 443
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__25 or _la == GrammarParser.T__34
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 444
                        self.init_expression(6)
                        pass

                    elif la_ == 5:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 445
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 4)"
                            )
                        self.state = 446
                        localctx.op = self.match(GrammarParser.T__35)
                        self.state = 447
                        self.init_expression(5)
                        pass

                    elif la_ == 6:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 448
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 3)"
                            )
                        self.state = 449
                        localctx.op = self.match(GrammarParser.T__36)
                        self.state = 450
                        self.init_expression(4)
                        pass

                    elif la_ == 7:
                        localctx = GrammarParser.BinaryExprInitContext(
                            self,
                            GrammarParser.Init_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_init_expression
                        )
                        self.state = 451
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 2)"
                            )
                        self.state = 452
                        localctx.op = self.match(GrammarParser.T__37)
                        self.state = 453
                        self.init_expression(3)
                        pass

                self.state = 458
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 47, self._ctx)

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

    class Num_expressionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_num_expression

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class UnaryExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def num_expression(self):
            return self.getTypedRuleContext(GrammarParser.Num_expressionContext, 0)

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

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

    class FuncExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.function = None  # Token
            self.copyFrom(ctx)

        def num_expression(self):
            return self.getTypedRuleContext(GrammarParser.Num_expressionContext, 0)

        def UFUNC_NAME(self):
            return self.getToken(GrammarParser.UFUNC_NAME, 0)

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

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

    class ConditionalCStyleExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

        def num_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Num_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Num_expressionContext, i)

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

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

    class BinaryExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def num_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Num_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Num_expressionContext, i)

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

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

    class LiteralExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def num_literal(self):
            return self.getTypedRuleContext(GrammarParser.Num_literalContext, 0)

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

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

    class MathConstExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def math_const(self):
            return self.getTypedRuleContext(GrammarParser.Math_constContext, 0)

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

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

    class ParenExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def num_expression(self):
            return self.getTypedRuleContext(GrammarParser.Num_expressionContext, 0)

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

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

    class IdExprNumContext(Num_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Num_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

    def num_expression(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = GrammarParser.Num_expressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 42
        self.enterRecursionRule(localctx, 42, self.RULE_num_expression, _p)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 482
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 48, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.ParenExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 460
                self.match(GrammarParser.T__27)
                self.state = 461
                self.num_expression(0)
                self.state = 462
                self.match(GrammarParser.T__28)
                pass

            elif la_ == 2:
                localctx = GrammarParser.LiteralExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 464
                self.num_literal()
                pass

            elif la_ == 3:
                localctx = GrammarParser.IdExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 465
                self.match(GrammarParser.ID)
                pass

            elif la_ == 4:
                localctx = GrammarParser.MathConstExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 466
                self.math_const()
                pass

            elif la_ == 5:
                localctx = GrammarParser.UnaryExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 467
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__29 or _la == GrammarParser.T__30):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 468
                self.num_expression(10)
                pass

            elif la_ == 6:
                localctx = GrammarParser.FuncExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 469
                localctx.function = self.match(GrammarParser.UFUNC_NAME)
                self.state = 470
                self.match(GrammarParser.T__27)
                self.state = 471
                self.num_expression(0)
                self.state = 472
                self.match(GrammarParser.T__28)
                pass

            elif la_ == 7:
                localctx = GrammarParser.ConditionalCStyleExprNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 474
                self.match(GrammarParser.T__27)
                self.state = 475
                self.cond_expression(0)
                self.state = 476
                self.match(GrammarParser.T__28)
                self.state = 477
                self.match(GrammarParser.T__38)
                self.state = 478
                self.num_expression(0)
                self.state = 479
                self.match(GrammarParser.T__11)
                self.state = 480
                self.num_expression(1)
                pass

            self._ctx.stop = self._input.LT(-1)
            self.state = 507
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 50, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 505
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input, 49, self._ctx)
                    if la_ == 1:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 484
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 9)"
                            )
                        self.state = 485
                        localctx.op = self.match(GrammarParser.T__31)
                        self.state = 486
                        self.num_expression(9)
                        pass

                    elif la_ == 2:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 487
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 8)"
                            )
                        self.state = 488
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            ((_la) & ~0x3F) == 0
                            and (
                                (1 << _la)
                                & (
                                    (1 << GrammarParser.T__18)
                                    | (1 << GrammarParser.T__32)
                                    | (1 << GrammarParser.T__33)
                                )
                            )
                            != 0
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 489
                        self.num_expression(9)
                        pass

                    elif la_ == 3:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 490
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 7)"
                            )
                        self.state = 491
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__29 or _la == GrammarParser.T__30
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 492
                        self.num_expression(8)
                        pass

                    elif la_ == 4:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 493
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 6)"
                            )
                        self.state = 494
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__25 or _la == GrammarParser.T__34
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 495
                        self.num_expression(7)
                        pass

                    elif la_ == 5:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 496
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 5)"
                            )
                        self.state = 497
                        localctx.op = self.match(GrammarParser.T__35)
                        self.state = 498
                        self.num_expression(6)
                        pass

                    elif la_ == 6:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 499
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 4)"
                            )
                        self.state = 500
                        localctx.op = self.match(GrammarParser.T__36)
                        self.state = 501
                        self.num_expression(5)
                        pass

                    elif la_ == 7:
                        localctx = GrammarParser.BinaryExprNumContext(
                            self,
                            GrammarParser.Num_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_num_expression
                        )
                        self.state = 502
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 3)"
                            )
                        self.state = 503
                        localctx.op = self.match(GrammarParser.T__37)
                        self.state = 504
                        self.num_expression(4)
                        pass

                self.state = 509
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 50, self._ctx)

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

    class Cond_expressionContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_cond_expression

        def copyFrom(self, ctx: ParserRuleContext):
            super().copyFrom(ctx)

    class BinaryExprFromCondCondContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def cond_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Cond_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, i)

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

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

    class BinaryExprCondContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def cond_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Cond_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, i)

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

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

    class BinaryExprFromNumCondContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def num_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Num_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Num_expressionContext, i)

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

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

    class UnaryExprCondContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.op = None  # Token
            self.copyFrom(ctx)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

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

    class ParenExprCondContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def cond_expression(self):
            return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, 0)

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

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

    class LiteralExprCondContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def bool_literal(self):
            return self.getTypedRuleContext(GrammarParser.Bool_literalContext, 0)

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

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

    class ConditionalCStyleCondNumContext(Cond_expressionContext):
        def __init__(
            self, parser, ctx: ParserRuleContext
        ):  # actually a GrammarParser.Cond_expressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def cond_expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(GrammarParser.Cond_expressionContext)
            else:
                return self.getTypedRuleContext(GrammarParser.Cond_expressionContext, i)

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

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

    def cond_expression(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = GrammarParser.Cond_expressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 44
        self.enterRecursionRule(localctx, 44, self.RULE_cond_expression, _p)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 534
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 51, self._ctx)
            if la_ == 1:
                localctx = GrammarParser.ParenExprCondContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 511
                self.match(GrammarParser.T__27)
                self.state = 512
                self.cond_expression(0)
                self.state = 513
                self.match(GrammarParser.T__28)
                pass

            elif la_ == 2:
                localctx = GrammarParser.LiteralExprCondContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 515
                self.bool_literal()
                pass

            elif la_ == 3:
                localctx = GrammarParser.UnaryExprCondContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 516
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__17 or _la == GrammarParser.T__39):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 517
                self.cond_expression(7)
                pass

            elif la_ == 4:
                localctx = GrammarParser.BinaryExprFromNumCondContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 518
                self.num_expression(0)
                self.state = 519
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << GrammarParser.T__40)
                            | (1 << GrammarParser.T__41)
                            | (1 << GrammarParser.T__42)
                            | (1 << GrammarParser.T__43)
                        )
                    )
                    != 0
                ):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 520
                self.num_expression(0)
                pass

            elif la_ == 5:
                localctx = GrammarParser.BinaryExprFromNumCondContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 522
                self.num_expression(0)
                self.state = 523
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == GrammarParser.T__44 or _la == GrammarParser.T__45):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 524
                self.num_expression(0)
                pass

            elif la_ == 6:
                localctx = GrammarParser.ConditionalCStyleCondNumContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 526
                self.match(GrammarParser.T__27)
                self.state = 527
                self.cond_expression(0)
                self.state = 528
                self.match(GrammarParser.T__28)
                self.state = 529
                self.match(GrammarParser.T__38)
                self.state = 530
                self.cond_expression(0)
                self.state = 531
                self.match(GrammarParser.T__11)
                self.state = 532
                self.cond_expression(1)
                pass

            self._ctx.stop = self._input.LT(-1)
            self.state = 547
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 53, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 545
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input, 52, self._ctx)
                    if la_ == 1:
                        localctx = GrammarParser.BinaryExprFromCondCondContext(
                            self,
                            GrammarParser.Cond_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_cond_expression
                        )
                        self.state = 536
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 4)"
                            )
                        self.state = 537
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__44 or _la == GrammarParser.T__45
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 538
                        self.cond_expression(5)
                        pass

                    elif la_ == 2:
                        localctx = GrammarParser.BinaryExprCondContext(
                            self,
                            GrammarParser.Cond_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_cond_expression
                        )
                        self.state = 539
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 3)"
                            )
                        self.state = 540
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__46 or _la == GrammarParser.T__47
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 541
                        self.cond_expression(4)
                        pass

                    elif la_ == 3:
                        localctx = GrammarParser.BinaryExprCondContext(
                            self,
                            GrammarParser.Cond_expressionContext(
                                self, _parentctx, _parentState
                            ),
                        )
                        self.pushNewRecursionContext(
                            localctx, _startState, self.RULE_cond_expression
                        )
                        self.state = 542
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(
                                self, "self.precpred(self._ctx, 2)"
                            )
                        self.state = 543
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            _la == GrammarParser.T__48 or _la == GrammarParser.T__49
                        ):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 544
                        self.cond_expression(3)
                        pass

                self.state = 549
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 53, self._ctx)

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

    class Num_literalContext(ParserRuleContext):
        __slots__ = "parser"

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

        def INT(self):
            return self.getToken(GrammarParser.INT, 0)

        def FLOAT(self):
            return self.getToken(GrammarParser.FLOAT, 0)

        def HEX_INT(self):
            return self.getToken(GrammarParser.HEX_INT, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_num_literal

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

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

    def num_literal(self):
        localctx = GrammarParser.Num_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_num_literal)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 550
            _la = self._input.LA(1)
            if not (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << GrammarParser.FLOAT)
                        | (1 << GrammarParser.INT)
                        | (1 << GrammarParser.HEX_INT)
                    )
                )
                != 0
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Bool_literalContext(ParserRuleContext):
        __slots__ = "parser"

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

        def TRUE(self):
            return self.getToken(GrammarParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(GrammarParser.FALSE, 0)

        def getRuleIndex(self):
            return GrammarParser.RULE_bool_literal

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

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

    def bool_literal(self):
        localctx = GrammarParser.Bool_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_bool_literal)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 552
            _la = self._input.LA(1)
            if not (_la == GrammarParser.TRUE or _la == GrammarParser.FALSE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Math_constContext(ParserRuleContext):
        __slots__ = "parser"

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

        def getRuleIndex(self):
            return GrammarParser.RULE_math_const

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

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

    def math_const(self):
        localctx = GrammarParser.Math_constContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_math_const)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 554
            _la = self._input.LA(1)
            if not (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << GrammarParser.T__50)
                        | (1 << GrammarParser.T__51)
                        | (1 << GrammarParser.T__52)
                    )
                )
                != 0
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class Chain_idContext(ParserRuleContext):
        __slots__ = "parser"

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

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

        def getRuleIndex(self):
            return GrammarParser.RULE_chain_id

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

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

    def chain_id(self):
        localctx = GrammarParser.Chain_idContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_chain_id)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 557
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == GrammarParser.T__32:
                self.state = 556
                localctx.isabs = self.match(GrammarParser.T__32)

            self.state = 559
            self.match(GrammarParser.ID)
            self.state = 564
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == GrammarParser.T__53:
                self.state = 560
                self.match(GrammarParser.T__53)
                self.state = 561
                self.match(GrammarParser.ID)
                self.state = 566
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[20] = self.init_expression_sempred
        self._predicates[21] = self.num_expression_sempred
        self._predicates[22] = self.cond_expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def init_expression_sempred(self, localctx: Init_expressionContext, predIndex: int):
        if predIndex == 0:
            return self.precpred(self._ctx, 8)

        if predIndex == 1:
            return self.precpred(self._ctx, 7)

        if predIndex == 2:
            return self.precpred(self._ctx, 6)

        if predIndex == 3:
            return self.precpred(self._ctx, 5)

        if predIndex == 4:
            return self.precpred(self._ctx, 4)

        if predIndex == 5:
            return self.precpred(self._ctx, 3)

        if predIndex == 6:
            return self.precpred(self._ctx, 2)

    def num_expression_sempred(self, localctx: Num_expressionContext, predIndex: int):
        if predIndex == 7:
            return self.precpred(self._ctx, 9)

        if predIndex == 8:
            return self.precpred(self._ctx, 8)

        if predIndex == 9:
            return self.precpred(self._ctx, 7)

        if predIndex == 10:
            return self.precpred(self._ctx, 6)

        if predIndex == 11:
            return self.precpred(self._ctx, 5)

        if predIndex == 12:
            return self.precpred(self._ctx, 4)

        if predIndex == 13:
            return self.precpred(self._ctx, 3)

    def cond_expression_sempred(self, localctx: Cond_expressionContext, predIndex: int):
        if predIndex == 14:
            return self.precpred(self._ctx, 4)

        if predIndex == 15:
            return self.precpred(self._ctx, 3)

        if predIndex == 16:
            return self.precpred(self._ctx, 2)