# Generated from Cmm.g4 by ANTLR 4.6
# encoding: utf-8
from antlr4 import *
from io import StringIO

def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3=")
        buf.write("\u01a9\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("\3\2\7\2>\n\2\f\2\16\2A\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3")
        buf.write("\3\3\3\5\3K\n\3\3\4\3\4\3\4\3\4\5\4Q\n\4\3\4\3\4\3\4\3")
        buf.write("\4\3\4\3\4\3\4\5\4Z\n\4\3\4\3\4\3\4\5\4_\n\4\3\5\3\5\3")
        buf.write("\5\3\5\3\5\3\5\7\5g\n\5\f\5\16\5j\13\5\3\6\3\6\3\6\3\7")
        buf.write("\3\7\3\7\3\7\3\b\3\b\7\bu\n\b\f\b\16\bx\13\b\3\t\3\t\3")
        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u0084\n\n\3\13\3\13")
        buf.write("\3\13\3\13\3\13\3\13\5\13\u008c\n\13\3\f\3\f\5\f\u0090")
        buf.write("\n\f\3\f\3\f\7\f\u0094\n\f\f\f\16\f\u0097\13\f\3\f\3\f")
        buf.write("\3\r\3\r\5\r\u009d\n\r\3\16\3\16\3\16\3\16\5\16\u00a3")
        buf.write("\n\16\3\17\5\17\u00a6\n\17\3\17\3\17\5\17\u00aa\n\17\3")
        buf.write("\17\3\17\6\17\u00ae\n\17\r\17\16\17\u00af\5\17\u00b2\n")
        buf.write("\17\3\20\5\20\u00b5\n\20\3\20\7\20\u00b8\n\20\f\20\16")
        buf.write("\20\u00bb\13\20\3\20\3\20\7\20\u00bf\n\20\f\20\16\20\u00c2")
        buf.write("\13\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3")
        buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
        buf.write("\3\21\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u00df\n\21\f")
        buf.write("\21\16\21\u00e2\13\21\3\22\3\22\3\22\5\22\u00e7\n\22\3")
        buf.write("\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\25\3\25")
        buf.write("\3\25\3\25\3\25\5\25\u00f7\n\25\3\25\3\25\3\25\5\25\u00fc")
        buf.write("\n\25\3\25\3\25\3\25\3\25\5\25\u0102\n\25\3\25\6\25\u0105")
        buf.write("\n\25\r\25\16\25\u0106\3\25\3\25\5\25\u010b\n\25\3\25")
        buf.write("\3\25\3\25\3\25\5\25\u0111\n\25\3\26\3\26\3\26\3\26\3")
        buf.write("\26\3\26\3\26\3\26\3\26\7\26\u011c\n\26\f\26\16\26\u011f")
        buf.write("\13\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\7")
        buf.write("\27\u012a\n\27\f\27\16\27\u012d\13\27\3\30\3\30\3\30\3")
        buf.write("\30\3\30\3\30\7\30\u0135\n\30\f\30\16\30\u0138\13\30\3")
        buf.write("\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0142\n\31")
        buf.write("\3\31\3\31\3\31\3\31\5\31\u0148\n\31\3\31\3\31\3\31\3")
        buf.write("\31\3\31\5\31\u014f\n\31\3\32\7\32\u0152\n\32\f\32\16")
        buf.write("\32\u0155\13\32\3\32\3\32\5\32\u0159\n\32\3\32\3\32\3")
        buf.write("\32\3\33\3\33\3\33\7\33\u0161\n\33\f\33\16\33\u0164\13")
        buf.write("\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u0176\n\34\3\35\3")
        buf.write("\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u0182")
        buf.write("\n\35\3\35\3\35\3\35\5\35\u0187\n\35\3\35\3\35\3\35\3")
        buf.write("\35\3\35\3\35\5\35\u018f\n\35\3\35\3\35\5\35\u0193\n\35")
        buf.write("\3\35\3\35\3\35\5\35\u0198\n\35\3\35\3\35\5\35\u019c\n")
        buf.write("\35\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u01a4\n\36\3\36")
        buf.write("\5\36\u01a7\n\36\3\36\2\7\b *,.\37\2\4\6\b\n\f\16\20\22")
        buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:\2\6\3\2\r\20")
        buf.write("\4\2&&((\3\2\31\32\7\2\"&((*+/\609:\u01d6\2?\3\2\2\2\4")
        buf.write("J\3\2\2\2\6^\3\2\2\2\b`\3\2\2\2\nk\3\2\2\2\fn\3\2\2\2")
        buf.write("\16r\3\2\2\2\20y\3\2\2\2\22\u0083\3\2\2\2\24\u008b\3\2")
        buf.write("\2\2\26\u008d\3\2\2\2\30\u009c\3\2\2\2\32\u00a2\3\2\2")
        buf.write("\2\34\u00b1\3\2\2\2\36\u00b4\3\2\2\2 \u00c3\3\2\2\2\"")
        buf.write("\u00e3\3\2\2\2$\u00ea\3\2\2\2&\u00ef\3\2\2\2(\u0110\3")
        buf.write("\2\2\2*\u0112\3\2\2\2,\u0120\3\2\2\2.\u012e\3\2\2\2\60")
        buf.write("\u014e\3\2\2\2\62\u0153\3\2\2\2\64\u015d\3\2\2\2\66\u0175")
        buf.write("\3\2\2\28\u019b\3\2\2\2:\u01a6\3\2\2\2<>\5\4\3\2=<\3\2")
        buf.write("\2\2>A\3\2\2\2?=\3\2\2\2?@\3\2\2\2@B\3\2\2\2A?\3\2\2\2")
        buf.write("BC\7\2\2\3C\3\3\2\2\2DK\5\6\4\2EK\5\f\7\2FG\7\n\2\2GH")
        buf.write("\7\"\2\2HI\7\13\2\2IK\7$\2\2JD\3\2\2\2JE\3\2\2\2JF\3\2")
        buf.write("\2\2K\5\3\2\2\2LM\5\16\b\2MN\7\30\2\2NP\7\34\2\2OQ\5\b")
        buf.write("\5\2PO\3\2\2\2PQ\3\2\2\2QR\3\2\2\2RS\7\35\2\2ST\5\64\33")
        buf.write("\2T_\3\2\2\2UV\5\16\b\2VW\7\30\2\2WY\7\34\2\2XZ\5\b\5")
        buf.write("\2YX\3\2\2\2YZ\3\2\2\2Z[\3\2\2\2[\\\7\35\2\2\\]\7\66\2")
        buf.write("\2]_\3\2\2\2^L\3\2\2\2^U\3\2\2\2_\7\3\2\2\2`a\b\5\1\2")
        buf.write("ab\5\n\6\2bh\3\2\2\2cd\f\3\2\2de\7\67\2\2eg\5\n\6\2fc")
        buf.write("\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi\3\2\2\2i\t\3\2\2\2jh\3")
        buf.write("\2\2\2kl\5\16\b\2lm\5\24\13\2m\13\3\2\2\2no\5\16\b\2o")
        buf.write("p\5\22\n\2pq\7\66\2\2q\r\3\2\2\2rv\5\20\t\2su\7*\2\2t")
        buf.write("s\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2w\17\3\2\2\2xv")
        buf.write("\3\2\2\2yz\t\2\2\2z\21\3\2\2\2{\u0084\5\24\13\2|}\7\30")
        buf.write("\2\2}~\78\2\2~\u0084\5 \21\2\177\u0080\5\24\13\2\u0080")
        buf.write("\u0081\78\2\2\u0081\u0082\5\26\f\2\u0082\u0084\3\2\2\2")
        buf.write("\u0083{\3\2\2\2\u0083|\3\2\2\2\u0083\177\3\2\2\2\u0084")
        buf.write("\23\3\2\2\2\u0085\u008c\7\30\2\2\u0086\u0087\7\30\2\2")
        buf.write("\u0087\u0088\7\36\2\2\u0088\u0089\5\34\17\2\u0089\u008a")
        buf.write("\7\37\2\2\u008a\u008c\3\2\2\2\u008b\u0085\3\2\2\2\u008b")
        buf.write("\u0086\3\2\2\2\u008c\25\3\2\2\2\u008d\u008f\7 \2\2\u008e")
        buf.write("\u0090\5 \21\2\u008f\u008e\3\2\2\2\u008f\u0090\3\2\2\2")
        buf.write("\u0090\u0095\3\2\2\2\u0091\u0092\7\67\2\2\u0092\u0094")
        buf.write("\5 \21\2\u0093\u0091\3\2\2\2\u0094\u0097\3\2\2\2\u0095")
        buf.write("\u0093\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0098\3\2\2\2")
        buf.write("\u0097\u0095\3\2\2\2\u0098\u0099\7!\2\2\u0099\27\3\2\2")
        buf.write("\2\u009a\u009d\7\30\2\2\u009b\u009d\5\32\16\2\u009c\u009a")
        buf.write("\3\2\2\2\u009c\u009b\3\2\2\2\u009d\31\3\2\2\2\u009e\u00a3")
        buf.write("\5\34\17\2\u009f\u00a3\5\36\20\2\u00a0\u00a3\7\b\2\2\u00a1")
        buf.write("\u00a3\7\t\2\2\u00a2\u009e\3\2\2\2\u00a2\u009f\3\2\2\2")
        buf.write("\u00a2\u00a0\3\2\2\2\u00a2\u00a1\3\2\2\2\u00a3\33\3\2")
        buf.write("\2\2\u00a4\u00a6\t\3\2\2\u00a5\u00a4\3\2\2\2\u00a5\u00a6")
        buf.write("\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00b2\t\4\2\2\u00a8")
        buf.write("\u00aa\t\3\2\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2")
        buf.write("\u00aa\u00ab\3\2\2\2\u00ab\u00ad\7\31\2\2\u00ac\u00ae")
        buf.write("\t\4\2\2\u00ad\u00ac\3\2\2\2\u00ae\u00af\3\2\2\2\u00af")
        buf.write("\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b2\3\2\2\2")
        buf.write("\u00b1\u00a5\3\2\2\2\u00b1\u00a9\3\2\2\2\u00b2\35\3\2")
        buf.write("\2\2\u00b3\u00b5\t\3\2\2\u00b4\u00b3\3\2\2\2\u00b4\u00b5")
        buf.write("\3\2\2\2\u00b5\u00b9\3\2\2\2\u00b6\u00b8\t\4\2\2\u00b7")
        buf.write("\u00b6\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2")
        buf.write("\u00b9\u00ba\3\2\2\2\u00ba\u00bc\3\2\2\2\u00bb\u00b9\3")
        buf.write("\2\2\2\u00bc\u00c0\7<\2\2\u00bd\u00bf\t\4\2\2\u00be\u00bd")
        buf.write("\3\2\2\2\u00bf\u00c2\3\2\2\2\u00c0\u00be\3\2\2\2\u00c0")
        buf.write("\u00c1\3\2\2\2\u00c1\37\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c3")
        buf.write("\u00c4\b\21\1\2\u00c4\u00c5\5,\27\2\u00c5\u00e0\3\2\2")
        buf.write("\2\u00c6\u00c7\f\n\2\2\u00c7\u00c8\7\60\2\2\u00c8\u00df")
        buf.write("\5,\27\2\u00c9\u00ca\f\t\2\2\u00ca\u00cb\7/\2\2\u00cb")
        buf.write("\u00df\5,\27\2\u00cc\u00cd\f\b\2\2\u00cd\u00ce\79\2\2")
        buf.write("\u00ce\u00df\5,\27\2\u00cf\u00d0\f\7\2\2\u00d0\u00d1\7")
        buf.write(":\2\2\u00d1\u00df\5,\27\2\u00d2\u00d3\f\6\2\2\u00d3\u00d4")
        buf.write("\7\"\2\2\u00d4\u00df\5,\27\2\u00d5\u00d6\f\5\2\2\u00d6")
        buf.write("\u00d7\7$\2\2\u00d7\u00df\5,\27\2\u00d8\u00d9\f\4\2\2")
        buf.write("\u00d9\u00da\7#\2\2\u00da\u00df\5,\27\2\u00db\u00dc\f")
        buf.write("\3\2\2\u00dc\u00dd\7%\2\2\u00dd\u00df\5,\27\2\u00de\u00c6")
        buf.write("\3\2\2\2\u00de\u00c9\3\2\2\2\u00de\u00cc\3\2\2\2\u00de")
        buf.write("\u00cf\3\2\2\2\u00de\u00d2\3\2\2\2\u00de\u00d5\3\2\2\2")
        buf.write("\u00de\u00d8\3\2\2\2\u00de\u00db\3\2\2\2\u00df\u00e2\3")
        buf.write("\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1!")
        buf.write("\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3\u00e4\7\30\2\2\u00e4")
        buf.write("\u00e6\7\34\2\2\u00e5\u00e7\5.\30\2\u00e6\u00e5\3\2\2")
        buf.write("\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\u00e9")
        buf.write("\7\35\2\2\u00e9#\3\2\2\2\u00ea\u00eb\7\30\2\2\u00eb\u00ec")
        buf.write("\7\36\2\2\u00ec\u00ed\5 \21\2\u00ed\u00ee\7\37\2\2\u00ee")
        buf.write("%\3\2\2\2\u00ef\u00f0\t\5\2\2\u00f0\'\3\2\2\2\u00f1\u0111")
        buf.write("\5\30\r\2\u00f2\u0111\5$\23\2\u00f3\u0111\5\"\22\2\u00f4")
        buf.write("\u00f7\7\30\2\2\u00f5\u00f7\5$\23\2\u00f6\u00f4\3\2\2")
        buf.write("\2\u00f6\u00f5\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u0111")
        buf.write("\7\'\2\2\u00f9\u00fc\7\30\2\2\u00fa\u00fc\5$\23\2\u00fb")
        buf.write("\u00f9\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2")
        buf.write("\u00fd\u0111\7)\2\2\u00fe\u0101\7-\2\2\u00ff\u0102\7\30")
        buf.write("\2\2\u0100\u0102\5$\23\2\u0101\u00ff\3\2\2\2\u0101\u0100")
        buf.write("\3\2\2\2\u0102\u0111\3\2\2\2\u0103\u0105\7*\2\2\u0104")
        buf.write("\u0103\3\2\2\2\u0105\u0106\3\2\2\2\u0106\u0104\3\2\2\2")
        buf.write("\u0106\u0107\3\2\2\2\u0107\u010a\3\2\2\2\u0108\u010b\7")
        buf.write("\30\2\2\u0109\u010b\5$\23\2\u010a\u0108\3\2\2\2\u010a")
        buf.write("\u0109\3\2\2\2\u010b\u0111\3\2\2\2\u010c\u010d\7\34\2")
        buf.write("\2\u010d\u010e\5 \21\2\u010e\u010f\7\35\2\2\u010f\u0111")
        buf.write("\3\2\2\2\u0110\u00f1\3\2\2\2\u0110\u00f2\3\2\2\2\u0110")
        buf.write("\u00f3\3\2\2\2\u0110\u00f6\3\2\2\2\u0110\u00fb\3\2\2\2")
        buf.write("\u0110\u00fe\3\2\2\2\u0110\u0104\3\2\2\2\u0110\u010c\3")
        buf.write("\2\2\2\u0111)\3\2\2\2\u0112\u0113\b\26\1\2\u0113\u0114")
        buf.write("\5(\25\2\u0114\u011d\3\2\2\2\u0115\u0116\f\4\2\2\u0116")
        buf.write("\u0117\7*\2\2\u0117\u011c\5(\25\2\u0118\u0119\f\3\2\2")
        buf.write("\u0119\u011a\7+\2\2\u011a\u011c\5(\25\2\u011b\u0115\3")
        buf.write("\2\2\2\u011b\u0118\3\2\2\2\u011c\u011f\3\2\2\2\u011d\u011b")
        buf.write("\3\2\2\2\u011d\u011e\3\2\2\2\u011e+\3\2\2\2\u011f\u011d")
        buf.write("\3\2\2\2\u0120\u0121\b\27\1\2\u0121\u0122\5*\26\2\u0122")
        buf.write("\u012b\3\2\2\2\u0123\u0124\f\4\2\2\u0124\u0125\7&\2\2")
        buf.write("\u0125\u012a\5*\26\2\u0126\u0127\f\3\2\2\u0127\u0128\7")
        buf.write("(\2\2\u0128\u012a\5*\26\2\u0129\u0123\3\2\2\2\u0129\u0126")
        buf.write("\3\2\2\2\u012a\u012d\3\2\2\2\u012b\u0129\3\2\2\2\u012b")
        buf.write("\u012c\3\2\2\2\u012c-\3\2\2\2\u012d\u012b\3\2\2\2\u012e")
        buf.write("\u012f\b\30\1\2\u012f\u0130\5 \21\2\u0130\u0136\3\2\2")
        buf.write("\2\u0131\u0132\f\3\2\2\u0132\u0133\7\67\2\2\u0133\u0135")
        buf.write("\5 \21\2\u0134\u0131\3\2\2\2\u0135\u0138\3\2\2\2\u0136")
        buf.write("\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137/\3\2\2\2\u0138")
        buf.write("\u0136\3\2\2\2\u0139\u014f\5\66\34\2\u013a\u014f\58\35")
        buf.write("\2\u013b\u014f\5:\36\2\u013c\u013d\5\"\22\2\u013d\u013e")
        buf.write("\7\66\2\2\u013e\u014f\3\2\2\2\u013f\u0142\7\30\2\2\u0140")
        buf.write("\u0142\5$\23\2\u0141\u013f\3\2\2\2\u0141\u0140\3\2\2\2")
        buf.write("\u0142\u0143\3\2\2\2\u0143\u0144\7\'\2\2\u0144\u014f\7")
        buf.write("\66\2\2\u0145\u0148\7\30\2\2\u0146\u0148\5$\23\2\u0147")
        buf.write("\u0145\3\2\2\2\u0147\u0146\3\2\2\2\u0148\u0149\3\2\2\2")
        buf.write("\u0149\u014a\7)\2\2\u014a\u014f\7\66\2\2\u014b\u014c\5")
        buf.write("\62\32\2\u014c\u014d\7\66\2\2\u014d\u014f\3\2\2\2\u014e")
        buf.write("\u0139\3\2\2\2\u014e\u013a\3\2\2\2\u014e\u013b\3\2\2\2")
        buf.write("\u014e\u013c\3\2\2\2\u014e\u0141\3\2\2\2\u014e\u0147\3")
        buf.write("\2\2\2\u014e\u014b\3\2\2\2\u014f\61\3\2\2\2\u0150\u0152")
        buf.write("\7*\2\2\u0151\u0150\3\2\2\2\u0152\u0155\3\2\2\2\u0153")
        buf.write("\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0158\3\2\2\2")
        buf.write("\u0155\u0153\3\2\2\2\u0156\u0159\5\24\13\2\u0157\u0159")
        buf.write("\5$\23\2\u0158\u0156\3\2\2\2\u0158\u0157\3\2\2\2\u0159")
        buf.write("\u015a\3\2\2\2\u015a\u015b\78\2\2\u015b\u015c\5 \21\2")
        buf.write("\u015c\63\3\2\2\2\u015d\u0162\7 \2\2\u015e\u0161\5\f\7")
        buf.write("\2\u015f\u0161\5\60\31\2\u0160\u015e\3\2\2\2\u0160\u015f")
        buf.write("\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162")
        buf.write("\u0163\3\2\2\2\u0163\u0165\3\2\2\2\u0164\u0162\3\2\2\2")
        buf.write("\u0165\u0166\7!\2\2\u0166\65\3\2\2\2\u0167\u0168\7\21")
        buf.write("\2\2\u0168\u0169\7\34\2\2\u0169\u016a\5 \21\2\u016a\u016b")
        buf.write("\7\35\2\2\u016b\u016c\5\64\33\2\u016c\u0176\3\2\2\2\u016d")
        buf.write("\u016e\7\21\2\2\u016e\u016f\7\34\2\2\u016f\u0170\5 \21")
        buf.write("\2\u0170\u0171\7\35\2\2\u0171\u0172\5\64\33\2\u0172\u0173")
        buf.write("\7\22\2\2\u0173\u0174\5\64\33\2\u0174\u0176\3\2\2\2\u0175")
        buf.write("\u0167\3\2\2\2\u0175\u016d\3\2\2\2\u0176\67\3\2\2\2\u0177")
        buf.write("\u0178\7\23\2\2\u0178\u0179\7\34\2\2\u0179\u017a\5 \21")
        buf.write("\2\u017a\u017b\7\35\2\2\u017b\u017c\5\64\33\2\u017c\u019c")
        buf.write("\3\2\2\2\u017d\u017e\7\24\2\2\u017e\u017f\7\34\2\2\u017f")
        buf.write("\u0181\5\f\7\2\u0180\u0182\5 \21\2\u0181\u0180\3\2\2\2")
        buf.write("\u0181\u0182\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u0186\7")
        buf.write("\66\2\2\u0184\u0187\5 \21\2\u0185\u0187\5\62\32\2\u0186")
        buf.write("\u0184\3\2\2\2\u0186\u0185\3\2\2\2\u0186\u0187\3\2\2\2")
        buf.write("\u0187\u0188\3\2\2\2\u0188\u0189\7\35\2\2\u0189\u018a")
        buf.write("\5\64\33\2\u018a\u019c\3\2\2\2\u018b\u018c\7\24\2\2\u018c")
        buf.write("\u018e\7\34\2\2\u018d\u018f\5\62\32\2\u018e\u018d\3\2")
        buf.write("\2\2\u018e\u018f\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0192")
        buf.write("\7\66\2\2\u0191\u0193\5 \21\2\u0192\u0191\3\2\2\2\u0192")
        buf.write("\u0193\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0197\7\66\2")
        buf.write("\2\u0195\u0198\5 \21\2\u0196\u0198\5\62\32\2\u0197\u0195")
        buf.write("\3\2\2\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2\2\u0198")
        buf.write("\u0199\3\2\2\2\u0199\u019a\7\35\2\2\u019a\u019c\5\64\33")
        buf.write("\2\u019b\u0177\3\2\2\2\u019b\u017d\3\2\2\2\u019b\u018b")
        buf.write("\3\2\2\2\u019c9\3\2\2\2\u019d\u019e\7\26\2\2\u019e\u01a7")
        buf.write("\7\66\2\2\u019f\u01a0\7\25\2\2\u01a0\u01a7\7\66\2\2\u01a1")
        buf.write("\u01a3\7\27\2\2\u01a2\u01a4\5 \21\2\u01a3\u01a2\3\2\2")
        buf.write("\2\u01a3\u01a4\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a7")
        buf.write("\7\66\2\2\u01a6\u019d\3\2\2\2\u01a6\u019f\3\2\2\2\u01a6")
        buf.write("\u01a1\3\2\2\2\u01a7;\3\2\2\2\64?JPY^hv\u0083\u008b\u008f")
        buf.write("\u0095\u009c\u00a2\u00a5\u00a9\u00af\u00b1\u00b4\u00b9")
        buf.write("\u00c0\u00de\u00e0\u00e6\u00f6\u00fb\u0101\u0106\u010a")
        buf.write("\u0110\u011b\u011d\u0129\u012b\u0136\u0141\u0147\u014e")
        buf.write("\u0153\u0158\u0160\u0162\u0175\u0181\u0186\u018e\u0192")
        buf.write("\u0197\u019b\u01a3\u01a6")
        return buf.getvalue()


class CmmParser ( Parser ):

    grammarFileName = "Cmm.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'''", "<INVALID>", "<INVALID>", "'#include'", 
                     "'stdio.h'", "'const'", "'void'", "'int'", "'float'", 
                     "'char'", "'if'", "'else'", "'while'", "'for'", "'break'", 
                     "'continue'", "'return'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'('", "')'", "'['", "']'", 
                     "'{'", "'}'", "'<'", "'<='", "'>'", "'>='", "'+'", 
                     "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", "'&'", 
                     "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", "'?'", 
                     "':'", "';'", "','", "'='", "'=='", "'!='", "'->'", 
                     "'.'", "'#'" ]

    symbolicNames = [ "<INVALID>", "WS", "Newline", "BlockComment", "LineComment", 
                      "Apostrophe", "Character", "String", "Include", "Stdio", 
                      "Const", "Void", "Int", "Float", "Char", "If", "Else", 
                      "While", "For", "Break", "Continue", "Return", "Identifier", 
                      "NonZeroDigit", "ZeroDigit", "Nondigit", "LeftParen", 
                      "RightParen", "LeftBracket", "RightBracket", "LeftBrace", 
                      "RightBrace", "Less", "LessEqual", "Greater", "GreaterEqual", 
                      "Plus", "PlusPlus", "Minus", "MinusMinus", "Star", 
                      "Div", "Mod", "And", "Or", "AndAnd", "OrOr", "Caret", 
                      "Not", "Tilde", "Question", "Colon", "Semicolon", 
                      "Comma", "Assign", "Equal", "NotEqual", "Arrow", "Dot", 
                      "Pound" ]

    RULE_program = 0
    RULE_externalDeclaration = 1
    RULE_functionDeclaration = 2
    RULE_parameterList = 3
    RULE_parameterDeclaration = 4
    RULE_declaration = 5
    RULE_declarationSpecifier = 6
    RULE_typeSpecifier = 7
    RULE_initDeclarator = 8
    RULE_declarator = 9
    RULE_initializerList = 10
    RULE_primaryExpression = 11
    RULE_constant = 12
    RULE_integerConstant = 13
    RULE_floatingConstant = 14
    RULE_expression = 15
    RULE_functionCallExpression = 16
    RULE_arrayExpression = 17
    RULE_binaryOperator = 18
    RULE_atomExpression = 19
    RULE_multiplicativeExpression = 20
    RULE_additiveExpression = 21
    RULE_argumentExpressionList = 22
    RULE_statement = 23
    RULE_assignment = 24
    RULE_compoundStatement = 25
    RULE_ifStatement = 26
    RULE_iterationStatement = 27
    RULE_jumpStatement = 28

    ruleNames =  [ "program", "externalDeclaration", "functionDeclaration", 
                   "parameterList", "parameterDeclaration", "declaration", 
                   "declarationSpecifier", "typeSpecifier", "initDeclarator", 
                   "declarator", "initializerList", "primaryExpression", 
                   "constant", "integerConstant", "floatingConstant", "expression", 
                   "functionCallExpression", "arrayExpression", "binaryOperator", 
                   "atomExpression", "multiplicativeExpression", "additiveExpression", 
                   "argumentExpressionList", "statement", "assignment", 
                   "compoundStatement", "ifStatement", "iterationStatement", 
                   "jumpStatement" ]

    EOF = Token.EOF
    WS=1
    Newline=2
    BlockComment=3
    LineComment=4
    Apostrophe=5
    Character=6
    String=7
    Include=8
    Stdio=9
    Const=10
    Void=11
    Int=12
    Float=13
    Char=14
    If=15
    Else=16
    While=17
    For=18
    Break=19
    Continue=20
    Return=21
    Identifier=22
    NonZeroDigit=23
    ZeroDigit=24
    Nondigit=25
    LeftParen=26
    RightParen=27
    LeftBracket=28
    RightBracket=29
    LeftBrace=30
    RightBrace=31
    Less=32
    LessEqual=33
    Greater=34
    GreaterEqual=35
    Plus=36
    PlusPlus=37
    Minus=38
    MinusMinus=39
    Star=40
    Div=41
    Mod=42
    And=43
    Or=44
    AndAnd=45
    OrOr=46
    Caret=47
    Not=48
    Tilde=49
    Question=50
    Colon=51
    Semicolon=52
    Comma=53
    Assign=54
    Equal=55
    NotEqual=56
    Arrow=57
    Dot=58
    Pound=59

    def __init__(self, input:TokenStream):
        super().__init__(input)
        self.checkVersion("4.6")
        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 EOF(self):
            return self.getToken(CmmParser.EOF, 0)

        def externalDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CmmParser.ExternalDeclarationContext)
            else:
                return self.getTypedRuleContext(CmmParser.ExternalDeclarationContext,i)


        def getRuleIndex(self):
            return CmmParser.RULE_program

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

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

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




    def program(self):

        localctx = CmmParser.ProgramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_program)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 61
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Include) | (1 << CmmParser.Void) | (1 << CmmParser.Int) | (1 << CmmParser.Float) | (1 << CmmParser.Char))) != 0):
                self.state = 58
                self.externalDeclaration()
                self.state = 63
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class ExternalDeclarationContext(ParserRuleContext):

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

        def functionDeclaration(self):
            return self.getTypedRuleContext(CmmParser.FunctionDeclarationContext,0)


        def declaration(self):
            return self.getTypedRuleContext(CmmParser.DeclarationContext,0)


        def Include(self):
            return self.getToken(CmmParser.Include, 0)

        def Less(self):
            return self.getToken(CmmParser.Less, 0)

        def Stdio(self):
            return self.getToken(CmmParser.Stdio, 0)

        def Greater(self):
            return self.getToken(CmmParser.Greater, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_externalDeclaration

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

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

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




    def externalDeclaration(self):

        localctx = CmmParser.ExternalDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_externalDeclaration)
        try:
            self.state = 72
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 66
                self.functionDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 67
                self.declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 68
                self.match(CmmParser.Include)
                self.state = 69
                self.match(CmmParser.Less)
                self.state = 70
                self.match(CmmParser.Stdio)
                self.state = 71
                self.match(CmmParser.Greater)
                pass


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

    class FunctionDeclarationContext(ParserRuleContext):

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

        def declarationSpecifier(self):
            return self.getTypedRuleContext(CmmParser.DeclarationSpecifierContext,0)


        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def LeftParen(self):
            return self.getToken(CmmParser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CmmParser.RightParen, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CmmParser.CompoundStatementContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(CmmParser.ParameterListContext,0)


        def Semicolon(self):
            return self.getToken(CmmParser.Semicolon, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_functionDeclaration

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

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

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




    def functionDeclaration(self):

        localctx = CmmParser.FunctionDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_functionDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 92
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 74
                self.declarationSpecifier()
                self.state = 75
                self.match(CmmParser.Identifier)
                self.state = 76
                self.match(CmmParser.LeftParen)
                self.state = 78
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Void) | (1 << CmmParser.Int) | (1 << CmmParser.Float) | (1 << CmmParser.Char))) != 0):
                    self.state = 77
                    self.parameterList(0)


                self.state = 80
                self.match(CmmParser.RightParen)
                self.state = 81
                self.compoundStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 83
                self.declarationSpecifier()
                self.state = 84
                self.match(CmmParser.Identifier)
                self.state = 85
                self.match(CmmParser.LeftParen)
                self.state = 87
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Void) | (1 << CmmParser.Int) | (1 << CmmParser.Float) | (1 << CmmParser.Char))) != 0):
                    self.state = 86
                    self.parameterList(0)


                self.state = 89
                self.match(CmmParser.RightParen)
                self.state = 90
                self.match(CmmParser.Semicolon)
                pass


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

    class ParameterListContext(ParserRuleContext):

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

        def parameterDeclaration(self):
            return self.getTypedRuleContext(CmmParser.ParameterDeclarationContext,0)


        def parameterList(self):
            return self.getTypedRuleContext(CmmParser.ParameterListContext,0)


        def Comma(self):
            return self.getToken(CmmParser.Comma, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_parameterList

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

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

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



    def parameterList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CmmParser.ParameterListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 6
        self.enterRecursionRule(localctx, 6, self.RULE_parameterList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 95
            self.parameterDeclaration()
            self._ctx.stop = self._input.LT(-1)
            self.state = 102
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CmmParser.ParameterListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_parameterList)
                    self.state = 97
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 98
                    self.match(CmmParser.Comma)
                    self.state = 99
                    self.parameterDeclaration() 
                self.state = 104
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,5,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 ParameterDeclarationContext(ParserRuleContext):

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

        def declarationSpecifier(self):
            return self.getTypedRuleContext(CmmParser.DeclarationSpecifierContext,0)


        def declarator(self):
            return self.getTypedRuleContext(CmmParser.DeclaratorContext,0)


        def getRuleIndex(self):
            return CmmParser.RULE_parameterDeclaration

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

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

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




    def parameterDeclaration(self):

        localctx = CmmParser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_parameterDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 105
            self.declarationSpecifier()
            self.state = 106
            self.declarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DeclarationContext(ParserRuleContext):

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

        def declarationSpecifier(self):
            return self.getTypedRuleContext(CmmParser.DeclarationSpecifierContext,0)


        def initDeclarator(self):
            return self.getTypedRuleContext(CmmParser.InitDeclaratorContext,0)


        def Semicolon(self):
            return self.getToken(CmmParser.Semicolon, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_declaration

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

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

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




    def declaration(self):

        localctx = CmmParser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 108
            self.declarationSpecifier()
            self.state = 109
            self.initDeclarator()
            self.state = 110
            self.match(CmmParser.Semicolon)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DeclarationSpecifierContext(ParserRuleContext):

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

        def typeSpecifier(self):
            return self.getTypedRuleContext(CmmParser.TypeSpecifierContext,0)


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

        def getRuleIndex(self):
            return CmmParser.RULE_declarationSpecifier

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

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

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




    def declarationSpecifier(self):

        localctx = CmmParser.DeclarationSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_declarationSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 112
            self.typeSpecifier()
            self.state = 116
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CmmParser.Star:
                self.state = 113
                self.match(CmmParser.Star)
                self.state = 118
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class TypeSpecifierContext(ParserRuleContext):

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

        def Void(self):
            return self.getToken(CmmParser.Void, 0)

        def Char(self):
            return self.getToken(CmmParser.Char, 0)

        def Int(self):
            return self.getToken(CmmParser.Int, 0)

        def Float(self):
            return self.getToken(CmmParser.Float, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_typeSpecifier

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

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

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




    def typeSpecifier(self):

        localctx = CmmParser.TypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_typeSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 119
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Void) | (1 << CmmParser.Int) | (1 << CmmParser.Float) | (1 << CmmParser.Char))) != 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 InitDeclaratorContext(ParserRuleContext):

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

        def declarator(self):
            return self.getTypedRuleContext(CmmParser.DeclaratorContext,0)


        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def Assign(self):
            return self.getToken(CmmParser.Assign, 0)

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


        def initializerList(self):
            return self.getTypedRuleContext(CmmParser.InitializerListContext,0)


        def getRuleIndex(self):
            return CmmParser.RULE_initDeclarator

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

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

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




    def initDeclarator(self):

        localctx = CmmParser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_initDeclarator)
        try:
            self.state = 129
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 121
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 122
                self.match(CmmParser.Identifier)
                self.state = 123
                self.match(CmmParser.Assign)
                self.state = 124
                self.expression(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 125
                self.declarator()
                self.state = 126
                self.match(CmmParser.Assign)
                self.state = 127
                self.initializerList()
                pass


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

    class DeclaratorContext(ParserRuleContext):

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

        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def LeftBracket(self):
            return self.getToken(CmmParser.LeftBracket, 0)

        def integerConstant(self):
            return self.getTypedRuleContext(CmmParser.IntegerConstantContext,0)


        def RightBracket(self):
            return self.getToken(CmmParser.RightBracket, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_declarator

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

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

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




    def declarator(self):

        localctx = CmmParser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_declarator)
        try:
            self.state = 137
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 131
                self.match(CmmParser.Identifier)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 132
                self.match(CmmParser.Identifier)
                self.state = 133
                self.match(CmmParser.LeftBracket)
                self.state = 134
                self.integerConstant()
                self.state = 135
                self.match(CmmParser.RightBracket)
                pass


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

    class InitializerListContext(ParserRuleContext):

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

        def LeftBrace(self):
            return self.getToken(CmmParser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CmmParser.RightBrace, 0)

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


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

        def getRuleIndex(self):
            return CmmParser.RULE_initializerList

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

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

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




    def initializerList(self):

        localctx = CmmParser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 139
            self.match(CmmParser.LeftBrace)
            self.state = 141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Character) | (1 << CmmParser.String) | (1 << CmmParser.Identifier) | (1 << CmmParser.NonZeroDigit) | (1 << CmmParser.ZeroDigit) | (1 << CmmParser.LeftParen) | (1 << CmmParser.Plus) | (1 << CmmParser.Minus) | (1 << CmmParser.Star) | (1 << CmmParser.And) | (1 << CmmParser.Dot))) != 0):
                self.state = 140
                self.expression(0)


            self.state = 147
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CmmParser.Comma:
                self.state = 143
                self.match(CmmParser.Comma)
                self.state = 144
                self.expression(0)
                self.state = 149
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 150
            self.match(CmmParser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PrimaryExpressionContext(ParserRuleContext):

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

        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def constant(self):
            return self.getTypedRuleContext(CmmParser.ConstantContext,0)


        def getRuleIndex(self):
            return CmmParser.RULE_primaryExpression

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

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

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




    def primaryExpression(self):

        localctx = CmmParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_primaryExpression)
        try:
            self.state = 154
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CmmParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 152
                self.match(CmmParser.Identifier)
                pass
            elif token in [CmmParser.Character, CmmParser.String, CmmParser.NonZeroDigit, CmmParser.ZeroDigit, CmmParser.Plus, CmmParser.Minus, CmmParser.Dot]:
                self.enterOuterAlt(localctx, 2)
                self.state = 153
                self.constant()
                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 ConstantContext(ParserRuleContext):

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

        def integerConstant(self):
            return self.getTypedRuleContext(CmmParser.IntegerConstantContext,0)


        def floatingConstant(self):
            return self.getTypedRuleContext(CmmParser.FloatingConstantContext,0)


        def Character(self):
            return self.getToken(CmmParser.Character, 0)

        def String(self):
            return self.getToken(CmmParser.String, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_constant

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

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

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




    def constant(self):

        localctx = CmmParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_constant)
        try:
            self.state = 160
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 156
                self.integerConstant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 157
                self.floatingConstant()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 158
                self.match(CmmParser.Character)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 159
                self.match(CmmParser.String)
                pass


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

    class IntegerConstantContext(ParserRuleContext):

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

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

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

        def Plus(self):
            return self.getToken(CmmParser.Plus, 0)

        def Minus(self):
            return self.getToken(CmmParser.Minus, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_integerConstant

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

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

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




    def integerConstant(self):

        localctx = CmmParser.IntegerConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_integerConstant)
        self._la = 0 # Token type
        try:
            self.state = 175
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CmmParser.Plus or _la==CmmParser.Minus:
                    self.state = 162
                    _la = self._input.LA(1)
                    if not(_la==CmmParser.Plus or _la==CmmParser.Minus):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 165
                _la = self._input.LA(1)
                if not(_la==CmmParser.NonZeroDigit or _la==CmmParser.ZeroDigit):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 167
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CmmParser.Plus or _la==CmmParser.Minus:
                    self.state = 166
                    _la = self._input.LA(1)
                    if not(_la==CmmParser.Plus or _la==CmmParser.Minus):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 169
                self.match(CmmParser.NonZeroDigit)
                self.state = 171 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 170
                        _la = self._input.LA(1)
                        if not(_la==CmmParser.NonZeroDigit or _la==CmmParser.ZeroDigit):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()

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

                pass


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

    class FloatingConstantContext(ParserRuleContext):

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

        def Dot(self):
            return self.getToken(CmmParser.Dot, 0)

        def Plus(self):
            return self.getToken(CmmParser.Plus, 0)

        def Minus(self):
            return self.getToken(CmmParser.Minus, 0)

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

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

        def getRuleIndex(self):
            return CmmParser.RULE_floatingConstant

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

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

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




    def floatingConstant(self):

        localctx = CmmParser.FloatingConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_floatingConstant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 178
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CmmParser.Plus or _la==CmmParser.Minus:
                self.state = 177
                _la = self._input.LA(1)
                if not(_la==CmmParser.Plus or _la==CmmParser.Minus):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 183
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CmmParser.NonZeroDigit or _la==CmmParser.ZeroDigit:
                self.state = 180
                _la = self._input.LA(1)
                if not(_la==CmmParser.NonZeroDigit or _la==CmmParser.ZeroDigit):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 185
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 186
            self.match(CmmParser.Dot)
            self.state = 190
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 187
                    _la = self._input.LA(1)
                    if not(_la==CmmParser.NonZeroDigit or _la==CmmParser.ZeroDigit):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 192
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,19,self._ctx)

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

    class ExpressionContext(ParserRuleContext):

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

        def additiveExpression(self):
            return self.getTypedRuleContext(CmmParser.AdditiveExpressionContext,0)


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


        def OrOr(self):
            return self.getToken(CmmParser.OrOr, 0)

        def AndAnd(self):
            return self.getToken(CmmParser.AndAnd, 0)

        def Equal(self):
            return self.getToken(CmmParser.Equal, 0)

        def NotEqual(self):
            return self.getToken(CmmParser.NotEqual, 0)

        def Less(self):
            return self.getToken(CmmParser.Less, 0)

        def Greater(self):
            return self.getToken(CmmParser.Greater, 0)

        def LessEqual(self):
            return self.getToken(CmmParser.LessEqual, 0)

        def GreaterEqual(self):
            return self.getToken(CmmParser.GreaterEqual, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_expression

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

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

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



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CmmParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 30
        self.enterRecursionRule(localctx, 30, self.RULE_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 194
            self.additiveExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 222
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,21,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 = 220
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                    if la_ == 1:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 196
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 197
                        self.match(CmmParser.OrOr)
                        self.state = 198
                        self.additiveExpression(0)
                        pass

                    elif la_ == 2:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 199
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 200
                        self.match(CmmParser.AndAnd)
                        self.state = 201
                        self.additiveExpression(0)
                        pass

                    elif la_ == 3:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 202
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 203
                        self.match(CmmParser.Equal)
                        self.state = 204
                        self.additiveExpression(0)
                        pass

                    elif la_ == 4:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 205
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 206
                        self.match(CmmParser.NotEqual)
                        self.state = 207
                        self.additiveExpression(0)
                        pass

                    elif la_ == 5:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 208
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 209
                        self.match(CmmParser.Less)
                        self.state = 210
                        self.additiveExpression(0)
                        pass

                    elif la_ == 6:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 211
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 212
                        self.match(CmmParser.Greater)
                        self.state = 213
                        self.additiveExpression(0)
                        pass

                    elif la_ == 7:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 214
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 215
                        self.match(CmmParser.LessEqual)
                        self.state = 216
                        self.additiveExpression(0)
                        pass

                    elif la_ == 8:
                        localctx = CmmParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 217
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 218
                        self.match(CmmParser.GreaterEqual)
                        self.state = 219
                        self.additiveExpression(0)
                        pass

             
                self.state = 224
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,21,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 FunctionCallExpressionContext(ParserRuleContext):

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

        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def LeftParen(self):
            return self.getToken(CmmParser.LeftParen, 0)

        def RightParen(self):
            return self.getToken(CmmParser.RightParen, 0)

        def argumentExpressionList(self):
            return self.getTypedRuleContext(CmmParser.ArgumentExpressionListContext,0)


        def getRuleIndex(self):
            return CmmParser.RULE_functionCallExpression

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

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

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




    def functionCallExpression(self):

        localctx = CmmParser.FunctionCallExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_functionCallExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self.match(CmmParser.Identifier)
            self.state = 226
            self.match(CmmParser.LeftParen)
            self.state = 228
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Character) | (1 << CmmParser.String) | (1 << CmmParser.Identifier) | (1 << CmmParser.NonZeroDigit) | (1 << CmmParser.ZeroDigit) | (1 << CmmParser.LeftParen) | (1 << CmmParser.Plus) | (1 << CmmParser.Minus) | (1 << CmmParser.Star) | (1 << CmmParser.And) | (1 << CmmParser.Dot))) != 0):
                self.state = 227
                self.argumentExpressionList(0)


            self.state = 230
            self.match(CmmParser.RightParen)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArrayExpressionContext(ParserRuleContext):

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

        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def LeftBracket(self):
            return self.getToken(CmmParser.LeftBracket, 0)

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


        def RightBracket(self):
            return self.getToken(CmmParser.RightBracket, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_arrayExpression

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

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

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




    def arrayExpression(self):

        localctx = CmmParser.ArrayExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_arrayExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(CmmParser.Identifier)
            self.state = 233
            self.match(CmmParser.LeftBracket)
            self.state = 234
            self.expression(0)
            self.state = 235
            self.match(CmmParser.RightBracket)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BinaryOperatorContext(ParserRuleContext):

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

        def OrOr(self):
            return self.getToken(CmmParser.OrOr, 0)

        def AndAnd(self):
            return self.getToken(CmmParser.AndAnd, 0)

        def Equal(self):
            return self.getToken(CmmParser.Equal, 0)

        def NotEqual(self):
            return self.getToken(CmmParser.NotEqual, 0)

        def Less(self):
            return self.getToken(CmmParser.Less, 0)

        def Greater(self):
            return self.getToken(CmmParser.Greater, 0)

        def LessEqual(self):
            return self.getToken(CmmParser.LessEqual, 0)

        def GreaterEqual(self):
            return self.getToken(CmmParser.GreaterEqual, 0)

        def Plus(self):
            return self.getToken(CmmParser.Plus, 0)

        def Minus(self):
            return self.getToken(CmmParser.Minus, 0)

        def Star(self):
            return self.getToken(CmmParser.Star, 0)

        def Div(self):
            return self.getToken(CmmParser.Div, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_binaryOperator

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

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

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




    def binaryOperator(self):

        localctx = CmmParser.BinaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_binaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 237
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Less) | (1 << CmmParser.LessEqual) | (1 << CmmParser.Greater) | (1 << CmmParser.GreaterEqual) | (1 << CmmParser.Plus) | (1 << CmmParser.Minus) | (1 << CmmParser.Star) | (1 << CmmParser.Div) | (1 << CmmParser.AndAnd) | (1 << CmmParser.OrOr) | (1 << CmmParser.Equal) | (1 << CmmParser.NotEqual))) != 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 AtomExpressionContext(ParserRuleContext):

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

        def primaryExpression(self):
            return self.getTypedRuleContext(CmmParser.PrimaryExpressionContext,0)


        def arrayExpression(self):
            return self.getTypedRuleContext(CmmParser.ArrayExpressionContext,0)


        def functionCallExpression(self):
            return self.getTypedRuleContext(CmmParser.FunctionCallExpressionContext,0)


        def PlusPlus(self):
            return self.getToken(CmmParser.PlusPlus, 0)

        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def MinusMinus(self):
            return self.getToken(CmmParser.MinusMinus, 0)

        def And(self):
            return self.getToken(CmmParser.And, 0)

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

        def LeftParen(self):
            return self.getToken(CmmParser.LeftParen, 0)

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


        def RightParen(self):
            return self.getToken(CmmParser.RightParen, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_atomExpression

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

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

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




    def atomExpression(self):

        localctx = CmmParser.AtomExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_atomExpression)
        self._la = 0 # Token type
        try:
            self.state = 270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 239
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 240
                self.arrayExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 241
                self.functionCallExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 244
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
                if la_ == 1:
                    self.state = 242
                    self.match(CmmParser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 243
                    self.arrayExpression()
                    pass


                self.state = 246
                self.match(CmmParser.PlusPlus)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 249
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
                if la_ == 1:
                    self.state = 247
                    self.match(CmmParser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 248
                    self.arrayExpression()
                    pass


                self.state = 251
                self.match(CmmParser.MinusMinus)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 252
                self.match(CmmParser.And)
                self.state = 255
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                if la_ == 1:
                    self.state = 253
                    self.match(CmmParser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 254
                    self.arrayExpression()
                    pass


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 258 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 257
                    self.match(CmmParser.Star)
                    self.state = 260 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==CmmParser.Star):
                        break

                self.state = 264
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                if la_ == 1:
                    self.state = 262
                    self.match(CmmParser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 263
                    self.arrayExpression()
                    pass


                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 266
                self.match(CmmParser.LeftParen)
                self.state = 267
                self.expression(0)
                self.state = 268
                self.match(CmmParser.RightParen)
                pass


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

    class MultiplicativeExpressionContext(ParserRuleContext):

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

        def atomExpression(self):
            return self.getTypedRuleContext(CmmParser.AtomExpressionContext,0)


        def multiplicativeExpression(self):
            return self.getTypedRuleContext(CmmParser.MultiplicativeExpressionContext,0)


        def Star(self):
            return self.getToken(CmmParser.Star, 0)

        def Div(self):
            return self.getToken(CmmParser.Div, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_multiplicativeExpression

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

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

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



    def multiplicativeExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CmmParser.MultiplicativeExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 40
        self.enterRecursionRule(localctx, 40, self.RULE_multiplicativeExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 273
            self.atomExpression()
            self._ctx.stop = self._input.LT(-1)
            self.state = 283
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,30,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 = 281
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
                    if la_ == 1:
                        localctx = CmmParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
                        self.state = 275
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 276
                        self.match(CmmParser.Star)
                        self.state = 277
                        self.atomExpression()
                        pass

                    elif la_ == 2:
                        localctx = CmmParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
                        self.state = 278
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 279
                        self.match(CmmParser.Div)
                        self.state = 280
                        self.atomExpression()
                        pass

             
                self.state = 285
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,30,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 AdditiveExpressionContext(ParserRuleContext):

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

        def multiplicativeExpression(self):
            return self.getTypedRuleContext(CmmParser.MultiplicativeExpressionContext,0)


        def additiveExpression(self):
            return self.getTypedRuleContext(CmmParser.AdditiveExpressionContext,0)


        def Plus(self):
            return self.getToken(CmmParser.Plus, 0)

        def Minus(self):
            return self.getToken(CmmParser.Minus, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_additiveExpression

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

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

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



    def additiveExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CmmParser.AdditiveExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 42
        self.enterRecursionRule(localctx, 42, self.RULE_additiveExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 287
            self.multiplicativeExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 297
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,32,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 = 295
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                    if la_ == 1:
                        localctx = CmmParser.AdditiveExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression)
                        self.state = 289
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 290
                        self.match(CmmParser.Plus)
                        self.state = 291
                        self.multiplicativeExpression(0)
                        pass

                    elif la_ == 2:
                        localctx = CmmParser.AdditiveExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression)
                        self.state = 292
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 293
                        self.match(CmmParser.Minus)
                        self.state = 294
                        self.multiplicativeExpression(0)
                        pass

             
                self.state = 299
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,32,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 ArgumentExpressionListContext(ParserRuleContext):

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

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


        def argumentExpressionList(self):
            return self.getTypedRuleContext(CmmParser.ArgumentExpressionListContext,0)


        def Comma(self):
            return self.getToken(CmmParser.Comma, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_argumentExpressionList

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

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

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



    def argumentExpressionList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CmmParser.ArgumentExpressionListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 44
        self.enterRecursionRule(localctx, 44, self.RULE_argumentExpressionList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 301
            self.expression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 308
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CmmParser.ArgumentExpressionListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_argumentExpressionList)
                    self.state = 303
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 304
                    self.match(CmmParser.Comma)
                    self.state = 305
                    self.expression(0) 
                self.state = 310
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,33,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 StatementContext(ParserRuleContext):

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

        def ifStatement(self):
            return self.getTypedRuleContext(CmmParser.IfStatementContext,0)


        def iterationStatement(self):
            return self.getTypedRuleContext(CmmParser.IterationStatementContext,0)


        def jumpStatement(self):
            return self.getTypedRuleContext(CmmParser.JumpStatementContext,0)


        def functionCallExpression(self):
            return self.getTypedRuleContext(CmmParser.FunctionCallExpressionContext,0)


        def Semicolon(self):
            return self.getToken(CmmParser.Semicolon, 0)

        def PlusPlus(self):
            return self.getToken(CmmParser.PlusPlus, 0)

        def Identifier(self):
            return self.getToken(CmmParser.Identifier, 0)

        def arrayExpression(self):
            return self.getTypedRuleContext(CmmParser.ArrayExpressionContext,0)


        def MinusMinus(self):
            return self.getToken(CmmParser.MinusMinus, 0)

        def assignment(self):
            return self.getTypedRuleContext(CmmParser.AssignmentContext,0)


        def getRuleIndex(self):
            return CmmParser.RULE_statement

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

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

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




    def statement(self):

        localctx = CmmParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_statement)
        try:
            self.state = 332
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 311
                self.ifStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 312
                self.iterationStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 313
                self.jumpStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 314
                self.functionCallExpression()
                self.state = 315
                self.match(CmmParser.Semicolon)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 319
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                if la_ == 1:
                    self.state = 317
                    self.match(CmmParser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 318
                    self.arrayExpression()
                    pass


                self.state = 321
                self.match(CmmParser.PlusPlus)
                self.state = 322
                self.match(CmmParser.Semicolon)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 325
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                if la_ == 1:
                    self.state = 323
                    self.match(CmmParser.Identifier)
                    pass

                elif la_ == 2:
                    self.state = 324
                    self.arrayExpression()
                    pass


                self.state = 327
                self.match(CmmParser.MinusMinus)
                self.state = 328
                self.match(CmmParser.Semicolon)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 329
                self.assignment()
                self.state = 330
                self.match(CmmParser.Semicolon)
                pass


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

    class AssignmentContext(ParserRuleContext):

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

        def Assign(self):
            return self.getToken(CmmParser.Assign, 0)

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


        def declarator(self):
            return self.getTypedRuleContext(CmmParser.DeclaratorContext,0)


        def arrayExpression(self):
            return self.getTypedRuleContext(CmmParser.ArrayExpressionContext,0)


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

        def getRuleIndex(self):
            return CmmParser.RULE_assignment

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

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

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




    def assignment(self):

        localctx = CmmParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CmmParser.Star:
                self.state = 334
                self.match(CmmParser.Star)
                self.state = 339
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 342
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.state = 340
                self.declarator()
                pass

            elif la_ == 2:
                self.state = 341
                self.arrayExpression()
                pass


            self.state = 344
            self.match(CmmParser.Assign)
            self.state = 345
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CompoundStatementContext(ParserRuleContext):

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

        def LeftBrace(self):
            return self.getToken(CmmParser.LeftBrace, 0)

        def RightBrace(self):
            return self.getToken(CmmParser.RightBrace, 0)

        def declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CmmParser.DeclarationContext)
            else:
                return self.getTypedRuleContext(CmmParser.DeclarationContext,i)


        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CmmParser.StatementContext)
            else:
                return self.getTypedRuleContext(CmmParser.StatementContext,i)


        def getRuleIndex(self):
            return CmmParser.RULE_compoundStatement

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

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

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




    def compoundStatement(self):

        localctx = CmmParser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 347
            self.match(CmmParser.LeftBrace)
            self.state = 352
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Void) | (1 << CmmParser.Int) | (1 << CmmParser.Float) | (1 << CmmParser.Char) | (1 << CmmParser.If) | (1 << CmmParser.While) | (1 << CmmParser.For) | (1 << CmmParser.Break) | (1 << CmmParser.Continue) | (1 << CmmParser.Return) | (1 << CmmParser.Identifier) | (1 << CmmParser.Star))) != 0):
                self.state = 350
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CmmParser.Void, CmmParser.Int, CmmParser.Float, CmmParser.Char]:
                    self.state = 348
                    self.declaration()
                    pass
                elif token in [CmmParser.If, CmmParser.While, CmmParser.For, CmmParser.Break, CmmParser.Continue, CmmParser.Return, CmmParser.Identifier, CmmParser.Star]:
                    self.state = 349
                    self.statement()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 354
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 355
            self.match(CmmParser.RightBrace)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IfStatementContext(ParserRuleContext):

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

        def If(self):
            return self.getToken(CmmParser.If, 0)

        def LeftParen(self):
            return self.getToken(CmmParser.LeftParen, 0)

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


        def RightParen(self):
            return self.getToken(CmmParser.RightParen, 0)

        def compoundStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CmmParser.CompoundStatementContext)
            else:
                return self.getTypedRuleContext(CmmParser.CompoundStatementContext,i)


        def Else(self):
            return self.getToken(CmmParser.Else, 0)

        def getRuleIndex(self):
            return CmmParser.RULE_ifStatement

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

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

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




    def ifStatement(self):

        localctx = CmmParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_ifStatement)
        try:
            self.state = 371
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 357
                self.match(CmmParser.If)
                self.state = 358
                self.match(CmmParser.LeftParen)
                self.state = 359
                self.expression(0)
                self.state = 360
                self.match(CmmParser.RightParen)
                self.state = 361
                self.compoundStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 363
                self.match(CmmParser.If)
                self.state = 364
                self.match(CmmParser.LeftParen)
                self.state = 365
                self.expression(0)
                self.state = 366
                self.match(CmmParser.RightParen)
                self.state = 367
                self.compoundStatement()
                self.state = 368
                self.match(CmmParser.Else)
                self.state = 369
                self.compoundStatement()
                pass


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

    class IterationStatementContext(ParserRuleContext):

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

        def While(self):
            return self.getToken(CmmParser.While, 0)

        def LeftParen(self):
            return self.getToken(CmmParser.LeftParen, 0)

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


        def RightParen(self):
            return self.getToken(CmmParser.RightParen, 0)

        def compoundStatement(self):
            return self.getTypedRuleContext(CmmParser.CompoundStatementContext,0)


        def For(self):
            return self.getToken(CmmParser.For, 0)

        def declaration(self):
            return self.getTypedRuleContext(CmmParser.DeclarationContext,0)


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

        def assignment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CmmParser.AssignmentContext)
            else:
                return self.getTypedRuleContext(CmmParser.AssignmentContext,i)


        def getRuleIndex(self):
            return CmmParser.RULE_iterationStatement

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

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

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




    def iterationStatement(self):

        localctx = CmmParser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_iterationStatement)
        self._la = 0 # Token type
        try:
            self.state = 409
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 373
                self.match(CmmParser.While)
                self.state = 374
                self.match(CmmParser.LeftParen)
                self.state = 375
                self.expression(0)
                self.state = 376
                self.match(CmmParser.RightParen)
                self.state = 377
                self.compoundStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 379
                self.match(CmmParser.For)
                self.state = 380
                self.match(CmmParser.LeftParen)
                self.state = 381
                self.declaration()
                self.state = 383
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Character) | (1 << CmmParser.String) | (1 << CmmParser.Identifier) | (1 << CmmParser.NonZeroDigit) | (1 << CmmParser.ZeroDigit) | (1 << CmmParser.LeftParen) | (1 << CmmParser.Plus) | (1 << CmmParser.Minus) | (1 << CmmParser.Star) | (1 << CmmParser.And) | (1 << CmmParser.Dot))) != 0):
                    self.state = 382
                    self.expression(0)


                self.state = 385
                self.match(CmmParser.Semicolon)
                self.state = 388
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                if la_ == 1:
                    self.state = 386
                    self.expression(0)

                elif la_ == 2:
                    self.state = 387
                    self.assignment()


                self.state = 390
                self.match(CmmParser.RightParen)
                self.state = 391
                self.compoundStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 393
                self.match(CmmParser.For)
                self.state = 394
                self.match(CmmParser.LeftParen)
                self.state = 396
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CmmParser.Identifier or _la==CmmParser.Star:
                    self.state = 395
                    self.assignment()


                self.state = 398
                self.match(CmmParser.Semicolon)
                self.state = 400
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Character) | (1 << CmmParser.String) | (1 << CmmParser.Identifier) | (1 << CmmParser.NonZeroDigit) | (1 << CmmParser.ZeroDigit) | (1 << CmmParser.LeftParen) | (1 << CmmParser.Plus) | (1 << CmmParser.Minus) | (1 << CmmParser.Star) | (1 << CmmParser.And) | (1 << CmmParser.Dot))) != 0):
                    self.state = 399
                    self.expression(0)


                self.state = 402
                self.match(CmmParser.Semicolon)
                self.state = 405
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
                if la_ == 1:
                    self.state = 403
                    self.expression(0)

                elif la_ == 2:
                    self.state = 404
                    self.assignment()


                self.state = 407
                self.match(CmmParser.RightParen)
                self.state = 408
                self.compoundStatement()
                pass


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

    class JumpStatementContext(ParserRuleContext):

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

        def Continue(self):
            return self.getToken(CmmParser.Continue, 0)

        def Semicolon(self):
            return self.getToken(CmmParser.Semicolon, 0)

        def Break(self):
            return self.getToken(CmmParser.Break, 0)

        def Return(self):
            return self.getToken(CmmParser.Return, 0)

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


        def getRuleIndex(self):
            return CmmParser.RULE_jumpStatement

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

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

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




    def jumpStatement(self):

        localctx = CmmParser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_jumpStatement)
        self._la = 0 # Token type
        try:
            self.state = 420
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CmmParser.Continue]:
                self.enterOuterAlt(localctx, 1)
                self.state = 411
                self.match(CmmParser.Continue)
                self.state = 412
                self.match(CmmParser.Semicolon)
                pass
            elif token in [CmmParser.Break]:
                self.enterOuterAlt(localctx, 2)
                self.state = 413
                self.match(CmmParser.Break)
                self.state = 414
                self.match(CmmParser.Semicolon)
                pass
            elif token in [CmmParser.Return]:
                self.enterOuterAlt(localctx, 3)
                self.state = 415
                self.match(CmmParser.Return)
                self.state = 417
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CmmParser.Character) | (1 << CmmParser.String) | (1 << CmmParser.Identifier) | (1 << CmmParser.NonZeroDigit) | (1 << CmmParser.ZeroDigit) | (1 << CmmParser.LeftParen) | (1 << CmmParser.Plus) | (1 << CmmParser.Minus) | (1 << CmmParser.Star) | (1 << CmmParser.And) | (1 << CmmParser.Dot))) != 0):
                    self.state = 416
                    self.expression(0)


                self.state = 419
                self.match(CmmParser.Semicolon)
                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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[3] = self.parameterList_sempred
        self._predicates[15] = self.expression_sempred
        self._predicates[20] = self.multiplicativeExpression_sempred
        self._predicates[21] = self.additiveExpression_sempred
        self._predicates[22] = self.argumentExpressionList_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 parameterList_sempred(self, localctx:ParameterListContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 8)
         

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

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

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

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

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

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

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

    def multiplicativeExpression_sempred(self, localctx:MultiplicativeExpressionContext, predIndex:int):
            if predIndex == 9:
                return self.precpred(self._ctx, 2)
         

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

    def additiveExpression_sempred(self, localctx:AdditiveExpressionContext, predIndex:int):
            if predIndex == 11:
                return self.precpred(self._ctx, 2)
         

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

    def argumentExpressionList_sempred(self, localctx:ArgumentExpressionListContext, predIndex:int):
            if predIndex == 13:
                return self.precpred(self._ctx, 1)
         




