# Generated from lang.g4 by ANTLR 4.7.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
from typing.io import TextIO
import sys

def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3;")
        buf.write("\u01b4\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \3\2\3\2\3\2\3\2\3\2\3\2\5\2G\n\2\3\3")
        buf.write("\3\3\3\3\3\3\7\3M\n\3\f\3\16\3P\13\3\3\3\3\3\5\3T\n\3")
        buf.write("\3\3\3\3\3\3\3\3\5\3Z\n\3\3\3\3\3\3\3\3\3\3\3\5\3a\n\3")
        buf.write("\3\3\3\3\3\3\3\3\5\3g\n\3\3\3\3\3\3\3\6\3l\n\3\r\3\16")
        buf.write("\3m\3\3\5\3q\n\3\5\3s\n\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5")
        buf.write("\3\5\7\5}\n\5\f\5\16\5\u0080\13\5\3\5\3\5\3\5\3\5\5\5")
        buf.write("\u0086\n\5\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u008e\n\6\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\5\7\u0096\n\7\3\b\3\b\3\b\3\b\7\b\u009c")
        buf.write("\n\b\f\b\16\b\u009f\13\b\3\b\3\b\3\b\3\b\5\b\u00a5\n\b")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00ad\n\t\3\n\3\n\5\n\u00b1")
        buf.write("\n\n\3\n\3\n\7\n\u00b5\n\n\f\n\16\n\u00b8\13\n\3\n\3\n")
        buf.write("\3\13\3\13\3\13\3\13\3\13\3\f\3\f\5\f\u00c3\n\f\3\f\3")
        buf.write("\f\7\f\u00c7\n\f\f\f\16\f\u00ca\13\f\3\f\3\f\3\r\3\r\3")
        buf.write("\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
        buf.write("\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3")
        buf.write("\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
        buf.write("\5\r\u00f9\n\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
        buf.write("\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3")
        buf.write("\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
        buf.write("\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3")
        buf.write("\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u0134\n\r\f\r\16\r\u0137")
        buf.write("\13\r\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22")
        buf.write("\3\22\3\22\3\22\3\22\3\22\5\22\u0148\n\22\3\23\3\23\3")
        buf.write("\23\3\23\3\23\7\23\u014f\n\23\f\23\16\23\u0152\13\23\3")
        buf.write("\23\3\23\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25")
        buf.write("\3\25\7\25\u0160\n\25\f\25\16\25\u0163\13\25\3\25\3\25")
        buf.write("\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\5\31\u0175\n\31\3\31\3\31\3\32\3\32\3")
        buf.write("\32\3\32\3\32\3\32\5\32\u017f\n\32\3\32\3\32\3\32\3\32")
        buf.write("\5\32\u0185\n\32\3\32\5\32\u0188\n\32\3\33\3\33\3\33\5")
        buf.write("\33\u018d\n\33\3\33\5\33\u0190\n\33\3\33\3\33\5\33\u0194")
        buf.write("\n\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
        buf.write("\3\34\3\34\3\34\3\34\5\34\u01a4\n\34\3\35\3\35\3\35\5")
        buf.write("\35\u01a9\n\35\3\36\3\36\3\37\3\37\5\37\u01af\n\37\3 ")
        buf.write("\3 \3 \3 \2\3\30!\2\4\6\b\n\f\16\20\22\24\26\30\32\34")
        buf.write("\36 \"$&(*,.\60\62\64\668:<>\2\2\2\u01ea\2F\3\2\2\2\4")
        buf.write("r\3\2\2\2\6t\3\2\2\2\b\u0085\3\2\2\2\n\u008d\3\2\2\2\f")
        buf.write("\u0095\3\2\2\2\16\u00a4\3\2\2\2\20\u00ac\3\2\2\2\22\u00ae")
        buf.write("\3\2\2\2\24\u00bb\3\2\2\2\26\u00c0\3\2\2\2\30\u00f8\3")
        buf.write("\2\2\2\32\u0138\3\2\2\2\34\u013a\3\2\2\2\36\u013c\3\2")
        buf.write("\2\2 \u013e\3\2\2\2\"\u0140\3\2\2\2$\u0149\3\2\2\2&\u0155")
        buf.write("\3\2\2\2(\u015a\3\2\2\2*\u0166\3\2\2\2,\u0168\3\2\2\2")
        buf.write(".\u016b\3\2\2\2\60\u016e\3\2\2\2\62\u0178\3\2\2\2\64\u0189")
        buf.write("\3\2\2\2\66\u01a3\3\2\2\28\u01a8\3\2\2\2:\u01aa\3\2\2")
        buf.write("\2<\u01ac\3\2\2\2>\u01b0\3\2\2\2@A\5\f\7\2AB\7\2\2\3B")
        buf.write("G\3\2\2\2CD\5\4\3\2DE\7\2\2\3EG\3\2\2\2F@\3\2\2\2FC\3")
        buf.write("\2\2\2G\3\3\2\2\2HI\5\30\r\2IN\5\6\4\2JK\7\3\2\2KM\5\6")
        buf.write("\4\2LJ\3\2\2\2MP\3\2\2\2NL\3\2\2\2NO\3\2\2\2OQ\3\2\2\2")
        buf.write("PN\3\2\2\2QS\7\4\2\2RT\5\4\3\2SR\3\2\2\2ST\3\2\2\2Ts\3")
        buf.write("\2\2\2UV\7\5\2\2VW\5\6\4\2WY\7\4\2\2XZ\5\4\3\2YX\3\2\2")
        buf.write("\2YZ\3\2\2\2Zs\3\2\2\2[\\\7\6\2\2\\]\5\30\r\2]^\78\2\2")
        buf.write("^`\7\4\2\2_a\5\4\3\2`_\3\2\2\2`a\3\2\2\2as\3\2\2\2bc\7")
        buf.write("\7\2\2cd\78\2\2df\7\4\2\2eg\5\4\3\2fe\3\2\2\2fg\3\2\2")
        buf.write("\2gs\3\2\2\2hi\5\30\r\2ij\7\4\2\2jl\3\2\2\2kh\3\2\2\2")
        buf.write("lm\3\2\2\2mk\3\2\2\2mn\3\2\2\2np\3\2\2\2oq\5\4\3\2po\3")
        buf.write("\2\2\2pq\3\2\2\2qs\3\2\2\2rH\3\2\2\2rU\3\2\2\2r[\3\2\2")
        buf.write("\2rb\3\2\2\2rk\3\2\2\2s\5\3\2\2\2tu\78\2\2uv\7\b\2\2v")
        buf.write("w\5\30\r\2w\7\3\2\2\2xy\7\t\2\2y~\5\n\6\2z{\7\3\2\2{}")
        buf.write("\5\n\6\2|z\3\2\2\2}\u0080\3\2\2\2~|\3\2\2\2~\177\3\2\2")
        buf.write("\2\177\u0081\3\2\2\2\u0080~\3\2\2\2\u0081\u0082\7\n\2")
        buf.write("\2\u0082\u0086\3\2\2\2\u0083\u0084\7\t\2\2\u0084\u0086")
        buf.write("\7\n\2\2\u0085x\3\2\2\2\u0085\u0083\3\2\2\2\u0086\t\3")
        buf.write("\2\2\2\u0087\u0088\78\2\2\u0088\u0089\7\13\2\2\u0089\u008e")
        buf.write("\5\30\r\2\u008a\u008b\79\2\2\u008b\u008c\7\13\2\2\u008c")
        buf.write("\u008e\5\30\r\2\u008d\u0087\3\2\2\2\u008d\u008a\3\2\2")
        buf.write("\2\u008e\13\3\2\2\2\u008f\u0096\79\2\2\u0090\u0096\7:")
        buf.write("\2\2\u0091\u0096\5\16\b\2\u0092\u0096\5\22\n\2\u0093\u0096")
        buf.write("\5\64\33\2\u0094\u0096\5\24\13\2\u0095\u008f\3\2\2\2\u0095")
        buf.write("\u0090\3\2\2\2\u0095\u0091\3\2\2\2\u0095\u0092\3\2\2\2")
        buf.write("\u0095\u0093\3\2\2\2\u0095\u0094\3\2\2\2\u0096\r\3\2\2")
        buf.write("\2\u0097\u0098\7\t\2\2\u0098\u009d\5\20\t\2\u0099\u009a")
        buf.write("\7\3\2\2\u009a\u009c\5\20\t\2\u009b\u0099\3\2\2\2\u009c")
        buf.write("\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2")
        buf.write("\u009e\u00a0\3\2\2\2\u009f\u009d\3\2\2\2\u00a0\u00a1\7")
        buf.write("\n\2\2\u00a1\u00a5\3\2\2\2\u00a2\u00a3\7\t\2\2\u00a3\u00a5")
        buf.write("\7\n\2\2\u00a4\u0097\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5")
        buf.write("\17\3\2\2\2\u00a6\u00a7\78\2\2\u00a7\u00a8\7\13\2\2\u00a8")
        buf.write("\u00ad\5\f\7\2\u00a9\u00aa\79\2\2\u00aa\u00ab\7\13\2\2")
        buf.write("\u00ab\u00ad\5\f\7\2\u00ac\u00a6\3\2\2\2\u00ac\u00a9\3")
        buf.write("\2\2\2\u00ad\21\3\2\2\2\u00ae\u00b0\7\f\2\2\u00af\u00b1")
        buf.write("\5\f\7\2\u00b0\u00af\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1")
        buf.write("\u00b6\3\2\2\2\u00b2\u00b3\7\3\2\2\u00b3\u00b5\5\f\7\2")
        buf.write("\u00b4\u00b2\3\2\2\2\u00b5\u00b8\3\2\2\2\u00b6\u00b4\3")
        buf.write("\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b9\3\2\2\2\u00b8\u00b6")
        buf.write("\3\2\2\2\u00b9\u00ba\7\r\2\2\u00ba\23\3\2\2\2\u00bb\u00bc")
        buf.write("\7\16\2\2\u00bc\u00bd\7\17\2\2\u00bd\u00be\5\30\r\2\u00be")
        buf.write("\u00bf\7\20\2\2\u00bf\25\3\2\2\2\u00c0\u00c2\7\f\2\2\u00c1")
        buf.write("\u00c3\5\30\r\2\u00c2\u00c1\3\2\2\2\u00c2\u00c3\3\2\2")
        buf.write("\2\u00c3\u00c8\3\2\2\2\u00c4\u00c5\7\3\2\2\u00c5\u00c7")
        buf.write("\5\30\r\2\u00c6\u00c4\3\2\2\2\u00c7\u00ca\3\2\2\2\u00c8")
        buf.write("\u00c6\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00cb\3\2\2\2")
        buf.write("\u00ca\u00c8\3\2\2\2\u00cb\u00cc\7\r\2\2\u00cc\27\3\2")
        buf.write("\2\2\u00cd\u00ce\b\r\1\2\u00ce\u00f9\78\2\2\u00cf\u00d0")
        buf.write("\7\22\2\2\u00d0\u00d1\5\30\r\2\u00d1\u00d2\7\23\2\2\u00d2")
        buf.write("\u00f9\3\2\2\2\u00d3\u00d4\7\17\2\2\u00d4\u00d5\5\30\r")
        buf.write("\2\u00d5\u00d6\7\20\2\2\u00d6\u00f9\3\2\2\2\u00d7\u00d8")
        buf.write("\7\24\2\2\u00d8\u00f9\5\30\r(\u00d9\u00da\7\25\2\2\u00da")
        buf.write("\u00f9\5\30\r\'\u00db\u00f9\79\2\2\u00dc\u00f9\7:\2\2")
        buf.write("\u00dd\u00f9\5\60\31\2\u00de\u00f9\5\62\32\2\u00df\u00e0")
        buf.write("\7\37\2\2\u00e0\u00e1\7\17\2\2\u00e1\u00e2\5\f\7\2\u00e2")
        buf.write("\u00e3\7\20\2\2\u00e3\u00f9\3\2\2\2\u00e4\u00e5\7 \2\2")
        buf.write("\u00e5\u00f9\5\64\33\2\u00e6\u00f9\5\64\33\2\u00e7\u00f9")
        buf.write("\5\b\5\2\u00e8\u00f9\5\26\f\2\u00e9\u00f9\7!\2\2\u00ea")
        buf.write("\u00f9\7\"\2\2\u00eb\u00f9\7#\2\2\u00ec\u00f9\5\32\16")
        buf.write("\2\u00ed\u00f9\5\36\20\2\u00ee\u00f9\5\34\17\2\u00ef\u00f9")
        buf.write("\5 \21\2\u00f0\u00f9\5\"\22\2\u00f1\u00f9\5$\23\2\u00f2")
        buf.write("\u00f9\5(\25\2\u00f3\u00f9\5&\24\2\u00f4\u00f9\5*\26\2")
        buf.write("\u00f5\u00f9\5,\27\2\u00f6\u00f9\5<\37\2\u00f7\u00f9\5")
        buf.write("> \2\u00f8\u00cd\3\2\2\2\u00f8\u00cf\3\2\2\2\u00f8\u00d3")
        buf.write("\3\2\2\2\u00f8\u00d7\3\2\2\2\u00f8\u00d9\3\2\2\2\u00f8")
        buf.write("\u00db\3\2\2\2\u00f8\u00dc\3\2\2\2\u00f8\u00dd\3\2\2\2")
        buf.write("\u00f8\u00de\3\2\2\2\u00f8\u00df\3\2\2\2\u00f8\u00e4\3")
        buf.write("\2\2\2\u00f8\u00e6\3\2\2\2\u00f8\u00e7\3\2\2\2\u00f8\u00e8")
        buf.write("\3\2\2\2\u00f8\u00e9\3\2\2\2\u00f8\u00ea\3\2\2\2\u00f8")
        buf.write("\u00eb\3\2\2\2\u00f8\u00ec\3\2\2\2\u00f8\u00ed\3\2\2\2")
        buf.write("\u00f8\u00ee\3\2\2\2\u00f8\u00ef\3\2\2\2\u00f8\u00f0\3")
        buf.write("\2\2\2\u00f8\u00f1\3\2\2\2\u00f8\u00f2\3\2\2\2\u00f8\u00f3")
        buf.write("\3\2\2\2\u00f8\u00f4\3\2\2\2\u00f8\u00f5\3\2\2\2\u00f8")
        buf.write("\u00f6\3\2\2\2\u00f8\u00f7\3\2\2\2\u00f9\u0135\3\2\2\2")
        buf.write("\u00fa\u00fb\f&\2\2\u00fb\u00fc\7\26\2\2\u00fc\u0134\5")
        buf.write("\30\r\'\u00fd\u00fe\f%\2\2\u00fe\u00ff\7\27\2\2\u00ff")
        buf.write("\u0134\5\30\r&\u0100\u0101\f$\2\2\u0101\u0102\7\24\2\2")
        buf.write("\u0102\u0134\5\30\r%\u0103\u0104\f#\2\2\u0104\u0105\7")
        buf.write("\25\2\2\u0105\u0134\5\30\r$\u0106\u0107\f\"\2\2\u0107")
        buf.write("\u0108\7\30\2\2\u0108\u0134\5\30\r#\u0109\u010a\f!\2\2")
        buf.write("\u010a\u010b\7\31\2\2\u010b\u0134\5\30\r\"\u010c\u010d")
        buf.write("\f \2\2\u010d\u010e\7\32\2\2\u010e\u0134\5\30\r!\u010f")
        buf.write("\u0110\f\37\2\2\u0110\u0111\7\33\2\2\u0111\u0134\5\30")
        buf.write("\r \u0112\u0113\f\36\2\2\u0113\u0114\7\34\2\2\u0114\u0134")
        buf.write("\5\30\r\37\u0115\u0116\f\35\2\2\u0116\u0117\7\35\2\2\u0117")
        buf.write("\u0134\5\30\r\36\u0118\u0119\f\34\2\2\u0119\u011a\7\36")
        buf.write("\2\2\u011a\u0134\5\30\r\35\u011b\u011c\f\33\2\2\u011c")
        buf.write("\u011d\7\b\2\2\u011d\u0134\5\30\r\34\u011e\u011f\f\60")
        buf.write("\2\2\u011f\u0120\7\21\2\2\u0120\u0134\78\2\2\u0121\u0122")
        buf.write("\f/\2\2\u0122\u0123\7\f\2\2\u0123\u0124\5\30\r\2\u0124")
        buf.write("\u0125\7\r\2\2\u0125\u0134\3\2\2\2\u0126\u0127\f-\2\2")
        buf.write("\u0127\u0128\7\17\2\2\u0128\u0134\7\20\2\2\u0129\u012a")
        buf.write("\f,\2\2\u012a\u012b\7\17\2\2\u012b\u012c\5\30\r\2\u012c")
        buf.write("\u012d\7\20\2\2\u012d\u0134\3\2\2\2\u012e\u012f\f+\2\2")
        buf.write("\u012f\u0130\7\22\2\2\u0130\u0131\5\30\r\2\u0131\u0132")
        buf.write("\7\23\2\2\u0132\u0134\3\2\2\2\u0133\u00fa\3\2\2\2\u0133")
        buf.write("\u00fd\3\2\2\2\u0133\u0100\3\2\2\2\u0133\u0103\3\2\2\2")
        buf.write("\u0133\u0106\3\2\2\2\u0133\u0109\3\2\2\2\u0133\u010c\3")
        buf.write("\2\2\2\u0133\u010f\3\2\2\2\u0133\u0112\3\2\2\2\u0133\u0115")
        buf.write("\3\2\2\2\u0133\u0118\3\2\2\2\u0133\u011b\3\2\2\2\u0133")
        buf.write("\u011e\3\2\2\2\u0133\u0121\3\2\2\2\u0133\u0126\3\2\2\2")
        buf.write("\u0133\u0129\3\2\2\2\u0133\u012e\3\2\2\2\u0134\u0137\3")
        buf.write("\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2\u0136\31")
        buf.write("\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u0139\7$\2\2\u0139")
        buf.write("\33\3\2\2\2\u013a\u013b\7%\2\2\u013b\35\3\2\2\2\u013c")
        buf.write("\u013d\7&\2\2\u013d\37\3\2\2\2\u013e\u013f\7\'\2\2\u013f")
        buf.write("!\3\2\2\2\u0140\u0141\7(\2\2\u0141\u0142\7\22\2\2\u0142")
        buf.write("\u0143\5\30\r\2\u0143\u0144\7)\2\2\u0144\u0145\5\30\r")
        buf.write("\2\u0145\u0147\7\23\2\2\u0146\u0148\5:\36\2\u0147\u0146")
        buf.write("\3\2\2\2\u0147\u0148\3\2\2\2\u0148#\3\2\2\2\u0149\u014a")
        buf.write("\7*\2\2\u014a\u0150\7\t\2\2\u014b\u014c\5.\30\2\u014c")
        buf.write("\u014d\7\4\2\2\u014d\u014f\3\2\2\2\u014e\u014b\3\2\2\2")
        buf.write("\u014f\u0152\3\2\2\2\u0150\u014e\3\2\2\2\u0150\u0151\3")
        buf.write("\2\2\2\u0151\u0153\3\2\2\2\u0152\u0150\3\2\2\2\u0153\u0154")
        buf.write("\7\n\2\2\u0154%\3\2\2\2\u0155\u0156\7+\2\2\u0156\u0157")
        buf.write("\7\22\2\2\u0157\u0158\5\30\r\2\u0158\u0159\7\23\2\2\u0159")
        buf.write("\'\3\2\2\2\u015a\u015b\7,\2\2\u015b\u015c\7\22\2\2\u015c")
        buf.write("\u0161\5\30\r\2\u015d\u015e\7\3\2\2\u015e\u0160\5\30\r")
        buf.write("\2\u015f\u015d\3\2\2\2\u0160\u0163\3\2\2\2\u0161\u015f")
        buf.write("\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0164\3\2\2\2\u0163")
        buf.write("\u0161\3\2\2\2\u0164\u0165\7\23\2\2\u0165)\3\2\2\2\u0166")
        buf.write("\u0167\7-\2\2\u0167+\3\2\2\2\u0168\u0169\7.\2\2\u0169")
        buf.write("\u016a\5\30\r\2\u016a-\3\2\2\2\u016b\u016c\5\30\r\2\u016c")
        buf.write("\u016d\78\2\2\u016d/\3\2\2\2\u016e\u016f\7/\2\2\u016f")
        buf.write("\u0170\7\17\2\2\u0170\u0171\5\30\r\2\u0171\u0172\7\20")
        buf.write("\2\2\u0172\u0174\7\t\2\2\u0173\u0175\5\4\3\2\u0174\u0173")
        buf.write("\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u0176\3\2\2\2\u0176")
        buf.write("\u0177\7\n\2\2\u0177\61\3\2\2\2\u0178\u0179\7\60\2\2\u0179")
        buf.write("\u017a\7\17\2\2\u017a\u017b\5\30\r\2\u017b\u017c\7\20")
        buf.write("\2\2\u017c\u017e\7\t\2\2\u017d\u017f\5\4\3\2\u017e\u017d")
        buf.write("\3\2\2\2\u017e\u017f\3\2\2\2\u017f\u0180\3\2\2\2\u0180")
        buf.write("\u0187\7\n\2\2\u0181\u0182\7\61\2\2\u0182\u0184\7\t\2")
        buf.write("\2\u0183\u0185\5\4\3\2\u0184\u0183\3\2\2\2\u0184\u0185")
        buf.write("\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0188\7\n\2\2\u0187")
        buf.write("\u0181\3\2\2\2\u0187\u0188\3\2\2\2\u0188\63\3\2\2\2\u0189")
        buf.write("\u018a\7\62\2\2\u018a\u018c\5\66\34\2\u018b\u018d\58\35")
        buf.write("\2\u018c\u018b\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f")
        buf.write("\3\2\2\2\u018e\u0190\5:\36\2\u018f\u018e\3\2\2\2\u018f")
        buf.write("\u0190\3\2\2\2\u0190\u0191\3\2\2\2\u0191\u0193\7\t\2\2")
        buf.write("\u0192\u0194\5\4\3\2\u0193\u0192\3\2\2\2\u0193\u0194\3")
        buf.write("\2\2\2\u0194\u0195\3\2\2\2\u0195\u0196\7\n\2\2\u0196\65")
        buf.write("\3\2\2\2\u0197\u0198\7\17\2\2\u0198\u01a4\7\20\2\2\u0199")
        buf.write("\u019a\7\17\2\2\u019a\u019b\5\30\r\2\u019b\u019c\7\20")
        buf.write("\2\2\u019c\u01a4\3\2\2\2\u019d\u019e\7\17\2\2\u019e\u019f")
        buf.write("\5\30\r\2\u019f\u01a0\7)\2\2\u01a0\u01a1\5\30\r\2\u01a1")
        buf.write("\u01a2\7\20\2\2\u01a2\u01a4\3\2\2\2\u01a3\u0197\3\2\2")
        buf.write("\2\u01a3\u0199\3\2\2\2\u01a3\u019d\3\2\2\2\u01a4\67\3")
        buf.write("\2\2\2\u01a5\u01a9\7\63\2\2\u01a6\u01a7\7\64\2\2\u01a7")
        buf.write("\u01a9\5\30\r\2\u01a8\u01a5\3\2\2\2\u01a8\u01a6\3\2\2")
        buf.write("\2\u01a99\3\2\2\2\u01aa\u01ab\7\65\2\2\u01ab;\3\2\2\2")
        buf.write("\u01ac\u01ae\7\66\2\2\u01ad\u01af\5\30\r\2\u01ae\u01ad")
        buf.write("\3\2\2\2\u01ae\u01af\3\2\2\2\u01af=\3\2\2\2\u01b0\u01b1")
        buf.write("\7\67\2\2\u01b1\u01b2\5\30\r\2\u01b2?\3\2\2\2&FNSY`fm")
        buf.write("pr~\u0085\u008d\u0095\u009d\u00a4\u00ac\u00b0\u00b6\u00c2")
        buf.write("\u00c8\u00f8\u0133\u0135\u0147\u0150\u0161\u0174\u017e")
        buf.write("\u0184\u0187\u018c\u018f\u0193\u01a3\u01a8\u01ae")
        return buf.getvalue()


class langParser ( Parser ):

    grammarFileName = "lang.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "','", "';'", "'static'", "'typedef'", 
                     "'import'", "'='", "'{'", "'}'", "':'", "'['", "']'", 
                     "'code'", "'('", "')'", "'.'", "'<'", "'>'", "'+'", 
                     "'-'", "'*'", "'/'", "'%'", "'>='", "'<='", "' < '", 
                     "' > '", "'=='", "'!='", "'exec'", "'dynamic'", "'true'", 
                     "'false'", "'null'", "'Void'", "'var'", "'Integer'", 
                     "'String'", "'Function'", "'=>'", "'Object'", "'List'", 
                     "'Tuple'", "'Any'", "'const'", "'while'", "'if'", "'else'", 
                     "'function'", "'nothrow'", "'throws'", "'noexit'", 
                     "'return'", "'exit'" ]

    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>", "SYMBOL", "STRING", "NUMBER", 
                      "WS" ]

    RULE_code = 0
    RULE_functionStub = 1
    RULE_symbolInitialization = 2
    RULE_newObject = 3
    RULE_pair = 4
    RULE_literal = 5
    RULE_objectLiteral = 6
    RULE_literalPair = 7
    RULE_tupleLiteral = 8
    RULE_expressionLiteral = 9
    RULE_newTuple = 10
    RULE_expression = 11
    RULE_voidType = 12
    RULE_inferredType = 13
    RULE_integerType = 14
    RULE_stringType = 15
    RULE_functionType = 16
    RULE_objectType = 17
    RULE_listType = 18
    RULE_tupleType = 19
    RULE_anyType = 20
    RULE_constTypeModifier = 21
    RULE_propertyType = 22
    RULE_whileLoop = 23
    RULE_ifBlock = 24
    RULE_functionLiteral = 25
    RULE_functionArgumentAndReturns = 26
    RULE_functionThrows = 27
    RULE_functionExits = 28
    RULE_returnExpression = 29
    RULE_exitExpression = 30

    ruleNames =  [ "code", "functionStub", "symbolInitialization", "newObject", 
                   "pair", "literal", "objectLiteral", "literalPair", "tupleLiteral", 
                   "expressionLiteral", "newTuple", "expression", "voidType", 
                   "inferredType", "integerType", "stringType", "functionType", 
                   "objectType", "listType", "tupleType", "anyType", "constTypeModifier", 
                   "propertyType", "whileLoop", "ifBlock", "functionLiteral", 
                   "functionArgumentAndReturns", "functionThrows", "functionExits", 
                   "returnExpression", "exitExpression" ]

    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
    SYMBOL=54
    STRING=55
    NUMBER=56
    WS=57

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



    class CodeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_code

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



    class ToFunctionStubContext(CodeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.CodeContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)

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

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToFunctionStub" ):
                return visitor.visitToFunctionStub(self)
            else:
                return visitor.visitChildren(self)


    class ToLiteralContext(CodeContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.CodeContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def literal(self):
            return self.getTypedRuleContext(langParser.LiteralContext,0)

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

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToLiteral" ):
                return visitor.visitToLiteral(self)
            else:
                return visitor.visitChildren(self)



    def code(self):

        localctx = langParser.CodeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_code)
        try:
            self.state = 68
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                localctx = langParser.ToLiteralContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 62
                self.literal()
                self.state = 63
                self.match(langParser.EOF)
                pass

            elif la_ == 2:
                localctx = langParser.ToFunctionStubContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 65
                self.functionStub()
                self.state = 66
                self.match(langParser.EOF)
                pass


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

    class FunctionStubContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_functionStub

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



    class LocalVariableDeclarationContext(FunctionStubContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.FunctionStubContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)

        def symbolInitialization(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.SymbolInitializationContext)
            else:
                return self.getTypedRuleContext(langParser.SymbolInitializationContext,i)

        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLocalVariableDeclaration" ):
                return visitor.visitLocalVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)


    class ImportStatementContext(FunctionStubContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.FunctionStubContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)
        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImportStatement" ):
                return visitor.visitImportStatement(self)
            else:
                return visitor.visitChildren(self)


    class ToExpressionContext(FunctionStubContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.FunctionStubContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)

        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToExpression" ):
                return visitor.visitToExpression(self)
            else:
                return visitor.visitChildren(self)


    class StaticValueDeclarationContext(FunctionStubContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.FunctionStubContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def symbolInitialization(self):
            return self.getTypedRuleContext(langParser.SymbolInitializationContext,0)

        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticValueDeclaration" ):
                return visitor.visitStaticValueDeclaration(self)
            else:
                return visitor.visitChildren(self)


    class TypedefContext(FunctionStubContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.FunctionStubContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)
        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypedef" ):
                return visitor.visitTypedef(self)
            else:
                return visitor.visitChildren(self)



    def functionStub(self):

        localctx = langParser.FunctionStubContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_functionStub)
        self._la = 0 # Token type
        try:
            self.state = 112
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                localctx = langParser.LocalVariableDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 70
                self.expression(0)
                self.state = 71
                self.symbolInitialization()
                self.state = 76
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==langParser.T__0:
                    self.state = 72
                    self.match(langParser.T__0)
                    self.state = 73
                    self.symbolInitialization()
                    self.state = 78
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 79
                self.match(langParser.T__1)
                self.state = 81
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                    self.state = 80
                    self.functionStub()


                pass

            elif la_ == 2:
                localctx = langParser.StaticValueDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 83
                self.match(langParser.T__2)
                self.state = 84
                self.symbolInitialization()
                self.state = 85
                self.match(langParser.T__1)
                self.state = 87
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                    self.state = 86
                    self.functionStub()


                pass

            elif la_ == 3:
                localctx = langParser.TypedefContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 89
                self.match(langParser.T__3)
                self.state = 90
                self.expression(0)
                self.state = 91
                self.match(langParser.SYMBOL)
                self.state = 92
                self.match(langParser.T__1)
                self.state = 94
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                    self.state = 93
                    self.functionStub()


                pass

            elif la_ == 4:
                localctx = langParser.ImportStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 96
                self.match(langParser.T__4)
                self.state = 97
                self.match(langParser.SYMBOL)
                self.state = 98
                self.match(langParser.T__1)
                self.state = 100
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                    self.state = 99
                    self.functionStub()


                pass

            elif la_ == 5:
                localctx = langParser.ToExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 105 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 102
                        self.expression(0)
                        self.state = 103
                        self.match(langParser.T__1)

                    else:
                        raise NoViableAltException(self)
                    self.state = 107 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,6,self._ctx)

                self.state = 110
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                    self.state = 109
                    self.functionStub()


                pass


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

    class SymbolInitializationContext(ParserRuleContext):

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

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_symbolInitialization

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSymbolInitialization" ):
                return visitor.visitSymbolInitialization(self)
            else:
                return visitor.visitChildren(self)




    def symbolInitialization(self):

        localctx = langParser.SymbolInitializationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_symbolInitialization)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 114
            self.match(langParser.SYMBOL)
            self.state = 115
            self.match(langParser.T__5)
            self.state = 116
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class NewObjectContext(ParserRuleContext):

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

        def pair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.PairContext)
            else:
                return self.getTypedRuleContext(langParser.PairContext,i)


        def getRuleIndex(self):
            return langParser.RULE_newObject

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewObject" ):
                return visitor.visitNewObject(self)
            else:
                return visitor.visitChildren(self)




    def newObject(self):

        localctx = langParser.NewObjectContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_newObject)
        self._la = 0 # Token type
        try:
            self.state = 131
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 118
                self.match(langParser.T__6)
                self.state = 119
                self.pair()
                self.state = 124
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==langParser.T__0:
                    self.state = 120
                    self.match(langParser.T__0)
                    self.state = 121
                    self.pair()
                    self.state = 126
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 127
                self.match(langParser.T__7)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 129
                self.match(langParser.T__6)
                self.state = 130
                self.match(langParser.T__7)
                pass


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

    class PairContext(ParserRuleContext):

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

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def STRING(self):
            return self.getToken(langParser.STRING, 0)

        def getRuleIndex(self):
            return langParser.RULE_pair

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPair" ):
                return visitor.visitPair(self)
            else:
                return visitor.visitChildren(self)




    def pair(self):

        localctx = langParser.PairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_pair)
        try:
            self.state = 139
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [langParser.SYMBOL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 133
                self.match(langParser.SYMBOL)
                self.state = 134
                self.match(langParser.T__8)
                self.state = 135
                self.expression(0)
                pass
            elif token in [langParser.STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 136
                self.match(langParser.STRING)
                self.state = 137
                self.match(langParser.T__8)
                self.state = 138
                self.expression(0)
                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 LiteralContext(ParserRuleContext):

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

        def STRING(self):
            return self.getToken(langParser.STRING, 0)

        def NUMBER(self):
            return self.getToken(langParser.NUMBER, 0)

        def objectLiteral(self):
            return self.getTypedRuleContext(langParser.ObjectLiteralContext,0)


        def tupleLiteral(self):
            return self.getTypedRuleContext(langParser.TupleLiteralContext,0)


        def functionLiteral(self):
            return self.getTypedRuleContext(langParser.FunctionLiteralContext,0)


        def expressionLiteral(self):
            return self.getTypedRuleContext(langParser.ExpressionLiteralContext,0)


        def getRuleIndex(self):
            return langParser.RULE_literal

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral" ):
                return visitor.visitLiteral(self)
            else:
                return visitor.visitChildren(self)




    def literal(self):

        localctx = langParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_literal)
        try:
            self.state = 147
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [langParser.STRING]:
                self.enterOuterAlt(localctx, 1)
                self.state = 141
                self.match(langParser.STRING)
                pass
            elif token in [langParser.NUMBER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 142
                self.match(langParser.NUMBER)
                pass
            elif token in [langParser.T__6]:
                self.enterOuterAlt(localctx, 3)
                self.state = 143
                self.objectLiteral()
                pass
            elif token in [langParser.T__9]:
                self.enterOuterAlt(localctx, 4)
                self.state = 144
                self.tupleLiteral()
                pass
            elif token in [langParser.T__47]:
                self.enterOuterAlt(localctx, 5)
                self.state = 145
                self.functionLiteral()
                pass
            elif token in [langParser.T__11]:
                self.enterOuterAlt(localctx, 6)
                self.state = 146
                self.expressionLiteral()
                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 ObjectLiteralContext(ParserRuleContext):

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

        def literalPair(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.LiteralPairContext)
            else:
                return self.getTypedRuleContext(langParser.LiteralPairContext,i)


        def getRuleIndex(self):
            return langParser.RULE_objectLiteral

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectLiteral" ):
                return visitor.visitObjectLiteral(self)
            else:
                return visitor.visitChildren(self)




    def objectLiteral(self):

        localctx = langParser.ObjectLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_objectLiteral)
        self._la = 0 # Token type
        try:
            self.state = 162
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 149
                self.match(langParser.T__6)
                self.state = 150
                self.literalPair()
                self.state = 155
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==langParser.T__0:
                    self.state = 151
                    self.match(langParser.T__0)
                    self.state = 152
                    self.literalPair()
                    self.state = 157
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 158
                self.match(langParser.T__7)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 160
                self.match(langParser.T__6)
                self.state = 161
                self.match(langParser.T__7)
                pass


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

    class LiteralPairContext(ParserRuleContext):

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

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)

        def literal(self):
            return self.getTypedRuleContext(langParser.LiteralContext,0)


        def STRING(self):
            return self.getToken(langParser.STRING, 0)

        def getRuleIndex(self):
            return langParser.RULE_literalPair

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteralPair" ):
                return visitor.visitLiteralPair(self)
            else:
                return visitor.visitChildren(self)




    def literalPair(self):

        localctx = langParser.LiteralPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_literalPair)
        try:
            self.state = 170
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [langParser.SYMBOL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 164
                self.match(langParser.SYMBOL)
                self.state = 165
                self.match(langParser.T__8)
                self.state = 166
                self.literal()
                pass
            elif token in [langParser.STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 167
                self.match(langParser.STRING)
                self.state = 168
                self.match(langParser.T__8)
                self.state = 169
                self.literal()
                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 TupleLiteralContext(ParserRuleContext):

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

        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.LiteralContext)
            else:
                return self.getTypedRuleContext(langParser.LiteralContext,i)


        def getRuleIndex(self):
            return langParser.RULE_tupleLiteral

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTupleLiteral" ):
                return visitor.visitTupleLiteral(self)
            else:
                return visitor.visitChildren(self)




    def tupleLiteral(self):

        localctx = langParser.TupleLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_tupleLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 172
            self.match(langParser.T__9)
            self.state = 174
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__11) | (1 << langParser.T__47) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                self.state = 173
                self.literal()


            self.state = 180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==langParser.T__0:
                self.state = 176
                self.match(langParser.T__0)
                self.state = 177
                self.literal()
                self.state = 182
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 183
            self.match(langParser.T__10)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpressionLiteralContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_expressionLiteral

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpressionLiteral" ):
                return visitor.visitExpressionLiteral(self)
            else:
                return visitor.visitChildren(self)




    def expressionLiteral(self):

        localctx = langParser.ExpressionLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_expressionLiteral)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 185
            self.match(langParser.T__11)
            self.state = 186
            self.match(langParser.T__12)
            self.state = 187
            self.expression(0)
            self.state = 188
            self.match(langParser.T__13)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class NewTupleContext(ParserRuleContext):

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


        def getRuleIndex(self):
            return langParser.RULE_newTuple

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNewTuple" ):
                return visitor.visitNewTuple(self)
            else:
                return visitor.visitChildren(self)




    def newTuple(self):

        localctx = langParser.NewTupleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_newTuple)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 190
            self.match(langParser.T__9)
            self.state = 192
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                self.state = 191
                self.expression(0)


            self.state = 198
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==langParser.T__0:
                self.state = 194
                self.match(langParser.T__0)
                self.state = 195
                self.expression(0)
                self.state = 200
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 201
            self.match(langParser.T__10)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpressionContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_expression

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


    class NegationContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNegation" ):
                return visitor.visitNegation(self)
            else:
                return visitor.visitChildren(self)


    class StringContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def STRING(self):
            return self.getToken(langParser.STRING, 0)

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitString" ):
                return visitor.visitString(self)
            else:
                return visitor.visitChildren(self)


    class ToExitExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def exitExpression(self):
            return self.getTypedRuleContext(langParser.ExitExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToExitExpression" ):
                return visitor.visitToExitExpression(self)
            else:
                return visitor.visitChildren(self)


    class LtContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLt" ):
                return visitor.visitLt(self)
            else:
                return visitor.visitChildren(self)


    class ToFunctionTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionType(self):
            return self.getTypedRuleContext(langParser.FunctionTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToFunctionType" ):
                return visitor.visitToFunctionType(self)
            else:
                return visitor.visitChildren(self)


    class SubtractionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubtraction" ):
                return visitor.visitSubtraction(self)
            else:
                return visitor.visitChildren(self)


    class ToVoidTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def voidType(self):
            return self.getTypedRuleContext(langParser.VoidTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToVoidType" ):
                return visitor.visitToVoidType(self)
            else:
                return visitor.visitChildren(self)


    class ToIfContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ifBlock(self):
            return self.getTypedRuleContext(langParser.IfBlockContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToIf" ):
                return visitor.visitToIf(self)
            else:
                return visitor.visitChildren(self)


    class StaticExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticExpression" ):
                return visitor.visitStaticExpression(self)
            else:
                return visitor.visitChildren(self)


    class ToNewObjectContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def newObject(self):
            return self.getTypedRuleContext(langParser.NewObjectContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToNewObject" ):
                return visitor.visitToNewObject(self)
            else:
                return visitor.visitChildren(self)


    class DivisionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDivision" ):
                return visitor.visitDivision(self)
            else:
                return visitor.visitChildren(self)


    class BoundDereferenceContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBoundDereference" ):
                return visitor.visitBoundDereference(self)
            else:
                return visitor.visitChildren(self)


    class NumberContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NUMBER(self):
            return self.getToken(langParser.NUMBER, 0)

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumber" ):
                return visitor.visitNumber(self)
            else:
                return visitor.visitChildren(self)


    class ToListTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def listType(self):
            return self.getTypedRuleContext(langParser.ListTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToListType" ):
                return visitor.visitToListType(self)
            else:
                return visitor.visitChildren(self)


    class ToWhileLoopContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def whileLoop(self):
            return self.getTypedRuleContext(langParser.WhileLoopContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToWhileLoop" ):
                return visitor.visitToWhileLoop(self)
            else:
                return visitor.visitChildren(self)


    class ToConstTypeModifierContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def constTypeModifier(self):
            return self.getTypedRuleContext(langParser.ConstTypeModifierContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToConstTypeModifier" ):
                return visitor.visitToConstTypeModifier(self)
            else:
                return visitor.visitChildren(self)


    class ToReturnExpressionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def returnExpression(self):
            return self.getTypedRuleContext(langParser.ReturnExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToReturnExpression" ):
                return visitor.visitToReturnExpression(self)
            else:
                return visitor.visitChildren(self)


    class GteContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGte" ):
                return visitor.visitGte(self)
            else:
                return visitor.visitChildren(self)


    class MultiplicationContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiplication" ):
                return visitor.visitMultiplication(self)
            else:
                return visitor.visitChildren(self)


    class LteContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLte" ):
                return visitor.visitLte(self)
            else:
                return visitor.visitChildren(self)


    class ModulusContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitModulus" ):
                return visitor.visitModulus(self)
            else:
                return visitor.visitChildren(self)


    class AdditionContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAddition" ):
                return visitor.visitAddition(self)
            else:
                return visitor.visitChildren(self)


    class StaticFunctionInvocationContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStaticFunctionInvocation" ):
                return visitor.visitStaticFunctionInvocation(self)
            else:
                return visitor.visitChildren(self)


    class DynamicDereferenceContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDynamicDereference" ):
                return visitor.visitDynamicDereference(self)
            else:
                return visitor.visitChildren(self)


    class NoParameterFunctionInvocationContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNoParameterFunctionInvocation" ):
                return visitor.visitNoParameterFunctionInvocation(self)
            else:
                return visitor.visitChildren(self)


    class UnboundDereferenceContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnboundDereference" ):
                return visitor.visitUnboundDereference(self)
            else:
                return visitor.visitChildren(self)


    class ToObjectTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def objectType(self):
            return self.getTypedRuleContext(langParser.ObjectTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToObjectType" ):
                return visitor.visitToObjectType(self)
            else:
                return visitor.visitChildren(self)


    class ToDynamicFunctionLiteralContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionLiteral(self):
            return self.getTypedRuleContext(langParser.FunctionLiteralContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToDynamicFunctionLiteral" ):
                return visitor.visitToDynamicFunctionLiteral(self)
            else:
                return visitor.visitChildren(self)


    class ToFunctionLiteralContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionLiteral(self):
            return self.getTypedRuleContext(langParser.FunctionLiteralContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToFunctionLiteral" ):
                return visitor.visitToFunctionLiteral(self)
            else:
                return visitor.visitChildren(self)


    class AssignmentContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignment" ):
                return visitor.visitAssignment(self)
            else:
                return visitor.visitChildren(self)


    class ToNewTupleContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def newTuple(self):
            return self.getTypedRuleContext(langParser.NewTupleContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToNewTuple" ):
                return visitor.visitToNewTuple(self)
            else:
                return visitor.visitChildren(self)


    class FalseContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFalse" ):
                return visitor.visitFalse(self)
            else:
                return visitor.visitChildren(self)


    class ToAnyTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def anyType(self):
            return self.getTypedRuleContext(langParser.AnyTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToAnyType" ):
                return visitor.visitToAnyType(self)
            else:
                return visitor.visitChildren(self)


    class ParenthesisContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParenthesis" ):
                return visitor.visitParenthesis(self)
            else:
                return visitor.visitChildren(self)


    class MakePositiveContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMakePositive" ):
                return visitor.visitMakePositive(self)
            else:
                return visitor.visitChildren(self)


    class ExecuteContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def literal(self):
            return self.getTypedRuleContext(langParser.LiteralContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExecute" ):
                return visitor.visitExecute(self)
            else:
                return visitor.visitChildren(self)


    class GtContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGt" ):
                return visitor.visitGt(self)
            else:
                return visitor.visitChildren(self)


    class ToStringTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def stringType(self):
            return self.getTypedRuleContext(langParser.StringTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToStringType" ):
                return visitor.visitToStringType(self)
            else:
                return visitor.visitChildren(self)


    class ToIntegerTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def integerType(self):
            return self.getTypedRuleContext(langParser.IntegerTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToIntegerType" ):
                return visitor.visitToIntegerType(self)
            else:
                return visitor.visitChildren(self)


    class SingleParameterFunctionInvocationContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSingleParameterFunctionInvocation" ):
                return visitor.visitSingleParameterFunctionInvocation(self)
            else:
                return visitor.visitChildren(self)


    class NullContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNull" ):
                return visitor.visitNull(self)
            else:
                return visitor.visitChildren(self)


    class ToTupleTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def tupleType(self):
            return self.getTypedRuleContext(langParser.TupleTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToTupleType" ):
                return visitor.visitToTupleType(self)
            else:
                return visitor.visitChildren(self)


    class ToInferredTypeContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def inferredType(self):
            return self.getTypedRuleContext(langParser.InferredTypeContext,0)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitToInferredType" ):
                return visitor.visitToInferredType(self)
            else:
                return visitor.visitChildren(self)


    class EqualsContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEquals" ):
                return visitor.visitEquals(self)
            else:
                return visitor.visitChildren(self)


    class TrueContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrue" ):
                return visitor.visitTrue(self)
            else:
                return visitor.visitChildren(self)


    class NotEqualsContext(ExpressionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a langParser.ExpressionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNotEquals" ):
                return visitor.visitNotEquals(self)
            else:
                return visitor.visitChildren(self)



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = langParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 22
        self.enterRecursionRule(localctx, 22, self.RULE_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 246
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [langParser.SYMBOL]:
                localctx = langParser.UnboundDereferenceContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 204
                self.match(langParser.SYMBOL)
                pass
            elif token in [langParser.T__15]:
                localctx = langParser.StaticExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 205
                self.match(langParser.T__15)
                self.state = 206
                self.expression(0)
                self.state = 207
                self.match(langParser.T__16)
                pass
            elif token in [langParser.T__12]:
                localctx = langParser.ParenthesisContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 209
                self.match(langParser.T__12)
                self.state = 210
                self.expression(0)
                self.state = 211
                self.match(langParser.T__13)
                pass
            elif token in [langParser.T__17]:
                localctx = langParser.MakePositiveContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 213
                self.match(langParser.T__17)
                self.state = 214
                self.expression(38)
                pass
            elif token in [langParser.T__18]:
                localctx = langParser.NegationContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 215
                self.match(langParser.T__18)
                self.state = 216
                self.expression(37)
                pass
            elif token in [langParser.STRING]:
                localctx = langParser.StringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 217
                self.match(langParser.STRING)
                pass
            elif token in [langParser.NUMBER]:
                localctx = langParser.NumberContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 218
                self.match(langParser.NUMBER)
                pass
            elif token in [langParser.T__44]:
                localctx = langParser.ToWhileLoopContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 219
                self.whileLoop()
                pass
            elif token in [langParser.T__45]:
                localctx = langParser.ToIfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 220
                self.ifBlock()
                pass
            elif token in [langParser.T__28]:
                localctx = langParser.ExecuteContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 221
                self.match(langParser.T__28)
                self.state = 222
                self.match(langParser.T__12)
                self.state = 223
                self.literal()
                self.state = 224
                self.match(langParser.T__13)
                pass
            elif token in [langParser.T__29]:
                localctx = langParser.ToDynamicFunctionLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 226
                self.match(langParser.T__29)
                self.state = 227
                self.functionLiteral()
                pass
            elif token in [langParser.T__47]:
                localctx = langParser.ToFunctionLiteralContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 228
                self.functionLiteral()
                pass
            elif token in [langParser.T__6]:
                localctx = langParser.ToNewObjectContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 229
                self.newObject()
                pass
            elif token in [langParser.T__9]:
                localctx = langParser.ToNewTupleContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 230
                self.newTuple()
                pass
            elif token in [langParser.T__30]:
                localctx = langParser.TrueContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 231
                self.match(langParser.T__30)
                pass
            elif token in [langParser.T__31]:
                localctx = langParser.FalseContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 232
                self.match(langParser.T__31)
                pass
            elif token in [langParser.T__32]:
                localctx = langParser.NullContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 233
                self.match(langParser.T__32)
                pass
            elif token in [langParser.T__33]:
                localctx = langParser.ToVoidTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 234
                self.voidType()
                pass
            elif token in [langParser.T__35]:
                localctx = langParser.ToIntegerTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 235
                self.integerType()
                pass
            elif token in [langParser.T__34]:
                localctx = langParser.ToInferredTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 236
                self.inferredType()
                pass
            elif token in [langParser.T__36]:
                localctx = langParser.ToStringTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 237
                self.stringType()
                pass
            elif token in [langParser.T__37]:
                localctx = langParser.ToFunctionTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 238
                self.functionType()
                pass
            elif token in [langParser.T__39]:
                localctx = langParser.ToObjectTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 239
                self.objectType()
                pass
            elif token in [langParser.T__41]:
                localctx = langParser.ToTupleTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 240
                self.tupleType()
                pass
            elif token in [langParser.T__40]:
                localctx = langParser.ToListTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 241
                self.listType()
                pass
            elif token in [langParser.T__42]:
                localctx = langParser.ToAnyTypeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 242
                self.anyType()
                pass
            elif token in [langParser.T__43]:
                localctx = langParser.ToConstTypeModifierContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 243
                self.constTypeModifier()
                pass
            elif token in [langParser.T__51]:
                localctx = langParser.ToReturnExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 244
                self.returnExpression()
                pass
            elif token in [langParser.T__52]:
                localctx = langParser.ToExitExpressionContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 245
                self.exitExpression()
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 307
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,22,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 = 305
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
                    if la_ == 1:
                        localctx = langParser.MultiplicationContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 248
                        if not self.precpred(self._ctx, 36):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 36)")
                        self.state = 249
                        self.match(langParser.T__19)
                        self.state = 250
                        self.expression(37)
                        pass

                    elif la_ == 2:
                        localctx = langParser.DivisionContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 251
                        if not self.precpred(self._ctx, 35):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 35)")
                        self.state = 252
                        self.match(langParser.T__20)
                        self.state = 253
                        self.expression(36)
                        pass

                    elif la_ == 3:
                        localctx = langParser.AdditionContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 254
                        if not self.precpred(self._ctx, 34):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 34)")
                        self.state = 255
                        self.match(langParser.T__17)
                        self.state = 256
                        self.expression(35)
                        pass

                    elif la_ == 4:
                        localctx = langParser.SubtractionContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 257
                        if not self.precpred(self._ctx, 33):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 33)")
                        self.state = 258
                        self.match(langParser.T__18)
                        self.state = 259
                        self.expression(34)
                        pass

                    elif la_ == 5:
                        localctx = langParser.ModulusContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 260
                        if not self.precpred(self._ctx, 32):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 32)")
                        self.state = 261
                        self.match(langParser.T__21)
                        self.state = 262
                        self.expression(33)
                        pass

                    elif la_ == 6:
                        localctx = langParser.GteContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 263
                        if not self.precpred(self._ctx, 31):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 31)")
                        self.state = 264
                        self.match(langParser.T__22)
                        self.state = 265
                        self.expression(32)
                        pass

                    elif la_ == 7:
                        localctx = langParser.LteContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 266
                        if not self.precpred(self._ctx, 30):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 30)")
                        self.state = 267
                        self.match(langParser.T__23)
                        self.state = 268
                        self.expression(31)
                        pass

                    elif la_ == 8:
                        localctx = langParser.LtContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 269
                        if not self.precpred(self._ctx, 29):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 29)")
                        self.state = 270
                        self.match(langParser.T__24)
                        self.state = 271
                        self.expression(30)
                        pass

                    elif la_ == 9:
                        localctx = langParser.GtContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 272
                        if not self.precpred(self._ctx, 28):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 28)")
                        self.state = 273
                        self.match(langParser.T__25)
                        self.state = 274
                        self.expression(29)
                        pass

                    elif la_ == 10:
                        localctx = langParser.EqualsContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 275
                        if not self.precpred(self._ctx, 27):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 27)")
                        self.state = 276
                        self.match(langParser.T__26)
                        self.state = 277
                        self.expression(28)
                        pass

                    elif la_ == 11:
                        localctx = langParser.NotEqualsContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 278
                        if not self.precpred(self._ctx, 26):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 26)")
                        self.state = 279
                        self.match(langParser.T__27)
                        self.state = 280
                        self.expression(27)
                        pass

                    elif la_ == 12:
                        localctx = langParser.AssignmentContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 281
                        if not self.precpred(self._ctx, 25):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 25)")
                        self.state = 282
                        self.match(langParser.T__5)
                        self.state = 283
                        self.expression(26)
                        pass

                    elif la_ == 13:
                        localctx = langParser.BoundDereferenceContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 284
                        if not self.precpred(self._ctx, 46):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 46)")
                        self.state = 285
                        self.match(langParser.T__14)
                        self.state = 286
                        self.match(langParser.SYMBOL)
                        pass

                    elif la_ == 14:
                        localctx = langParser.DynamicDereferenceContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 287
                        if not self.precpred(self._ctx, 45):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 45)")
                        self.state = 288
                        self.match(langParser.T__9)
                        self.state = 289
                        self.expression(0)
                        self.state = 290
                        self.match(langParser.T__10)
                        pass

                    elif la_ == 15:
                        localctx = langParser.NoParameterFunctionInvocationContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 292
                        if not self.precpred(self._ctx, 43):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 43)")
                        self.state = 293
                        self.match(langParser.T__12)
                        self.state = 294
                        self.match(langParser.T__13)
                        pass

                    elif la_ == 16:
                        localctx = langParser.SingleParameterFunctionInvocationContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 295
                        if not self.precpred(self._ctx, 42):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 42)")
                        self.state = 296
                        self.match(langParser.T__12)
                        self.state = 297
                        self.expression(0)
                        self.state = 298
                        self.match(langParser.T__13)
                        pass

                    elif la_ == 17:
                        localctx = langParser.StaticFunctionInvocationContext(self, langParser.ExpressionContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 300
                        if not self.precpred(self._ctx, 41):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 41)")
                        self.state = 301
                        self.match(langParser.T__15)
                        self.state = 302
                        self.expression(0)
                        self.state = 303
                        self.match(langParser.T__16)
                        pass

             
                self.state = 309
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,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 VoidTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_voidType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVoidType" ):
                return visitor.visitVoidType(self)
            else:
                return visitor.visitChildren(self)




    def voidType(self):

        localctx = langParser.VoidTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_voidType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 310
            self.match(langParser.T__33)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InferredTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_inferredType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInferredType" ):
                return visitor.visitInferredType(self)
            else:
                return visitor.visitChildren(self)




    def inferredType(self):

        localctx = langParser.InferredTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_inferredType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 312
            self.match(langParser.T__34)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IntegerTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_integerType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIntegerType" ):
                return visitor.visitIntegerType(self)
            else:
                return visitor.visitChildren(self)




    def integerType(self):

        localctx = langParser.IntegerTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_integerType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 314
            self.match(langParser.T__35)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StringTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_stringType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStringType" ):
                return visitor.visitStringType(self)
            else:
                return visitor.visitChildren(self)




    def stringType(self):

        localctx = langParser.StringTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_stringType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 316
            self.match(langParser.T__36)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FunctionTypeContext(ParserRuleContext):

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


        def functionExits(self):
            return self.getTypedRuleContext(langParser.FunctionExitsContext,0)


        def getRuleIndex(self):
            return langParser.RULE_functionType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionType" ):
                return visitor.visitFunctionType(self)
            else:
                return visitor.visitChildren(self)




    def functionType(self):

        localctx = langParser.FunctionTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_functionType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 318
            self.match(langParser.T__37)
            self.state = 319
            self.match(langParser.T__15)
            self.state = 320
            self.expression(0)
            self.state = 321
            self.match(langParser.T__38)
            self.state = 322
            self.expression(0)
            self.state = 323
            self.match(langParser.T__16)
            self.state = 325
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.state = 324
                self.functionExits()


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

    class ObjectTypeContext(ParserRuleContext):

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

        def propertyType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.PropertyTypeContext)
            else:
                return self.getTypedRuleContext(langParser.PropertyTypeContext,i)


        def getRuleIndex(self):
            return langParser.RULE_objectType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitObjectType" ):
                return visitor.visitObjectType(self)
            else:
                return visitor.visitChildren(self)




    def objectType(self):

        localctx = langParser.ObjectTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_objectType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.match(langParser.T__39)
            self.state = 328
            self.match(langParser.T__6)
            self.state = 334
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                self.state = 329
                self.propertyType()
                self.state = 330
                self.match(langParser.T__1)
                self.state = 336
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 337
            self.match(langParser.T__7)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ListTypeContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_listType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitListType" ):
                return visitor.visitListType(self)
            else:
                return visitor.visitChildren(self)




    def listType(self):

        localctx = langParser.ListTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_listType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.match(langParser.T__40)
            self.state = 340
            self.match(langParser.T__15)
            self.state = 341
            self.expression(0)
            self.state = 342
            self.match(langParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TupleTypeContext(ParserRuleContext):

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


        def getRuleIndex(self):
            return langParser.RULE_tupleType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTupleType" ):
                return visitor.visitTupleType(self)
            else:
                return visitor.visitChildren(self)




    def tupleType(self):

        localctx = langParser.TupleTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_tupleType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 344
            self.match(langParser.T__41)
            self.state = 345
            self.match(langParser.T__15)
            self.state = 346
            self.expression(0)
            self.state = 351
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==langParser.T__0:
                self.state = 347
                self.match(langParser.T__0)
                self.state = 348
                self.expression(0)
                self.state = 353
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 354
            self.match(langParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnyTypeContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_anyType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAnyType" ):
                return visitor.visitAnyType(self)
            else:
                return visitor.visitChildren(self)




    def anyType(self):

        localctx = langParser.AnyTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_anyType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self.match(langParser.T__42)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstTypeModifierContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_constTypeModifier

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstTypeModifier" ):
                return visitor.visitConstTypeModifier(self)
            else:
                return visitor.visitChildren(self)




    def constTypeModifier(self):

        localctx = langParser.ConstTypeModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_constTypeModifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 358
            self.match(langParser.T__43)
            self.state = 359
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PropertyTypeContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def SYMBOL(self):
            return self.getToken(langParser.SYMBOL, 0)

        def getRuleIndex(self):
            return langParser.RULE_propertyType

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPropertyType" ):
                return visitor.visitPropertyType(self)
            else:
                return visitor.visitChildren(self)




    def propertyType(self):

        localctx = langParser.PropertyTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_propertyType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.expression(0)
            self.state = 362
            self.match(langParser.SYMBOL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class WhileLoopContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


        def getRuleIndex(self):
            return langParser.RULE_whileLoop

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhileLoop" ):
                return visitor.visitWhileLoop(self)
            else:
                return visitor.visitChildren(self)




    def whileLoop(self):

        localctx = langParser.WhileLoopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_whileLoop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self.match(langParser.T__44)
            self.state = 365
            self.match(langParser.T__12)
            self.state = 366
            self.expression(0)
            self.state = 367
            self.match(langParser.T__13)
            self.state = 368
            self.match(langParser.T__6)
            self.state = 370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                self.state = 369
                self.functionStub()


            self.state = 372
            self.match(langParser.T__7)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IfBlockContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def functionStub(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.FunctionStubContext)
            else:
                return self.getTypedRuleContext(langParser.FunctionStubContext,i)


        def getRuleIndex(self):
            return langParser.RULE_ifBlock

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIfBlock" ):
                return visitor.visitIfBlock(self)
            else:
                return visitor.visitChildren(self)




    def ifBlock(self):

        localctx = langParser.IfBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_ifBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 374
            self.match(langParser.T__45)
            self.state = 375
            self.match(langParser.T__12)
            self.state = 376
            self.expression(0)
            self.state = 377
            self.match(langParser.T__13)
            self.state = 378
            self.match(langParser.T__6)
            self.state = 380
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                self.state = 379
                self.functionStub()


            self.state = 382
            self.match(langParser.T__7)
            self.state = 389
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.state = 383
                self.match(langParser.T__46)
                self.state = 384
                self.match(langParser.T__6)
                self.state = 386
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                    self.state = 385
                    self.functionStub()


                self.state = 388
                self.match(langParser.T__7)


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

    class FunctionLiteralContext(ParserRuleContext):

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

        def functionArgumentAndReturns(self):
            return self.getTypedRuleContext(langParser.FunctionArgumentAndReturnsContext,0)


        def functionThrows(self):
            return self.getTypedRuleContext(langParser.FunctionThrowsContext,0)


        def functionExits(self):
            return self.getTypedRuleContext(langParser.FunctionExitsContext,0)


        def functionStub(self):
            return self.getTypedRuleContext(langParser.FunctionStubContext,0)


        def getRuleIndex(self):
            return langParser.RULE_functionLiteral

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionLiteral" ):
                return visitor.visitFunctionLiteral(self)
            else:
                return visitor.visitChildren(self)




    def functionLiteral(self):

        localctx = langParser.FunctionLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_functionLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 391
            self.match(langParser.T__47)
            self.state = 392
            self.functionArgumentAndReturns()
            self.state = 394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==langParser.T__48 or _la==langParser.T__49:
                self.state = 393
                self.functionThrows()


            self.state = 397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==langParser.T__50:
                self.state = 396
                self.functionExits()


            self.state = 399
            self.match(langParser.T__6)
            self.state = 401
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << langParser.T__2) | (1 << langParser.T__3) | (1 << langParser.T__4) | (1 << langParser.T__6) | (1 << langParser.T__9) | (1 << langParser.T__12) | (1 << langParser.T__15) | (1 << langParser.T__17) | (1 << langParser.T__18) | (1 << langParser.T__28) | (1 << langParser.T__29) | (1 << langParser.T__30) | (1 << langParser.T__31) | (1 << langParser.T__32) | (1 << langParser.T__33) | (1 << langParser.T__34) | (1 << langParser.T__35) | (1 << langParser.T__36) | (1 << langParser.T__37) | (1 << langParser.T__39) | (1 << langParser.T__40) | (1 << langParser.T__41) | (1 << langParser.T__42) | (1 << langParser.T__43) | (1 << langParser.T__44) | (1 << langParser.T__45) | (1 << langParser.T__47) | (1 << langParser.T__51) | (1 << langParser.T__52) | (1 << langParser.SYMBOL) | (1 << langParser.STRING) | (1 << langParser.NUMBER))) != 0):
                self.state = 400
                self.functionStub()


            self.state = 403
            self.match(langParser.T__7)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FunctionArgumentAndReturnsContext(ParserRuleContext):

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(langParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(langParser.ExpressionContext,i)


        def getRuleIndex(self):
            return langParser.RULE_functionArgumentAndReturns

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionArgumentAndReturns" ):
                return visitor.visitFunctionArgumentAndReturns(self)
            else:
                return visitor.visitChildren(self)




    def functionArgumentAndReturns(self):

        localctx = langParser.FunctionArgumentAndReturnsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_functionArgumentAndReturns)
        try:
            self.state = 417
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 405
                self.match(langParser.T__12)
                self.state = 406
                self.match(langParser.T__13)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 407
                self.match(langParser.T__12)
                self.state = 408
                self.expression(0)
                self.state = 409
                self.match(langParser.T__13)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 411
                self.match(langParser.T__12)
                self.state = 412
                self.expression(0)
                self.state = 413
                self.match(langParser.T__38)
                self.state = 414
                self.expression(0)
                self.state = 415
                self.match(langParser.T__13)
                pass


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

    class FunctionThrowsContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_functionThrows

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionThrows" ):
                return visitor.visitFunctionThrows(self)
            else:
                return visitor.visitChildren(self)




    def functionThrows(self):

        localctx = langParser.FunctionThrowsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_functionThrows)
        try:
            self.state = 422
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [langParser.T__48]:
                self.enterOuterAlt(localctx, 1)
                self.state = 419
                self.match(langParser.T__48)
                pass
            elif token in [langParser.T__49]:
                self.enterOuterAlt(localctx, 2)
                self.state = 420
                self.match(langParser.T__49)
                self.state = 421
                self.expression(0)
                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 FunctionExitsContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return langParser.RULE_functionExits

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunctionExits" ):
                return visitor.visitFunctionExits(self)
            else:
                return visitor.visitChildren(self)




    def functionExits(self):

        localctx = langParser.FunctionExitsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_functionExits)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424
            self.match(langParser.T__50)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ReturnExpressionContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_returnExpression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturnExpression" ):
                return visitor.visitReturnExpression(self)
            else:
                return visitor.visitChildren(self)




    def returnExpression(self):

        localctx = langParser.ReturnExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_returnExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 426
            self.match(langParser.T__51)
            self.state = 428
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 427
                self.expression(0)


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

    class ExitExpressionContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(langParser.ExpressionContext,0)


        def getRuleIndex(self):
            return langParser.RULE_exitExpression

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

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

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExitExpression" ):
                return visitor.visitExitExpression(self)
            else:
                return visitor.visitChildren(self)




    def exitExpression(self):

        localctx = langParser.ExitExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_exitExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 430
            self.match(langParser.T__52)
            self.state = 431
            self.expression(0)
        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[11] = self.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 expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 36)
         

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




