# Generated from main/bkit/parser/BKIT.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\3A")
        buf.write("\u01b6\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 \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\3\2\3\2\3\2\3")
        buf.write("\2\3\3\3\3\5\3_\n\3\3\4\3\4\5\4c\n\4\3\5\3\5\3\5\3\5\5")
        buf.write("\5i\n\5\3\6\3\6\3\6\3\6\5\6o\n\6\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\b\3\b\3\b\3\b\3\b\5\b{\n\b\3\t\3\t\5\t\177\n\t\3\n\3")
        buf.write("\n\5\n\u0083\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5")
        buf.write("\13\u008c\n\13\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r")
        buf.write("\5\r\u0098\n\r\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17")
        buf.write("\3\17\3\17\3\17\3\17\3\17\3\17\5\17\u00a8\n\17\3\20\3")
        buf.write("\20\3\20\3\20\3\20\5\20\u00af\n\20\3\21\3\21\5\21\u00b3")
        buf.write("\n\21\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24")
        buf.write("\3\24\5\24\u00c0\n\24\3\25\3\25\3\25\3\25\5\25\u00c6\n")
        buf.write("\25\3\26\3\26\5\26\u00ca\n\26\3\27\3\27\3\27\3\27\3\27")
        buf.write("\3\27\3\27\3\27\3\27\5\27\u00d5\n\27\3\30\3\30\3\30\3")
        buf.write("\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\7\31\u00e5\n\31\f\31\16\31\u00e8\13\31\3\31\3\31\5\31")
        buf.write("\u00ec\n\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3")
        buf.write("\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
        buf.write("\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34")
        buf.write("\3\34\3\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3\37")
        buf.write("\3\37\3 \3 \3 \3 \3 \3 \5 \u011e\n \3!\3!\3!\3!\3!\3!")
        buf.write("\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3")
        buf.write("!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\7!\u0144\n!\f!\16")
        buf.write("!\u0147\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u0152")
        buf.write("\n\"\f\"\16\"\u0155\13\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3")
        buf.write("#\3#\3#\3#\3#\3#\7#\u0166\n#\f#\16#\u0169\13#\3$\3$\3")
        buf.write("$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\7$\u017d")
        buf.write("\n$\f$\16$\u0180\13$\3%\3%\3%\5%\u0185\n%\3&\3&\3&\3&")
        buf.write("\3&\5&\u018c\n&\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u0196")
        buf.write("\n\'\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)\3)\5)\u01a4\n)\3")
        buf.write("*\3*\3*\3*\3*\3+\3+\5+\u01ad\n+\3,\3,\3,\3,\3,\5,\u01b4")
        buf.write("\n,\3,\2\6@BDF-\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
        buf.write(" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTV\2\3\4\2\65\659;")
        buf.write("\2\u01c4\2X\3\2\2\2\4^\3\2\2\2\6b\3\2\2\2\bh\3\2\2\2\n")
        buf.write("n\3\2\2\2\fp\3\2\2\2\16z\3\2\2\2\20~\3\2\2\2\22\u0082")
        buf.write("\3\2\2\2\24\u008b\3\2\2\2\26\u008d\3\2\2\2\30\u0097\3")
        buf.write("\2\2\2\32\u0099\3\2\2\2\34\u00a7\3\2\2\2\36\u00ae\3\2")
        buf.write("\2\2 \u00b2\3\2\2\2\"\u00b4\3\2\2\2$\u00ba\3\2\2\2&\u00bf")
        buf.write("\3\2\2\2(\u00c5\3\2\2\2*\u00c9\3\2\2\2,\u00d4\3\2\2\2")
        buf.write(".\u00d6\3\2\2\2\60\u00db\3\2\2\2\62\u00f0\3\2\2\2\64\u0101")
        buf.write("\3\2\2\2\66\u0108\3\2\2\28\u010e\3\2\2\2:\u0111\3\2\2")
        buf.write("\2<\u0114\3\2\2\2>\u011d\3\2\2\2@\u011f\3\2\2\2B\u0148")
        buf.write("\3\2\2\2D\u0156\3\2\2\2F\u016a\3\2\2\2H\u0184\3\2\2\2")
        buf.write("J\u018b\3\2\2\2L\u0195\3\2\2\2N\u0197\3\2\2\2P\u01a3\3")
        buf.write("\2\2\2R\u01a5\3\2\2\2T\u01ac\3\2\2\2V\u01b3\3\2\2\2XY")
        buf.write("\5\4\3\2YZ\5\6\4\2Z[\7\2\2\3[\3\3\2\2\2\\_\5\b\5\2]_\3")
        buf.write("\2\2\2^\\\3\2\2\2^]\3\2\2\2_\5\3\2\2\2`c\5\n\6\2ac\3\2")
        buf.write("\2\2b`\3\2\2\2ba\3\2\2\2c\7\3\2\2\2de\5\f\7\2ef\5\b\5")
        buf.write("\2fi\3\2\2\2gi\5\f\7\2hd\3\2\2\2hg\3\2\2\2i\t\3\2\2\2")
        buf.write("jk\5\34\17\2kl\5\n\6\2lo\3\2\2\2mo\5\34\17\2nj\3\2\2\2")
        buf.write("nm\3\2\2\2o\13\3\2\2\2pq\7*\2\2qr\7\60\2\2rs\5\16\b\2")
        buf.write("st\7\63\2\2t\r\3\2\2\2uv\5\20\t\2vw\7\62\2\2wx\5\16\b")
        buf.write("\2x{\3\2\2\2y{\5\20\t\2zu\3\2\2\2zy\3\2\2\2{\17\3\2\2")
        buf.write("\2|\177\5\22\n\2}\177\5\24\13\2~|\3\2\2\2~}\3\2\2\2\177")
        buf.write("\21\3\2\2\2\u0080\u0083\7<\2\2\u0081\u0083\5\26\f\2\u0082")
        buf.write("\u0080\3\2\2\2\u0082\u0081\3\2\2\2\u0083\23\3\2\2\2\u0084")
        buf.write("\u0085\7<\2\2\u0085\u0086\7\64\2\2\u0086\u008c\5\32\16")
        buf.write("\2\u0087\u0088\5\26\f\2\u0088\u0089\7\64\2\2\u0089\u008a")
        buf.write("\5\32\16\2\u008a\u008c\3\2\2\2\u008b\u0084\3\2\2\2\u008b")
        buf.write("\u0087\3\2\2\2\u008c\25\3\2\2\2\u008d\u008e\7<\2\2\u008e")
        buf.write("\u008f\5\30\r\2\u008f\27\3\2\2\2\u0090\u0091\7,\2\2\u0091")
        buf.write("\u0092\7\65\2\2\u0092\u0098\7-\2\2\u0093\u0094\7,\2\2")
        buf.write("\u0094\u0095\7\65\2\2\u0095\u0096\7-\2\2\u0096\u0098\5")
        buf.write("\30\r\2\u0097\u0090\3\2\2\2\u0097\u0093\3\2\2\2\u0098")
        buf.write("\31\3\2\2\2\u0099\u009a\t\2\2\2\u009a\33\3\2\2\2\u009b")
        buf.write("\u009c\7%\2\2\u009c\u009d\7\60\2\2\u009d\u009e\7<\2\2")
        buf.write("\u009e\u009f\7\'\2\2\u009f\u00a0\7\60\2\2\u00a0\u00a1")
        buf.write("\5\36\20\2\u00a1\u00a2\5\"\22\2\u00a2\u00a8\3\2\2\2\u00a3")
        buf.write("\u00a4\7%\2\2\u00a4\u00a5\7\60\2\2\u00a5\u00a6\7<\2\2")
        buf.write("\u00a6\u00a8\5\"\22\2\u00a7\u009b\3\2\2\2\u00a7\u00a3")
        buf.write("\3\2\2\2\u00a8\35\3\2\2\2\u00a9\u00aa\5 \21\2\u00aa\u00ab")
        buf.write("\7\62\2\2\u00ab\u00ac\5\36\20\2\u00ac\u00af\3\2\2\2\u00ad")
        buf.write("\u00af\5 \21\2\u00ae\u00a9\3\2\2\2\u00ae\u00ad\3\2\2\2")
        buf.write("\u00af\37\3\2\2\2\u00b0\u00b3\7<\2\2\u00b1\u00b3\5\26")
        buf.write("\f\2\u00b2\u00b0\3\2\2\2\u00b2\u00b1\3\2\2\2\u00b3!\3")
        buf.write("\2\2\2\u00b4\u00b5\7\32\2\2\u00b5\u00b6\7\60\2\2\u00b6")
        buf.write("\u00b7\5$\23\2\u00b7\u00b8\7 \2\2\u00b8\u00b9\7\61\2\2")
        buf.write("\u00b9#\3\2\2\2\u00ba\u00bb\5\4\3\2\u00bb\u00bc\5&\24")
        buf.write("\2\u00bc%\3\2\2\2\u00bd\u00c0\5(\25\2\u00be\u00c0\3\2")
        buf.write("\2\2\u00bf\u00bd\3\2\2\2\u00bf\u00be\3\2\2\2\u00c0\'\3")
        buf.write("\2\2\2\u00c1\u00c2\5,\27\2\u00c2\u00c3\5(\25\2\u00c3\u00c6")
        buf.write("\3\2\2\2\u00c4\u00c6\5,\27\2\u00c5\u00c1\3\2\2\2\u00c5")
        buf.write("\u00c4\3\2\2\2\u00c6)\3\2\2\2\u00c7\u00ca\7<\2\2\u00c8")
        buf.write("\u00ca\5N(\2\u00c9\u00c7\3\2\2\2\u00c9\u00c8\3\2\2\2\u00ca")
        buf.write("+\3\2\2\2\u00cb\u00d5\5.\30\2\u00cc\u00d5\5\60\31\2\u00cd")
        buf.write("\u00d5\5\62\32\2\u00ce\u00d5\5\64\33\2\u00cf\u00d5\5\66")
        buf.write("\34\2\u00d0\u00d5\58\35\2\u00d1\u00d5\5:\36\2\u00d2\u00d5")
        buf.write("\5<\37\2\u00d3\u00d5\5> \2\u00d4\u00cb\3\2\2\2\u00d4\u00cc")
        buf.write("\3\2\2\2\u00d4\u00cd\3\2\2\2\u00d4\u00ce\3\2\2\2\u00d4")
        buf.write("\u00cf\3\2\2\2\u00d4\u00d0\3\2\2\2\u00d4\u00d1\3\2\2\2")
        buf.write("\u00d4\u00d2\3\2\2\2\u00d4\u00d3\3\2\2\2\u00d5-\3\2\2")
        buf.write("\2\u00d6\u00d7\5*\26\2\u00d7\u00d8\7\64\2\2\u00d8\u00d9")
        buf.write("\5@!\2\u00d9\u00da\7\63\2\2\u00da/\3\2\2\2\u00db\u00dc")
        buf.write("\7&\2\2\u00dc\u00dd\5@!\2\u00dd\u00de\7)\2\2\u00de\u00e6")
        buf.write("\5$\23\2\u00df\u00e0\7\37\2\2\u00e0\u00e1\5@!\2\u00e1")
        buf.write("\u00e2\7)\2\2\u00e2\u00e3\5$\23\2\u00e3\u00e5\3\2\2\2")
        buf.write("\u00e4\u00df\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6\u00e4\3")
        buf.write("\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00eb\3\2\2\2\u00e8\u00e6")
        buf.write("\3\2\2\2\u00e9\u00ea\7\36\2\2\u00ea\u00ec\5$\23\2\u00eb")
        buf.write("\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\3\2\2\2")
        buf.write("\u00ed\u00ee\7!\2\2\u00ee\u00ef\7\61\2\2\u00ef\61\3\2")
        buf.write("\2\2\u00f0\u00f1\7$\2\2\u00f1\u00f2\7.\2\2\u00f2\u00f3")
        buf.write("\7<\2\2\u00f3\u00f4\7\64\2\2\u00f4\u00f5\5@!\2\u00f5\u00f6")
        buf.write("\7\62\2\2\u00f6\u00f7\5@!\2\u00f7\u00f8\7\62\2\2\u00f8")
        buf.write("\u00f9\7<\2\2\u00f9\u00fa\7\64\2\2\u00fa\u00fb\5@!\2\u00fb")
        buf.write("\u00fc\7/\2\2\u00fc\u00fd\7\35\2\2\u00fd\u00fe\5$\23\2")
        buf.write("\u00fe\u00ff\7\"\2\2\u00ff\u0100\7\61\2\2\u0100\63\3\2")
        buf.write("\2\2\u0101\u0102\7+\2\2\u0102\u0103\5@!\2\u0103\u0104")
        buf.write("\7\35\2\2\u0104\u0105\5$\23\2\u0105\u0106\7#\2\2\u0106")
        buf.write("\u0107\7\61\2\2\u0107\65\3\2\2\2\u0108\u0109\7\35\2\2")
        buf.write("\u0109\u010a\5$\23\2\u010a\u010b\7+\2\2\u010b\u010c\5")
        buf.write("@!\2\u010c\u010d\7\63\2\2\u010d\67\3\2\2\2\u010e\u010f")
        buf.write("\7\33\2\2\u010f\u0110\7\63\2\2\u01109\3\2\2\2\u0111\u0112")
        buf.write("\7\34\2\2\u0112\u0113\7\63\2\2\u0113;\3\2\2\2\u0114\u0115")
        buf.write("\5R*\2\u0115\u0116\7\63\2\2\u0116=\3\2\2\2\u0117\u0118")
        buf.write("\7(\2\2\u0118\u0119\5@!\2\u0119\u011a\7\63\2\2\u011a\u011e")
        buf.write("\3\2\2\2\u011b\u011c\7(\2\2\u011c\u011e\7\63\2\2\u011d")
        buf.write("\u0117\3\2\2\2\u011d\u011b\3\2\2\2\u011e?\3\2\2\2\u011f")
        buf.write("\u0120\b!\1\2\u0120\u0121\5B\"\2\u0121\u0145\3\2\2\2\u0122")
        buf.write("\u0123\f\16\2\2\u0123\u0124\7\17\2\2\u0124\u0144\5B\"")
        buf.write("\2\u0125\u0126\f\r\2\2\u0126\u0127\7\20\2\2\u0127\u0144")
        buf.write("\5B\"\2\u0128\u0129\f\f\2\2\u0129\u012a\7\21\2\2\u012a")
        buf.write("\u0144\5B\"\2\u012b\u012c\f\13\2\2\u012c\u012d\7\22\2")
        buf.write("\2\u012d\u0144\5B\"\2\u012e\u012f\f\n\2\2\u012f\u0130")
        buf.write("\7\23\2\2\u0130\u0144\5B\"\2\u0131\u0132\f\t\2\2\u0132")
        buf.write("\u0133\7\24\2\2\u0133\u0144\5B\"\2\u0134\u0135\f\b\2\2")
        buf.write("\u0135\u0136\7\25\2\2\u0136\u0144\5B\"\2\u0137\u0138\f")
        buf.write("\7\2\2\u0138\u0139\7\26\2\2\u0139\u0144\5B\"\2\u013a\u013b")
        buf.write("\f\6\2\2\u013b\u013c\7\27\2\2\u013c\u0144\5B\"\2\u013d")
        buf.write("\u013e\f\5\2\2\u013e\u013f\7\30\2\2\u013f\u0144\5B\"\2")
        buf.write("\u0140\u0141\f\4\2\2\u0141\u0142\7\31\2\2\u0142\u0144")
        buf.write("\5B\"\2\u0143\u0122\3\2\2\2\u0143\u0125\3\2\2\2\u0143")
        buf.write("\u0128\3\2\2\2\u0143\u012b\3\2\2\2\u0143\u012e\3\2\2\2")
        buf.write("\u0143\u0131\3\2\2\2\u0143\u0134\3\2\2\2\u0143\u0137\3")
        buf.write("\2\2\2\u0143\u013a\3\2\2\2\u0143\u013d\3\2\2\2\u0143\u0140")
        buf.write("\3\2\2\2\u0144\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0145")
        buf.write("\u0146\3\2\2\2\u0146A\3\2\2\2\u0147\u0145\3\2\2\2\u0148")
        buf.write("\u0149\b\"\1\2\u0149\u014a\5D#\2\u014a\u0153\3\2\2\2\u014b")
        buf.write("\u014c\f\5\2\2\u014c\u014d\7\r\2\2\u014d\u0152\5D#\2\u014e")
        buf.write("\u014f\f\4\2\2\u014f\u0150\7\16\2\2\u0150\u0152\5D#\2")
        buf.write("\u0151\u014b\3\2\2\2\u0151\u014e\3\2\2\2\u0152\u0155\3")
        buf.write("\2\2\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154C")
        buf.write("\3\2\2\2\u0155\u0153\3\2\2\2\u0156\u0157\b#\1\2\u0157")
        buf.write("\u0158\5F$\2\u0158\u0167\3\2\2\2\u0159\u015a\f\7\2\2\u015a")
        buf.write("\u015b\7\3\2\2\u015b\u0166\5F$\2\u015c\u015d\f\6\2\2\u015d")
        buf.write("\u015e\7\4\2\2\u015e\u0166\5F$\2\u015f\u0160\f\5\2\2\u0160")
        buf.write("\u0161\7\5\2\2\u0161\u0166\5F$\2\u0162\u0163\f\4\2\2\u0163")
        buf.write("\u0164\7\6\2\2\u0164\u0166\5F$\2\u0165\u0159\3\2\2\2\u0165")
        buf.write("\u015c\3\2\2\2\u0165\u015f\3\2\2\2\u0165\u0162\3\2\2\2")
        buf.write("\u0166\u0169\3\2\2\2\u0167\u0165\3\2\2\2\u0167\u0168\3")
        buf.write("\2\2\2\u0168E\3\2\2\2\u0169\u0167\3\2\2\2\u016a\u016b")
        buf.write("\b$\1\2\u016b\u016c\5H%\2\u016c\u017e\3\2\2\2\u016d\u016e")
        buf.write("\f\b\2\2\u016e\u016f\7\7\2\2\u016f\u017d\5H%\2\u0170\u0171")
        buf.write("\f\7\2\2\u0171\u0172\7\b\2\2\u0172\u017d\5H%\2\u0173\u0174")
        buf.write("\f\6\2\2\u0174\u0175\7\t\2\2\u0175\u017d\5H%\2\u0176\u0177")
        buf.write("\f\5\2\2\u0177\u0178\7\n\2\2\u0178\u017d\5H%\2\u0179\u017a")
        buf.write("\f\4\2\2\u017a\u017b\7\13\2\2\u017b\u017d\5H%\2\u017c")
        buf.write("\u016d\3\2\2\2\u017c\u0170\3\2\2\2\u017c\u0173\3\2\2\2")
        buf.write("\u017c\u0176\3\2\2\2\u017c\u0179\3\2\2\2\u017d\u0180\3")
        buf.write("\2\2\2\u017e\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017fG")
        buf.write("\3\2\2\2\u0180\u017e\3\2\2\2\u0181\u0182\7\f\2\2\u0182")
        buf.write("\u0185\5H%\2\u0183\u0185\5J&\2\u0184\u0181\3\2\2\2\u0184")
        buf.write("\u0183\3\2\2\2\u0185I\3\2\2\2\u0186\u0187\7\5\2\2\u0187")
        buf.write("\u018c\5J&\2\u0188\u0189\7\6\2\2\u0189\u018c\5J&\2\u018a")
        buf.write("\u018c\5L\'\2\u018b\u0186\3\2\2\2\u018b\u0188\3\2\2\2")
        buf.write("\u018b\u018a\3\2\2\2\u018cK\3\2\2\2\u018d\u0196\5\32\16")
        buf.write("\2\u018e\u018f\7.\2\2\u018f\u0190\5@!\2\u0190\u0191\7")
        buf.write("/\2\2\u0191\u0196\3\2\2\2\u0192\u0196\7<\2\2\u0193\u0196")
        buf.write("\5N(\2\u0194\u0196\5R*\2\u0195\u018d\3\2\2\2\u0195\u018e")
        buf.write("\3\2\2\2\u0195\u0192\3\2\2\2\u0195\u0193\3\2\2\2\u0195")
        buf.write("\u0194\3\2\2\2\u0196M\3\2\2\2\u0197\u0198\7<\2\2\u0198")
        buf.write("\u0199\5P)\2\u0199O\3\2\2\2\u019a\u019b\7,\2\2\u019b\u019c")
        buf.write("\5@!\2\u019c\u019d\7-\2\2\u019d\u01a4\3\2\2\2\u019e\u019f")
        buf.write("\7,\2\2\u019f\u01a0\5@!\2\u01a0\u01a1\7-\2\2\u01a1\u01a2")
        buf.write("\5P)\2\u01a2\u01a4\3\2\2\2\u01a3\u019a\3\2\2\2\u01a3\u019e")
        buf.write("\3\2\2\2\u01a4Q\3\2\2\2\u01a5\u01a6\7<\2\2\u01a6\u01a7")
        buf.write("\7.\2\2\u01a7\u01a8\5T+\2\u01a8\u01a9\7/\2\2\u01a9S\3")
        buf.write("\2\2\2\u01aa\u01ad\5V,\2\u01ab\u01ad\3\2\2\2\u01ac\u01aa")
        buf.write("\3\2\2\2\u01ac\u01ab\3\2\2\2\u01adU\3\2\2\2\u01ae\u01af")
        buf.write("\5@!\2\u01af\u01b0\7\62\2\2\u01b0\u01b1\5V,\2\u01b1\u01b4")
        buf.write("\3\2\2\2\u01b2\u01b4\5@!\2\u01b3\u01ae\3\2\2\2\u01b3\u01b2")
        buf.write("\3\2\2\2\u01b4W\3\2\2\2#^bhnz~\u0082\u008b\u0097\u00a7")
        buf.write("\u00ae\u00b2\u00bf\u00c5\u00c9\u00d4\u00e6\u00eb\u011d")
        buf.write("\u0143\u0145\u0151\u0153\u0165\u0167\u017c\u017e\u0184")
        buf.write("\u018b\u0195\u01a3\u01ac\u01b3")
        return buf.getvalue()


class BKITParser ( Parser ):

    grammarFileName = "BKIT.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'+'", "'+.'", "'-'", "'-.'", "'*'", "'*.'", 
                     "'\\'", "'/'", "'%'", "'!'", "'&&'", "'||'", "'=='", 
                     "'!='", "'<'", "'>'", "'<='", "'>='", "'=/='", "'<.'", 
                     "'>.'", "'<=.'", "'>=.'", "'Body'", "'Break'", "'Continue'", 
                     "'Do'", "'Else'", "'ElseIf'", "'EndBody'", "'EndIf'", 
                     "'EndFor'", "'EndWhile'", "'For'", "'Function'", "'If'", 
                     "'Parameter'", "'Return'", "'Then'", "'Var'", "'While'", 
                     "'['", "']'", "'('", "')'", "':'", "'.'", "','", "';'", 
                     "'='" ]

    symbolicNames = [ "<INVALID>", "ADD", "FADD", "SUB", "FSUB", "MUL", 
                      "FMUL", "DIV", "FDIV", "MOD", "NOT", "AND", "OR", 
                      "EQUAL", "NOTEQUAL", "LESS", "GREATER", "LESSEQUAL", 
                      "GREATEREQUAL", "FNOTEQUAL", "FLESS", "FGREATER", 
                      "FLESSEQUAL", "FGREATEREQUAL", "KEY_BODY", "KEY_BREAK", 
                      "KEY_CONTINUE", "KEY_DO", "KEY_ELSE", "KEY_ELSEIF", 
                      "KEY_ENDBODY", "KEY_ENDIF", "KEY_ENDFOR", "KEY_ENDWHILE", 
                      "KEY_FOR", "KEY_FUNCTION", "KEY_IF", "KEY_PARAMETER", 
                      "KEY_RETURN", "KEY_THEN", "KEY_VAR", "KEY_WHILE", 
                      "LSB", "RSB", "LP", "RP", "CL", "DOT", "CM", "SM", 
                      "ASSIGN", "INTLIT", "DECIMAL", "HEX", "OCTAL", "FLOATLIT", 
                      "BOOLLIT", "STRINGLIT", "ID", "COMMENT", "WS", "UNCLOSE_STRING", 
                      "ILLEGAL_ESCAPE", "ERROR_CHAR" ]

    RULE_program = 0
    RULE_listVarDeclar = 1
    RULE_listFuncDeclar = 2
    RULE_noNullListVarDeclar = 3
    RULE_noNullListFuncDeclar = 4
    RULE_vardeclara = 5
    RULE_listvar = 6
    RULE_var = 7
    RULE_nonInitVar = 8
    RULE_initVar = 9
    RULE_varArrayIdentifier = 10
    RULE_var_index_operators = 11
    RULE_literal = 12
    RULE_funcdeclara = 13
    RULE_listparam = 14
    RULE_param = 15
    RULE_funcbody = 16
    RULE_listStatement = 17
    RULE_listOtherStatements = 18
    RULE_noNullListOtherStatements = 19
    RULE_variable = 20
    RULE_statement = 21
    RULE_assigment = 22
    RULE_if_statement = 23
    RULE_for_statement = 24
    RULE_while_statement = 25
    RULE_do_while_statement = 26
    RULE_break_statement = 27
    RULE_continue_statement = 28
    RULE_call_statement = 29
    RULE_return_statement = 30
    RULE_exp = 31
    RULE_exp1 = 32
    RULE_exp2 = 33
    RULE_exp3 = 34
    RULE_exp4 = 35
    RULE_exp5 = 36
    RULE_exp6 = 37
    RULE_element_exp = 38
    RULE_index_operators = 39
    RULE_func_call = 40
    RULE_listExp = 41
    RULE_noNullListExp = 42

    ruleNames =  [ "program", "listVarDeclar", "listFuncDeclar", "noNullListVarDeclar", 
                   "noNullListFuncDeclar", "vardeclara", "listvar", "var", 
                   "nonInitVar", "initVar", "varArrayIdentifier", "var_index_operators", 
                   "literal", "funcdeclara", "listparam", "param", "funcbody", 
                   "listStatement", "listOtherStatements", "noNullListOtherStatements", 
                   "variable", "statement", "assigment", "if_statement", 
                   "for_statement", "while_statement", "do_while_statement", 
                   "break_statement", "continue_statement", "call_statement", 
                   "return_statement", "exp", "exp1", "exp2", "exp3", "exp4", 
                   "exp5", "exp6", "element_exp", "index_operators", "func_call", 
                   "listExp", "noNullListExp" ]

    EOF = Token.EOF
    ADD=1
    FADD=2
    SUB=3
    FSUB=4
    MUL=5
    FMUL=6
    DIV=7
    FDIV=8
    MOD=9
    NOT=10
    AND=11
    OR=12
    EQUAL=13
    NOTEQUAL=14
    LESS=15
    GREATER=16
    LESSEQUAL=17
    GREATEREQUAL=18
    FNOTEQUAL=19
    FLESS=20
    FGREATER=21
    FLESSEQUAL=22
    FGREATEREQUAL=23
    KEY_BODY=24
    KEY_BREAK=25
    KEY_CONTINUE=26
    KEY_DO=27
    KEY_ELSE=28
    KEY_ELSEIF=29
    KEY_ENDBODY=30
    KEY_ENDIF=31
    KEY_ENDFOR=32
    KEY_ENDWHILE=33
    KEY_FOR=34
    KEY_FUNCTION=35
    KEY_IF=36
    KEY_PARAMETER=37
    KEY_RETURN=38
    KEY_THEN=39
    KEY_VAR=40
    KEY_WHILE=41
    LSB=42
    RSB=43
    LP=44
    RP=45
    CL=46
    DOT=47
    CM=48
    SM=49
    ASSIGN=50
    INTLIT=51
    DECIMAL=52
    HEX=53
    OCTAL=54
    FLOATLIT=55
    BOOLLIT=56
    STRINGLIT=57
    ID=58
    COMMENT=59
    WS=60
    UNCLOSE_STRING=61
    ILLEGAL_ESCAPE=62
    ERROR_CHAR=63

    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 ProgramContext(ParserRuleContext):

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

        def listVarDeclar(self):
            return self.getTypedRuleContext(BKITParser.ListVarDeclarContext,0)


        def listFuncDeclar(self):
            return self.getTypedRuleContext(BKITParser.ListFuncDeclarContext,0)


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

        def getRuleIndex(self):
            return BKITParser.RULE_program

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




    def program(self):

        localctx = BKITParser.ProgramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_program)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 86
            self.listVarDeclar()
            self.state = 87
            self.listFuncDeclar()
            self.state = 88
            self.match(BKITParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListVarDeclarContext(ParserRuleContext):

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

        def noNullListVarDeclar(self):
            return self.getTypedRuleContext(BKITParser.NoNullListVarDeclarContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listVarDeclar

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




    def listVarDeclar(self):

        localctx = BKITParser.ListVarDeclarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_listVarDeclar)
        try:
            self.state = 92
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [BKITParser.KEY_VAR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 90
                self.noNullListVarDeclar()
                pass
            elif token in [BKITParser.EOF, BKITParser.KEY_BREAK, BKITParser.KEY_CONTINUE, BKITParser.KEY_DO, BKITParser.KEY_ELSE, BKITParser.KEY_ELSEIF, BKITParser.KEY_ENDBODY, BKITParser.KEY_ENDIF, BKITParser.KEY_ENDFOR, BKITParser.KEY_ENDWHILE, BKITParser.KEY_FOR, BKITParser.KEY_FUNCTION, BKITParser.KEY_IF, BKITParser.KEY_RETURN, BKITParser.KEY_WHILE, BKITParser.ID]:
                self.enterOuterAlt(localctx, 2)

                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 ListFuncDeclarContext(ParserRuleContext):

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

        def noNullListFuncDeclar(self):
            return self.getTypedRuleContext(BKITParser.NoNullListFuncDeclarContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listFuncDeclar

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




    def listFuncDeclar(self):

        localctx = BKITParser.ListFuncDeclarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_listFuncDeclar)
        try:
            self.state = 96
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [BKITParser.KEY_FUNCTION]:
                self.enterOuterAlt(localctx, 1)
                self.state = 94
                self.noNullListFuncDeclar()
                pass
            elif token in [BKITParser.EOF]:
                self.enterOuterAlt(localctx, 2)

                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 NoNullListVarDeclarContext(ParserRuleContext):

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

        def vardeclara(self):
            return self.getTypedRuleContext(BKITParser.VardeclaraContext,0)


        def noNullListVarDeclar(self):
            return self.getTypedRuleContext(BKITParser.NoNullListVarDeclarContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_noNullListVarDeclar

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




    def noNullListVarDeclar(self):

        localctx = BKITParser.NoNullListVarDeclarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_noNullListVarDeclar)
        try:
            self.state = 102
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 98
                self.vardeclara()
                self.state = 99
                self.noNullListVarDeclar()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 101
                self.vardeclara()
                pass


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


    class NoNullListFuncDeclarContext(ParserRuleContext):

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

        def funcdeclara(self):
            return self.getTypedRuleContext(BKITParser.FuncdeclaraContext,0)


        def noNullListFuncDeclar(self):
            return self.getTypedRuleContext(BKITParser.NoNullListFuncDeclarContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_noNullListFuncDeclar

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




    def noNullListFuncDeclar(self):

        localctx = BKITParser.NoNullListFuncDeclarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_noNullListFuncDeclar)
        try:
            self.state = 108
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 104
                self.funcdeclara()
                self.state = 105
                self.noNullListFuncDeclar()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 107
                self.funcdeclara()
                pass


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


    class VardeclaraContext(ParserRuleContext):

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

        def KEY_VAR(self):
            return self.getToken(BKITParser.KEY_VAR, 0)

        def CL(self):
            return self.getToken(BKITParser.CL, 0)

        def listvar(self):
            return self.getTypedRuleContext(BKITParser.ListvarContext,0)


        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_vardeclara

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




    def vardeclara(self):

        localctx = BKITParser.VardeclaraContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_vardeclara)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 110
            self.match(BKITParser.KEY_VAR)
            self.state = 111
            self.match(BKITParser.CL)
            self.state = 112
            self.listvar()
            self.state = 113
            self.match(BKITParser.SM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListvarContext(ParserRuleContext):

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

        def var(self):
            return self.getTypedRuleContext(BKITParser.VarContext,0)


        def CM(self):
            return self.getToken(BKITParser.CM, 0)

        def listvar(self):
            return self.getTypedRuleContext(BKITParser.ListvarContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listvar

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




    def listvar(self):

        localctx = BKITParser.ListvarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_listvar)
        try:
            self.state = 120
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 115
                self.var()
                self.state = 116
                self.match(BKITParser.CM)
                self.state = 117
                self.listvar()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 119
                self.var()
                pass


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


    class VarContext(ParserRuleContext):

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

        def nonInitVar(self):
            return self.getTypedRuleContext(BKITParser.NonInitVarContext,0)


        def initVar(self):
            return self.getTypedRuleContext(BKITParser.InitVarContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_var

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




    def var(self):

        localctx = BKITParser.VarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_var)
        try:
            self.state = 124
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 122
                self.nonInitVar()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 123
                self.initVar()
                pass


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


    class NonInitVarContext(ParserRuleContext):

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

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

        def varArrayIdentifier(self):
            return self.getTypedRuleContext(BKITParser.VarArrayIdentifierContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_nonInitVar

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




    def nonInitVar(self):

        localctx = BKITParser.NonInitVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_nonInitVar)
        try:
            self.state = 128
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 126
                self.match(BKITParser.ID)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 127
                self.varArrayIdentifier()
                pass


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


    class InitVarContext(ParserRuleContext):

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

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

        def ASSIGN(self):
            return self.getToken(BKITParser.ASSIGN, 0)

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


        def varArrayIdentifier(self):
            return self.getTypedRuleContext(BKITParser.VarArrayIdentifierContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_initVar

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




    def initVar(self):

        localctx = BKITParser.InitVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_initVar)
        try:
            self.state = 137
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 130
                self.match(BKITParser.ID)
                self.state = 131
                self.match(BKITParser.ASSIGN)
                self.state = 132
                self.literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 133
                self.varArrayIdentifier()
                self.state = 134
                self.match(BKITParser.ASSIGN)
                self.state = 135
                self.literal()
                pass


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


    class VarArrayIdentifierContext(ParserRuleContext):

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

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

        def var_index_operators(self):
            return self.getTypedRuleContext(BKITParser.Var_index_operatorsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_varArrayIdentifier

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




    def varArrayIdentifier(self):

        localctx = BKITParser.VarArrayIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_varArrayIdentifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 139
            self.match(BKITParser.ID)
            self.state = 140
            self.var_index_operators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Var_index_operatorsContext(ParserRuleContext):

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

        def LSB(self):
            return self.getToken(BKITParser.LSB, 0)

        def INTLIT(self):
            return self.getToken(BKITParser.INTLIT, 0)

        def RSB(self):
            return self.getToken(BKITParser.RSB, 0)

        def var_index_operators(self):
            return self.getTypedRuleContext(BKITParser.Var_index_operatorsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_var_index_operators

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




    def var_index_operators(self):

        localctx = BKITParser.Var_index_operatorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_var_index_operators)
        try:
            self.state = 149
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 142
                self.match(BKITParser.LSB)
                self.state = 143
                self.match(BKITParser.INTLIT)
                self.state = 144
                self.match(BKITParser.RSB)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 145
                self.match(BKITParser.LSB)
                self.state = 146
                self.match(BKITParser.INTLIT)
                self.state = 147
                self.match(BKITParser.RSB)
                self.state = 148
                self.var_index_operators()
                pass


        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 INTLIT(self):
            return self.getToken(BKITParser.INTLIT, 0)

        def FLOATLIT(self):
            return self.getToken(BKITParser.FLOATLIT, 0)

        def BOOLLIT(self):
            return self.getToken(BKITParser.BOOLLIT, 0)

        def STRINGLIT(self):
            return self.getToken(BKITParser.STRINGLIT, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_literal

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




    def literal(self):

        localctx = BKITParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 151
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << BKITParser.INTLIT) | (1 << BKITParser.FLOATLIT) | (1 << BKITParser.BOOLLIT) | (1 << BKITParser.STRINGLIT))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FuncdeclaraContext(ParserRuleContext):

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

        def KEY_FUNCTION(self):
            return self.getToken(BKITParser.KEY_FUNCTION, 0)

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

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

        def KEY_PARAMETER(self):
            return self.getToken(BKITParser.KEY_PARAMETER, 0)

        def listparam(self):
            return self.getTypedRuleContext(BKITParser.ListparamContext,0)


        def funcbody(self):
            return self.getTypedRuleContext(BKITParser.FuncbodyContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_funcdeclara

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




    def funcdeclara(self):

        localctx = BKITParser.FuncdeclaraContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_funcdeclara)
        try:
            self.state = 165
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 153
                self.match(BKITParser.KEY_FUNCTION)
                self.state = 154
                self.match(BKITParser.CL)
                self.state = 155
                self.match(BKITParser.ID)
                self.state = 156
                self.match(BKITParser.KEY_PARAMETER)
                self.state = 157
                self.match(BKITParser.CL)
                self.state = 158
                self.listparam()
                self.state = 159
                self.funcbody()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 161
                self.match(BKITParser.KEY_FUNCTION)
                self.state = 162
                self.match(BKITParser.CL)
                self.state = 163
                self.match(BKITParser.ID)
                self.state = 164
                self.funcbody()
                pass


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


    class ListparamContext(ParserRuleContext):

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

        def param(self):
            return self.getTypedRuleContext(BKITParser.ParamContext,0)


        def CM(self):
            return self.getToken(BKITParser.CM, 0)

        def listparam(self):
            return self.getTypedRuleContext(BKITParser.ListparamContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listparam

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




    def listparam(self):

        localctx = BKITParser.ListparamContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_listparam)
        try:
            self.state = 172
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 167
                self.param()
                self.state = 168
                self.match(BKITParser.CM)
                self.state = 169
                self.listparam()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 171
                self.param()
                pass


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


    class ParamContext(ParserRuleContext):

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

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

        def varArrayIdentifier(self):
            return self.getTypedRuleContext(BKITParser.VarArrayIdentifierContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_param

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




    def param(self):

        localctx = BKITParser.ParamContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_param)
        try:
            self.state = 176
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 174
                self.match(BKITParser.ID)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 175
                self.varArrayIdentifier()
                pass


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


    class FuncbodyContext(ParserRuleContext):

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

        def KEY_BODY(self):
            return self.getToken(BKITParser.KEY_BODY, 0)

        def CL(self):
            return self.getToken(BKITParser.CL, 0)

        def listStatement(self):
            return self.getTypedRuleContext(BKITParser.ListStatementContext,0)


        def KEY_ENDBODY(self):
            return self.getToken(BKITParser.KEY_ENDBODY, 0)

        def DOT(self):
            return self.getToken(BKITParser.DOT, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_funcbody

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




    def funcbody(self):

        localctx = BKITParser.FuncbodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_funcbody)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 178
            self.match(BKITParser.KEY_BODY)
            self.state = 179
            self.match(BKITParser.CL)
            self.state = 180
            self.listStatement()
            self.state = 181
            self.match(BKITParser.KEY_ENDBODY)
            self.state = 182
            self.match(BKITParser.DOT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListStatementContext(ParserRuleContext):

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

        def listVarDeclar(self):
            return self.getTypedRuleContext(BKITParser.ListVarDeclarContext,0)


        def listOtherStatements(self):
            return self.getTypedRuleContext(BKITParser.ListOtherStatementsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listStatement

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




    def listStatement(self):

        localctx = BKITParser.ListStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_listStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 184
            self.listVarDeclar()
            self.state = 185
            self.listOtherStatements()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListOtherStatementsContext(ParserRuleContext):

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

        def noNullListOtherStatements(self):
            return self.getTypedRuleContext(BKITParser.NoNullListOtherStatementsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listOtherStatements

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




    def listOtherStatements(self):

        localctx = BKITParser.ListOtherStatementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_listOtherStatements)
        try:
            self.state = 189
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 187
                self.noNullListOtherStatements()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)

                pass


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


    class NoNullListOtherStatementsContext(ParserRuleContext):

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

        def statement(self):
            return self.getTypedRuleContext(BKITParser.StatementContext,0)


        def noNullListOtherStatements(self):
            return self.getTypedRuleContext(BKITParser.NoNullListOtherStatementsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_noNullListOtherStatements

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




    def noNullListOtherStatements(self):

        localctx = BKITParser.NoNullListOtherStatementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_noNullListOtherStatements)
        try:
            self.state = 195
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 191
                self.statement()
                self.state = 192
                self.noNullListOtherStatements()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 194
                self.statement()
                pass


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


    class VariableContext(ParserRuleContext):

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

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

        def element_exp(self):
            return self.getTypedRuleContext(BKITParser.Element_expContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_variable

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




    def variable(self):

        localctx = BKITParser.VariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_variable)
        try:
            self.state = 199
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 197
                self.match(BKITParser.ID)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 198
                self.element_exp()
                pass


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


    class StatementContext(ParserRuleContext):

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

        def assigment(self):
            return self.getTypedRuleContext(BKITParser.AssigmentContext,0)


        def if_statement(self):
            return self.getTypedRuleContext(BKITParser.If_statementContext,0)


        def for_statement(self):
            return self.getTypedRuleContext(BKITParser.For_statementContext,0)


        def while_statement(self):
            return self.getTypedRuleContext(BKITParser.While_statementContext,0)


        def do_while_statement(self):
            return self.getTypedRuleContext(BKITParser.Do_while_statementContext,0)


        def break_statement(self):
            return self.getTypedRuleContext(BKITParser.Break_statementContext,0)


        def continue_statement(self):
            return self.getTypedRuleContext(BKITParser.Continue_statementContext,0)


        def call_statement(self):
            return self.getTypedRuleContext(BKITParser.Call_statementContext,0)


        def return_statement(self):
            return self.getTypedRuleContext(BKITParser.Return_statementContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_statement

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




    def statement(self):

        localctx = BKITParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_statement)
        try:
            self.state = 210
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 201
                self.assigment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 202
                self.if_statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 203
                self.for_statement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 204
                self.while_statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 205
                self.do_while_statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 206
                self.break_statement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 207
                self.continue_statement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 208
                self.call_statement()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 209
                self.return_statement()
                pass


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


    class AssigmentContext(ParserRuleContext):

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

        def variable(self):
            return self.getTypedRuleContext(BKITParser.VariableContext,0)


        def ASSIGN(self):
            return self.getToken(BKITParser.ASSIGN, 0)

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_assigment

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




    def assigment(self):

        localctx = BKITParser.AssigmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_assigment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 212
            self.variable()
            self.state = 213
            self.match(BKITParser.ASSIGN)
            self.state = 214
            self.exp(0)
            self.state = 215
            self.match(BKITParser.SM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class If_statementContext(ParserRuleContext):

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

        def KEY_IF(self):
            return self.getToken(BKITParser.KEY_IF, 0)

        def exp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BKITParser.ExpContext)
            else:
                return self.getTypedRuleContext(BKITParser.ExpContext,i)


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

        def listStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BKITParser.ListStatementContext)
            else:
                return self.getTypedRuleContext(BKITParser.ListStatementContext,i)


        def KEY_ENDIF(self):
            return self.getToken(BKITParser.KEY_ENDIF, 0)

        def DOT(self):
            return self.getToken(BKITParser.DOT, 0)

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

        def KEY_ELSE(self):
            return self.getToken(BKITParser.KEY_ELSE, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_if_statement

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




    def if_statement(self):

        localctx = BKITParser.If_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_if_statement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 217
            self.match(BKITParser.KEY_IF)
            self.state = 218
            self.exp(0)
            self.state = 219
            self.match(BKITParser.KEY_THEN)
            self.state = 220
            self.listStatement()
            self.state = 228
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==BKITParser.KEY_ELSEIF:
                self.state = 221
                self.match(BKITParser.KEY_ELSEIF)
                self.state = 222
                self.exp(0)
                self.state = 223
                self.match(BKITParser.KEY_THEN)
                self.state = 224
                self.listStatement()
                self.state = 230
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 233
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==BKITParser.KEY_ELSE:
                self.state = 231
                self.match(BKITParser.KEY_ELSE)
                self.state = 232
                self.listStatement()


            self.state = 235
            self.match(BKITParser.KEY_ENDIF)
            self.state = 236
            self.match(BKITParser.DOT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class For_statementContext(ParserRuleContext):

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

        def KEY_FOR(self):
            return self.getToken(BKITParser.KEY_FOR, 0)

        def LP(self):
            return self.getToken(BKITParser.LP, 0)

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

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

        def exp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(BKITParser.ExpContext)
            else:
                return self.getTypedRuleContext(BKITParser.ExpContext,i)


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

        def RP(self):
            return self.getToken(BKITParser.RP, 0)

        def KEY_DO(self):
            return self.getToken(BKITParser.KEY_DO, 0)

        def listStatement(self):
            return self.getTypedRuleContext(BKITParser.ListStatementContext,0)


        def KEY_ENDFOR(self):
            return self.getToken(BKITParser.KEY_ENDFOR, 0)

        def DOT(self):
            return self.getToken(BKITParser.DOT, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_for_statement

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




    def for_statement(self):

        localctx = BKITParser.For_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_for_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self.match(BKITParser.KEY_FOR)
            self.state = 239
            self.match(BKITParser.LP)
            self.state = 240
            self.match(BKITParser.ID)
            self.state = 241
            self.match(BKITParser.ASSIGN)
            self.state = 242
            self.exp(0)
            self.state = 243
            self.match(BKITParser.CM)
            self.state = 244
            self.exp(0)
            self.state = 245
            self.match(BKITParser.CM)
            self.state = 246
            self.match(BKITParser.ID)
            self.state = 247
            self.match(BKITParser.ASSIGN)
            self.state = 248
            self.exp(0)
            self.state = 249
            self.match(BKITParser.RP)
            self.state = 250
            self.match(BKITParser.KEY_DO)
            self.state = 251
            self.listStatement()
            self.state = 252
            self.match(BKITParser.KEY_ENDFOR)
            self.state = 253
            self.match(BKITParser.DOT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class While_statementContext(ParserRuleContext):

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

        def KEY_WHILE(self):
            return self.getToken(BKITParser.KEY_WHILE, 0)

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def KEY_DO(self):
            return self.getToken(BKITParser.KEY_DO, 0)

        def listStatement(self):
            return self.getTypedRuleContext(BKITParser.ListStatementContext,0)


        def KEY_ENDWHILE(self):
            return self.getToken(BKITParser.KEY_ENDWHILE, 0)

        def DOT(self):
            return self.getToken(BKITParser.DOT, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_while_statement

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




    def while_statement(self):

        localctx = BKITParser.While_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_while_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 255
            self.match(BKITParser.KEY_WHILE)
            self.state = 256
            self.exp(0)
            self.state = 257
            self.match(BKITParser.KEY_DO)
            self.state = 258
            self.listStatement()
            self.state = 259
            self.match(BKITParser.KEY_ENDWHILE)
            self.state = 260
            self.match(BKITParser.DOT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Do_while_statementContext(ParserRuleContext):

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

        def KEY_DO(self):
            return self.getToken(BKITParser.KEY_DO, 0)

        def listStatement(self):
            return self.getTypedRuleContext(BKITParser.ListStatementContext,0)


        def KEY_WHILE(self):
            return self.getToken(BKITParser.KEY_WHILE, 0)

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_do_while_statement

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




    def do_while_statement(self):

        localctx = BKITParser.Do_while_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_do_while_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 262
            self.match(BKITParser.KEY_DO)
            self.state = 263
            self.listStatement()
            self.state = 264
            self.match(BKITParser.KEY_WHILE)
            self.state = 265
            self.exp(0)
            self.state = 266
            self.match(BKITParser.SM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Break_statementContext(ParserRuleContext):

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

        def KEY_BREAK(self):
            return self.getToken(BKITParser.KEY_BREAK, 0)

        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_break_statement

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




    def break_statement(self):

        localctx = BKITParser.Break_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_break_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 268
            self.match(BKITParser.KEY_BREAK)
            self.state = 269
            self.match(BKITParser.SM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Continue_statementContext(ParserRuleContext):

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

        def KEY_CONTINUE(self):
            return self.getToken(BKITParser.KEY_CONTINUE, 0)

        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_continue_statement

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




    def continue_statement(self):

        localctx = BKITParser.Continue_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_continue_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 271
            self.match(BKITParser.KEY_CONTINUE)
            self.state = 272
            self.match(BKITParser.SM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Call_statementContext(ParserRuleContext):

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

        def func_call(self):
            return self.getTypedRuleContext(BKITParser.Func_callContext,0)


        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_call_statement

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




    def call_statement(self):

        localctx = BKITParser.Call_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_call_statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 274
            self.func_call()
            self.state = 275
            self.match(BKITParser.SM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_statementContext(ParserRuleContext):

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

        def KEY_RETURN(self):
            return self.getToken(BKITParser.KEY_RETURN, 0)

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def SM(self):
            return self.getToken(BKITParser.SM, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_return_statement

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




    def return_statement(self):

        localctx = BKITParser.Return_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_return_statement)
        try:
            self.state = 283
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 277
                self.match(BKITParser.KEY_RETURN)
                self.state = 278
                self.exp(0)
                self.state = 279
                self.match(BKITParser.SM)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 281
                self.match(BKITParser.KEY_RETURN)
                self.state = 282
                self.match(BKITParser.SM)
                pass


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


    class ExpContext(ParserRuleContext):

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

        def exp1(self):
            return self.getTypedRuleContext(BKITParser.Exp1Context,0)


        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def EQUAL(self):
            return self.getToken(BKITParser.EQUAL, 0)

        def NOTEQUAL(self):
            return self.getToken(BKITParser.NOTEQUAL, 0)

        def LESS(self):
            return self.getToken(BKITParser.LESS, 0)

        def GREATER(self):
            return self.getToken(BKITParser.GREATER, 0)

        def LESSEQUAL(self):
            return self.getToken(BKITParser.LESSEQUAL, 0)

        def GREATEREQUAL(self):
            return self.getToken(BKITParser.GREATEREQUAL, 0)

        def FNOTEQUAL(self):
            return self.getToken(BKITParser.FNOTEQUAL, 0)

        def FLESS(self):
            return self.getToken(BKITParser.FLESS, 0)

        def FGREATER(self):
            return self.getToken(BKITParser.FGREATER, 0)

        def FLESSEQUAL(self):
            return self.getToken(BKITParser.FLESSEQUAL, 0)

        def FGREATEREQUAL(self):
            return self.getToken(BKITParser.FGREATEREQUAL, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_exp

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



    def exp(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = BKITParser.ExpContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 62
        self.enterRecursionRule(localctx, 62, self.RULE_exp, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 286
            self.exp1(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 323
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,20,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 = 321
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
                    if la_ == 1:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 288
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 289
                        self.match(BKITParser.EQUAL)
                        self.state = 290
                        self.exp1(0)
                        pass

                    elif la_ == 2:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 291
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 292
                        self.match(BKITParser.NOTEQUAL)
                        self.state = 293
                        self.exp1(0)
                        pass

                    elif la_ == 3:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 294
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 295
                        self.match(BKITParser.LESS)
                        self.state = 296
                        self.exp1(0)
                        pass

                    elif la_ == 4:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 297
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 298
                        self.match(BKITParser.GREATER)
                        self.state = 299
                        self.exp1(0)
                        pass

                    elif la_ == 5:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 300
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 301
                        self.match(BKITParser.LESSEQUAL)
                        self.state = 302
                        self.exp1(0)
                        pass

                    elif la_ == 6:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 303
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 304
                        self.match(BKITParser.GREATEREQUAL)
                        self.state = 305
                        self.exp1(0)
                        pass

                    elif la_ == 7:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 306
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 307
                        self.match(BKITParser.FNOTEQUAL)
                        self.state = 308
                        self.exp1(0)
                        pass

                    elif la_ == 8:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 309
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 310
                        self.match(BKITParser.FLESS)
                        self.state = 311
                        self.exp1(0)
                        pass

                    elif la_ == 9:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 312
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 313
                        self.match(BKITParser.FGREATER)
                        self.state = 314
                        self.exp1(0)
                        pass

                    elif la_ == 10:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 315
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 316
                        self.match(BKITParser.FLESSEQUAL)
                        self.state = 317
                        self.exp1(0)
                        pass

                    elif la_ == 11:
                        localctx = BKITParser.ExpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
                        self.state = 318
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 319
                        self.match(BKITParser.FGREATEREQUAL)
                        self.state = 320
                        self.exp1(0)
                        pass

             
                self.state = 325
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,20,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 Exp1Context(ParserRuleContext):

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

        def exp2(self):
            return self.getTypedRuleContext(BKITParser.Exp2Context,0)


        def exp1(self):
            return self.getTypedRuleContext(BKITParser.Exp1Context,0)


        def AND(self):
            return self.getToken(BKITParser.AND, 0)

        def OR(self):
            return self.getToken(BKITParser.OR, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_exp1

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



    def exp1(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = BKITParser.Exp1Context(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 64
        self.enterRecursionRule(localctx, 64, self.RULE_exp1, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.exp2(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 337
            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 = 335
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
                    if la_ == 1:
                        localctx = BKITParser.Exp1Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp1)
                        self.state = 329
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 330
                        self.match(BKITParser.AND)
                        self.state = 331
                        self.exp2(0)
                        pass

                    elif la_ == 2:
                        localctx = BKITParser.Exp1Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp1)
                        self.state = 332
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 333
                        self.match(BKITParser.OR)
                        self.state = 334
                        self.exp2(0)
                        pass

             
                self.state = 339
                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 Exp2Context(ParserRuleContext):

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

        def exp3(self):
            return self.getTypedRuleContext(BKITParser.Exp3Context,0)


        def exp2(self):
            return self.getTypedRuleContext(BKITParser.Exp2Context,0)


        def ADD(self):
            return self.getToken(BKITParser.ADD, 0)

        def FADD(self):
            return self.getToken(BKITParser.FADD, 0)

        def SUB(self):
            return self.getToken(BKITParser.SUB, 0)

        def FSUB(self):
            return self.getToken(BKITParser.FSUB, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_exp2

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



    def exp2(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = BKITParser.Exp2Context(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 66
        self.enterRecursionRule(localctx, 66, self.RULE_exp2, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 341
            self.exp3(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 357
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,24,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 = 355
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
                    if la_ == 1:
                        localctx = BKITParser.Exp2Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp2)
                        self.state = 343
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 344
                        self.match(BKITParser.ADD)
                        self.state = 345
                        self.exp3(0)
                        pass

                    elif la_ == 2:
                        localctx = BKITParser.Exp2Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp2)
                        self.state = 346
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 347
                        self.match(BKITParser.FADD)
                        self.state = 348
                        self.exp3(0)
                        pass

                    elif la_ == 3:
                        localctx = BKITParser.Exp2Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp2)
                        self.state = 349
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 350
                        self.match(BKITParser.SUB)
                        self.state = 351
                        self.exp3(0)
                        pass

                    elif la_ == 4:
                        localctx = BKITParser.Exp2Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp2)
                        self.state = 352
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 353
                        self.match(BKITParser.FSUB)
                        self.state = 354
                        self.exp3(0)
                        pass

             
                self.state = 359
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,24,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 Exp3Context(ParserRuleContext):

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

        def exp4(self):
            return self.getTypedRuleContext(BKITParser.Exp4Context,0)


        def exp3(self):
            return self.getTypedRuleContext(BKITParser.Exp3Context,0)


        def MUL(self):
            return self.getToken(BKITParser.MUL, 0)

        def FMUL(self):
            return self.getToken(BKITParser.FMUL, 0)

        def DIV(self):
            return self.getToken(BKITParser.DIV, 0)

        def FDIV(self):
            return self.getToken(BKITParser.FDIV, 0)

        def MOD(self):
            return self.getToken(BKITParser.MOD, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_exp3

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



    def exp3(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = BKITParser.Exp3Context(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 68
        self.enterRecursionRule(localctx, 68, self.RULE_exp3, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.exp4()
            self._ctx.stop = self._input.LT(-1)
            self.state = 380
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,26,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 = 378
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                    if la_ == 1:
                        localctx = BKITParser.Exp3Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp3)
                        self.state = 363
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 364
                        self.match(BKITParser.MUL)
                        self.state = 365
                        self.exp4()
                        pass

                    elif la_ == 2:
                        localctx = BKITParser.Exp3Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp3)
                        self.state = 366
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 367
                        self.match(BKITParser.FMUL)
                        self.state = 368
                        self.exp4()
                        pass

                    elif la_ == 3:
                        localctx = BKITParser.Exp3Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp3)
                        self.state = 369
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 370
                        self.match(BKITParser.DIV)
                        self.state = 371
                        self.exp4()
                        pass

                    elif la_ == 4:
                        localctx = BKITParser.Exp3Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp3)
                        self.state = 372
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 373
                        self.match(BKITParser.FDIV)
                        self.state = 374
                        self.exp4()
                        pass

                    elif la_ == 5:
                        localctx = BKITParser.Exp3Context(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_exp3)
                        self.state = 375
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 376
                        self.match(BKITParser.MOD)
                        self.state = 377
                        self.exp4()
                        pass

             
                self.state = 382
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,26,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 Exp4Context(ParserRuleContext):

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

        def NOT(self):
            return self.getToken(BKITParser.NOT, 0)

        def exp4(self):
            return self.getTypedRuleContext(BKITParser.Exp4Context,0)


        def exp5(self):
            return self.getTypedRuleContext(BKITParser.Exp5Context,0)


        def getRuleIndex(self):
            return BKITParser.RULE_exp4

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




    def exp4(self):

        localctx = BKITParser.Exp4Context(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_exp4)
        try:
            self.state = 386
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [BKITParser.NOT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 383
                self.match(BKITParser.NOT)
                self.state = 384
                self.exp4()
                pass
            elif token in [BKITParser.SUB, BKITParser.FSUB, BKITParser.LP, BKITParser.INTLIT, BKITParser.FLOATLIT, BKITParser.BOOLLIT, BKITParser.STRINGLIT, BKITParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 385
                self.exp5()
                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 Exp5Context(ParserRuleContext):

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

        def SUB(self):
            return self.getToken(BKITParser.SUB, 0)

        def exp5(self):
            return self.getTypedRuleContext(BKITParser.Exp5Context,0)


        def FSUB(self):
            return self.getToken(BKITParser.FSUB, 0)

        def exp6(self):
            return self.getTypedRuleContext(BKITParser.Exp6Context,0)


        def getRuleIndex(self):
            return BKITParser.RULE_exp5

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




    def exp5(self):

        localctx = BKITParser.Exp5Context(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_exp5)
        try:
            self.state = 393
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [BKITParser.SUB]:
                self.enterOuterAlt(localctx, 1)
                self.state = 388
                self.match(BKITParser.SUB)
                self.state = 389
                self.exp5()
                pass
            elif token in [BKITParser.FSUB]:
                self.enterOuterAlt(localctx, 2)
                self.state = 390
                self.match(BKITParser.FSUB)
                self.state = 391
                self.exp5()
                pass
            elif token in [BKITParser.LP, BKITParser.INTLIT, BKITParser.FLOATLIT, BKITParser.BOOLLIT, BKITParser.STRINGLIT, BKITParser.ID]:
                self.enterOuterAlt(localctx, 3)
                self.state = 392
                self.exp6()
                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 Exp6Context(ParserRuleContext):

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

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


        def LP(self):
            return self.getToken(BKITParser.LP, 0)

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def RP(self):
            return self.getToken(BKITParser.RP, 0)

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

        def element_exp(self):
            return self.getTypedRuleContext(BKITParser.Element_expContext,0)


        def func_call(self):
            return self.getTypedRuleContext(BKITParser.Func_callContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_exp6

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




    def exp6(self):

        localctx = BKITParser.Exp6Context(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_exp6)
        try:
            self.state = 403
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 395
                self.literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 396
                self.match(BKITParser.LP)
                self.state = 397
                self.exp(0)
                self.state = 398
                self.match(BKITParser.RP)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 400
                self.match(BKITParser.ID)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 401
                self.element_exp()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 402
                self.func_call()
                pass


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


    class Element_expContext(ParserRuleContext):

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

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

        def index_operators(self):
            return self.getTypedRuleContext(BKITParser.Index_operatorsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_element_exp

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




    def element_exp(self):

        localctx = BKITParser.Element_expContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_element_exp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 405
            self.match(BKITParser.ID)
            self.state = 406
            self.index_operators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Index_operatorsContext(ParserRuleContext):

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

        def LSB(self):
            return self.getToken(BKITParser.LSB, 0)

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def RSB(self):
            return self.getToken(BKITParser.RSB, 0)

        def index_operators(self):
            return self.getTypedRuleContext(BKITParser.Index_operatorsContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_index_operators

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




    def index_operators(self):

        localctx = BKITParser.Index_operatorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_index_operators)
        try:
            self.state = 417
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 408
                self.match(BKITParser.LSB)
                self.state = 409
                self.exp(0)
                self.state = 410
                self.match(BKITParser.RSB)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 412
                self.match(BKITParser.LSB)
                self.state = 413
                self.exp(0)
                self.state = 414
                self.match(BKITParser.RSB)
                self.state = 415
                self.index_operators()
                pass


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


    class Func_callContext(ParserRuleContext):

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

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

        def LP(self):
            return self.getToken(BKITParser.LP, 0)

        def listExp(self):
            return self.getTypedRuleContext(BKITParser.ListExpContext,0)


        def RP(self):
            return self.getToken(BKITParser.RP, 0)

        def getRuleIndex(self):
            return BKITParser.RULE_func_call

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




    def func_call(self):

        localctx = BKITParser.Func_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_func_call)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self.match(BKITParser.ID)
            self.state = 420
            self.match(BKITParser.LP)
            self.state = 421
            self.listExp()
            self.state = 422
            self.match(BKITParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ListExpContext(ParserRuleContext):

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

        def noNullListExp(self):
            return self.getTypedRuleContext(BKITParser.NoNullListExpContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_listExp

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




    def listExp(self):

        localctx = BKITParser.ListExpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_listExp)
        try:
            self.state = 426
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [BKITParser.SUB, BKITParser.FSUB, BKITParser.NOT, BKITParser.LP, BKITParser.INTLIT, BKITParser.FLOATLIT, BKITParser.BOOLLIT, BKITParser.STRINGLIT, BKITParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 424
                self.noNullListExp()
                pass
            elif token in [BKITParser.RP]:
                self.enterOuterAlt(localctx, 2)

                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 NoNullListExpContext(ParserRuleContext):

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

        def exp(self):
            return self.getTypedRuleContext(BKITParser.ExpContext,0)


        def CM(self):
            return self.getToken(BKITParser.CM, 0)

        def noNullListExp(self):
            return self.getTypedRuleContext(BKITParser.NoNullListExpContext,0)


        def getRuleIndex(self):
            return BKITParser.RULE_noNullListExp

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




    def noNullListExp(self):

        localctx = BKITParser.NoNullListExpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_noNullListExp)
        try:
            self.state = 433
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 428
                self.exp(0)
                self.state = 429
                self.match(BKITParser.CM)
                self.state = 430
                self.noNullListExp()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 432
                self.exp(0)
                pass


        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[31] = self.exp_sempred
        self._predicates[32] = self.exp1_sempred
        self._predicates[33] = self.exp2_sempred
        self._predicates[34] = self.exp3_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 exp_sempred(self, localctx:ExpContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 12)
         

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

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

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

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

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

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

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

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

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

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

    def exp1_sempred(self, localctx:Exp1Context, predIndex:int):
            if predIndex == 11:
                return self.precpred(self._ctx, 3)
         

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

    def exp2_sempred(self, localctx:Exp2Context, predIndex:int):
            if predIndex == 13:
                return self.precpred(self._ctx, 5)
         

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

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

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

    def exp3_sempred(self, localctx:Exp3Context, predIndex:int):
            if predIndex == 17:
                return self.precpred(self._ctx, 6)
         

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

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

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

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




