# Generated from SmallC.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\39")
        buf.write("\u0189\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\3\2\5\2N\n\2\3\2\3\2\3\2\7\2S\n\2\f\2\16\2V\13\2\3\3")
        buf.write("\3\3\3\3\3\3\3\3\5\3]\n\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4")
        buf.write("\3\4\5\4g\n\4\3\4\3\4\3\4\3\5\3\5\3\5\7\5o\n\5\f\5\16")
        buf.write("\5r\13\5\3\6\3\6\3\6\3\7\3\7\3\7\7\7z\n\7\f\7\16\7}\13")
        buf.write("\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u0089\n")
        buf.write("\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u0092\n\t\3\n\3\n\3")
        buf.write("\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\5\13\u009e\n\13\3\13")
        buf.write("\5\13\u00a1\n\13\3\13\5\13\u00a4\n\13\3\13\3\13\5\13\u00a8")
        buf.write("\n\13\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16")
        buf.write("\5\16\u00b5\n\16\3\16\3\16\3\17\5\17\u00ba\n\17\3\17\3")
        buf.write("\17\3\20\3\20\5\20\u00c0\n\20\3\20\3\20\3\21\6\21\u00c5")
        buf.write("\n\21\r\21\16\21\u00c6\3\22\3\22\3\22\7\22\u00cc\n\22")
        buf.write("\f\22\16\22\u00cf\13\22\3\23\3\23\3\23\5\23\u00d4\n\23")
        buf.write("\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u00df")
        buf.write("\n\25\3\25\3\25\3\25\5\25\u00e4\n\25\3\25\7\25\u00e7\n")
        buf.write("\25\f\25\16\25\u00ea\13\25\3\26\3\26\5\26\u00ee\n\26\7")
        buf.write("\26\u00f0\n\26\f\26\16\26\u00f3\13\26\3\27\3\27\3\27\3")
        buf.write("\27\3\27\3\27\7\27\u00fb\n\27\f\27\16\27\u00fe\13\27\3")
        buf.write("\30\3\30\3\30\3\30\3\30\5\30\u0105\n\30\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\5\31\u010e\n\31\3\32\3\32\3\32\3")
        buf.write("\32\3\32\3\32\7\32\u0116\n\32\f\32\16\32\u0119\13\32\3")
        buf.write("\33\3\33\3\33\3\33\3\33\3\33\7\33\u0121\n\33\f\33\16\33")
        buf.write("\u0124\13\33\3\34\3\34\3\34\3\34\3\34\5\34\u012b\n\34")
        buf.write("\3\35\3\35\3\35\3\35\3\35\5\35\u0132\n\35\3\36\3\36\3")
        buf.write("\36\3\36\3\36\3\36\3\36\3\36\3\36\7\36\u013d\n\36\f\36")
        buf.write("\16\36\u0140\13\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37")
        buf.write("\3\37\3\37\7\37\u014b\n\37\f\37\16\37\u014e\13\37\3 \3")
        buf.write(" \3 \3 \3 \3 \3 \5 \u0157\n \3!\3!\3!\3!\3!\5!\u015e\n")
        buf.write("!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u016a\n")
        buf.write("\"\3\"\3\"\5\"\u016e\n\"\7\"\u0170\n\"\f\"\16\"\u0173")
        buf.write("\13\"\3#\3#\3#\3#\3#\3#\5#\u017b\n#\3$\3$\3%\3%\3&\3&")
        buf.write("\3&\7&\u0184\n&\f&\16&\u0187\13&\3&\2\t(,\62\64:<B\'\2")
        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
        buf.write("\668:<>@BDFHJ\2\t\3\2\21\26\3\2\37 \3\2!$\3\2()\5\2\32")
        buf.write("\32%&*+\3\2\648\4\2\27\27,/\u0198\2M\3\2\2\2\4W\3\2\2")
        buf.write("\2\6a\3\2\2\2\bk\3\2\2\2\ns\3\2\2\2\fv\3\2\2\2\16\u0088")
        buf.write("\3\2\2\2\20\u008a\3\2\2\2\22\u0093\3\2\2\2\24\u0099\3")
        buf.write("\2\2\2\26\u00ac\3\2\2\2\30\u00af\3\2\2\2\32\u00b2\3\2")
        buf.write("\2\2\34\u00b9\3\2\2\2\36\u00bd\3\2\2\2 \u00c4\3\2\2\2")
        buf.write("\"\u00c8\3\2\2\2$\u00d0\3\2\2\2&\u00d5\3\2\2\2(\u00de")
        buf.write("\3\2\2\2*\u00f1\3\2\2\2,\u00f4\3\2\2\2.\u0104\3\2\2\2")
        buf.write("\60\u010d\3\2\2\2\62\u010f\3\2\2\2\64\u011a\3\2\2\2\66")
        buf.write("\u012a\3\2\2\28\u0131\3\2\2\2:\u0133\3\2\2\2<\u0141\3")
        buf.write("\2\2\2>\u0156\3\2\2\2@\u015d\3\2\2\2B\u015f\3\2\2\2D\u017a")
        buf.write("\3\2\2\2F\u017c\3\2\2\2H\u017e\3\2\2\2J\u0180\3\2\2\2")
        buf.write("LN\7\3\2\2ML\3\2\2\2MN\3\2\2\2NT\3\2\2\2OS\5\4\3\2PS\5")
        buf.write("\6\4\2QS\5\36\20\2RO\3\2\2\2RP\3\2\2\2RQ\3\2\2\2SV\3\2")
        buf.write("\2\2TR\3\2\2\2TU\3\2\2\2U\3\3\2\2\2VT\3\2\2\2WX\5 \21")
        buf.write("\2XY\5*\26\2YZ\79\2\2Z\\\7\4\2\2[]\5\b\5\2\\[\3\2\2\2")
        buf.write("\\]\3\2\2\2]^\3\2\2\2^_\7\5\2\2_`\7\6\2\2`\5\3\2\2\2a")
        buf.write("b\5 \21\2bc\5*\26\2cd\79\2\2df\7\4\2\2eg\5\b\5\2fe\3\2")
        buf.write("\2\2fg\3\2\2\2gh\3\2\2\2hi\7\5\2\2ij\5\f\7\2j\7\3\2\2")
        buf.write("\2kp\5\n\6\2lm\7\7\2\2mo\5\n\6\2nl\3\2\2\2or\3\2\2\2p")
        buf.write("n\3\2\2\2pq\3\2\2\2q\t\3\2\2\2rp\3\2\2\2st\5 \21\2tu\5")
        buf.write("&\24\2u\13\3\2\2\2v{\7\b\2\2wz\5\36\20\2xz\5\16\b\2yw")
        buf.write("\3\2\2\2yx\3\2\2\2z}\3\2\2\2{y\3\2\2\2{|\3\2\2\2|~\3\2")
        buf.write("\2\2}{\3\2\2\2~\177\7\t\2\2\177\r\3\2\2\2\u0080\u0089")
        buf.write("\5\f\7\2\u0081\u0089\5\20\t\2\u0082\u0089\5\22\n\2\u0083")
        buf.write("\u0089\5\24\13\2\u0084\u0089\5\26\f\2\u0085\u0089\5\30")
        buf.write("\r\2\u0086\u0089\5\32\16\2\u0087\u0089\5\34\17\2\u0088")
        buf.write("\u0080\3\2\2\2\u0088\u0081\3\2\2\2\u0088\u0082\3\2\2\2")
        buf.write("\u0088\u0083\3\2\2\2\u0088\u0084\3\2\2\2\u0088\u0085\3")
        buf.write("\2\2\2\u0088\u0086\3\2\2\2\u0088\u0087\3\2\2\2\u0089\17")
        buf.write("\3\2\2\2\u008a\u008b\7\n\2\2\u008b\u008c\7\4\2\2\u008c")
        buf.write("\u008d\5,\27\2\u008d\u008e\7\5\2\2\u008e\u0091\5\16\b")
        buf.write("\2\u008f\u0090\7\13\2\2\u0090\u0092\5\16\b\2\u0091\u008f")
        buf.write("\3\2\2\2\u0091\u0092\3\2\2\2\u0092\21\3\2\2\2\u0093\u0094")
        buf.write("\7\f\2\2\u0094\u0095\7\4\2\2\u0095\u0096\5,\27\2\u0096")
        buf.write("\u0097\7\5\2\2\u0097\u0098\5\16\b\2\u0098\23\3\2\2\2\u0099")
        buf.write("\u009a\7\r\2\2\u009a\u00a0\7\4\2\2\u009b\u00a1\5\36\20")
        buf.write("\2\u009c\u009e\5,\27\2\u009d\u009c\3\2\2\2\u009d\u009e")
        buf.write("\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a1\7\6\2\2\u00a0")
        buf.write("\u009b\3\2\2\2\u00a0\u009d\3\2\2\2\u00a1\u00a3\3\2\2\2")
        buf.write("\u00a2\u00a4\5,\27\2\u00a3\u00a2\3\2\2\2\u00a3\u00a4\3")
        buf.write("\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a7\7\6\2\2\u00a6\u00a8")
        buf.write("\5,\27\2\u00a7\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8")
        buf.write("\u00a9\3\2\2\2\u00a9\u00aa\7\5\2\2\u00aa\u00ab\5\16\b")
        buf.write("\2\u00ab\25\3\2\2\2\u00ac\u00ad\7\16\2\2\u00ad\u00ae\7")
        buf.write("\6\2\2\u00ae\27\3\2\2\2\u00af\u00b0\7\17\2\2\u00b0\u00b1")
        buf.write("\7\6\2\2\u00b1\31\3\2\2\2\u00b2\u00b4\7\20\2\2\u00b3\u00b5")
        buf.write("\5,\27\2\u00b4\u00b3\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5")
        buf.write("\u00b6\3\2\2\2\u00b6\u00b7\7\6\2\2\u00b7\33\3\2\2\2\u00b8")
        buf.write("\u00ba\5,\27\2\u00b9\u00b8\3\2\2\2\u00b9\u00ba\3\2\2\2")
        buf.write("\u00ba\u00bb\3\2\2\2\u00bb\u00bc\7\6\2\2\u00bc\35\3\2")
        buf.write("\2\2\u00bd\u00bf\5 \21\2\u00be\u00c0\5\"\22\2\u00bf\u00be")
        buf.write("\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c1\3\2\2\2\u00c1")
        buf.write("\u00c2\7\6\2\2\u00c2\37\3\2\2\2\u00c3\u00c5\t\2\2\2\u00c4")
        buf.write("\u00c3\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00c4\3\2\2\2")
        buf.write("\u00c6\u00c7\3\2\2\2\u00c7!\3\2\2\2\u00c8\u00cd\5$\23")
        buf.write("\2\u00c9\u00ca\7\7\2\2\u00ca\u00cc\5$\23\2\u00cb\u00c9")
        buf.write("\3\2\2\2\u00cc\u00cf\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd")
        buf.write("\u00ce\3\2\2\2\u00ce#\3\2\2\2\u00cf\u00cd\3\2\2\2\u00d0")
        buf.write("\u00d3\5&\24\2\u00d1\u00d2\7\27\2\2\u00d2\u00d4\5.\30")
        buf.write("\2\u00d3\u00d1\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4%\3\2")
        buf.write("\2\2\u00d5\u00d6\5*\26\2\u00d6\u00d7\5(\25\2\u00d7\'\3")
        buf.write("\2\2\2\u00d8\u00d9\b\25\1\2\u00d9\u00df\79\2\2\u00da\u00db")
        buf.write("\7\4\2\2\u00db\u00dc\5&\24\2\u00dc\u00dd\7\5\2\2\u00dd")
        buf.write("\u00df\3\2\2\2\u00de\u00d8\3\2\2\2\u00de\u00da\3\2\2\2")
        buf.write("\u00df\u00e8\3\2\2\2\u00e0\u00e1\f\3\2\2\u00e1\u00e3\7")
        buf.write("\30\2\2\u00e2\u00e4\5.\30\2\u00e3\u00e2\3\2\2\2\u00e3")
        buf.write("\u00e4\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e7\7\31\2")
        buf.write("\2\u00e6\u00e0\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6")
        buf.write("\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9)\3\2\2\2\u00ea\u00e8")
        buf.write("\3\2\2\2\u00eb\u00ed\7\32\2\2\u00ec\u00ee\7\25\2\2\u00ed")
        buf.write("\u00ec\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00f0\3\2\2\2")
        buf.write("\u00ef\u00eb\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3")
        buf.write("\2\2\2\u00f1\u00f2\3\2\2\2\u00f2+\3\2\2\2\u00f3\u00f1")
        buf.write("\3\2\2\2\u00f4\u00f5\b\27\1\2\u00f5\u00f6\5.\30\2\u00f6")
        buf.write("\u00fc\3\2\2\2\u00f7\u00f8\f\3\2\2\u00f8\u00f9\7\7\2\2")
        buf.write("\u00f9\u00fb\5.\30\2\u00fa\u00f7\3\2\2\2\u00fb\u00fe\3")
        buf.write("\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd-")
        buf.write("\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff\u0100\5@!\2\u0100\u0101")
        buf.write("\5H%\2\u0101\u0102\5.\30\2\u0102\u0105\3\2\2\2\u0103\u0105")
        buf.write("\5\60\31\2\u0104\u00ff\3\2\2\2\u0104\u0103\3\2\2\2\u0105")
        buf.write("/\3\2\2\2\u0106\u010e\5\62\32\2\u0107\u0108\5\62\32\2")
        buf.write("\u0108\u0109\7\33\2\2\u0109\u010a\5,\27\2\u010a\u010b")
        buf.write("\7\34\2\2\u010b\u010c\5\60\31\2\u010c\u010e\3\2\2\2\u010d")
        buf.write("\u0106\3\2\2\2\u010d\u0107\3\2\2\2\u010e\61\3\2\2\2\u010f")
        buf.write("\u0110\b\32\1\2\u0110\u0111\5\64\33\2\u0111\u0117\3\2")
        buf.write("\2\2\u0112\u0113\f\3\2\2\u0113\u0114\7\35\2\2\u0114\u0116")
        buf.write("\5\64\33\2\u0115\u0112\3\2\2\2\u0116\u0119\3\2\2\2\u0117")
        buf.write("\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118\63\3\2\2\2\u0119")
        buf.write("\u0117\3\2\2\2\u011a\u011b\b\33\1\2\u011b\u011c\5\66\34")
        buf.write("\2\u011c\u0122\3\2\2\2\u011d\u011e\f\3\2\2\u011e\u011f")
        buf.write("\7\36\2\2\u011f\u0121\5\66\34\2\u0120\u011d\3\2\2\2\u0121")
        buf.write("\u0124\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0123\3\2\2\2")
        buf.write("\u0123\65\3\2\2\2\u0124\u0122\3\2\2\2\u0125\u012b\58\35")
        buf.write("\2\u0126\u0127\58\35\2\u0127\u0128\t\3\2\2\u0128\u0129")
        buf.write("\58\35\2\u0129\u012b\3\2\2\2\u012a\u0125\3\2\2\2\u012a")
        buf.write("\u0126\3\2\2\2\u012b\67\3\2\2\2\u012c\u0132\5:\36\2\u012d")
        buf.write("\u012e\5:\36\2\u012e\u012f\t\4\2\2\u012f\u0130\5:\36\2")
        buf.write("\u0130\u0132\3\2\2\2\u0131\u012c\3\2\2\2\u0131\u012d\3")
        buf.write("\2\2\2\u01329\3\2\2\2\u0133\u0134\b\36\1\2\u0134\u0135")
        buf.write("\5<\37\2\u0135\u013e\3\2\2\2\u0136\u0137\f\5\2\2\u0137")
        buf.write("\u0138\7%\2\2\u0138\u013d\5<\37\2\u0139\u013a\f\4\2\2")
        buf.write("\u013a\u013b\7&\2\2\u013b\u013d\5<\37\2\u013c\u0136\3")
        buf.write("\2\2\2\u013c\u0139\3\2\2\2\u013d\u0140\3\2\2\2\u013e\u013c")
        buf.write("\3\2\2\2\u013e\u013f\3\2\2\2\u013f;\3\2\2\2\u0140\u013e")
        buf.write("\3\2\2\2\u0141\u0142\b\37\1\2\u0142\u0143\5> \2\u0143")
        buf.write("\u014c\3\2\2\2\u0144\u0145\f\5\2\2\u0145\u0146\7\32\2")
        buf.write("\2\u0146\u014b\5> \2\u0147\u0148\f\4\2\2\u0148\u0149\7")
        buf.write("\'\2\2\u0149\u014b\5> \2\u014a\u0144\3\2\2\2\u014a\u0147")
        buf.write("\3\2\2\2\u014b\u014e\3\2\2\2\u014c\u014a\3\2\2\2\u014c")
        buf.write("\u014d\3\2\2\2\u014d=\3\2\2\2\u014e\u014c\3\2\2\2\u014f")
        buf.write("\u0157\5@!\2\u0150\u0151\7\4\2\2\u0151\u0152\5 \21\2\u0152")
        buf.write("\u0153\5*\26\2\u0153\u0154\7\5\2\2\u0154\u0155\5> \2\u0155")
        buf.write("\u0157\3\2\2\2\u0156\u014f\3\2\2\2\u0156\u0150\3\2\2\2")
        buf.write("\u0157?\3\2\2\2\u0158\u015e\5B\"\2\u0159\u015a\t\5\2\2")
        buf.write("\u015a\u015e\5@!\2\u015b\u015c\t\6\2\2\u015c\u015e\5>")
        buf.write(" \2\u015d\u0158\3\2\2\2\u015d\u0159\3\2\2\2\u015d\u015b")
        buf.write("\3\2\2\2\u015eA\3\2\2\2\u015f\u0160\b\"\1\2\u0160\u0161")
        buf.write("\5D#\2\u0161\u0171\3\2\2\2\u0162\u016d\f\3\2\2\u0163\u0164")
        buf.write("\7\30\2\2\u0164\u0165\5,\27\2\u0165\u0166\7\31\2\2\u0166")
        buf.write("\u016e\3\2\2\2\u0167\u0169\7\4\2\2\u0168\u016a\5J&\2\u0169")
        buf.write("\u0168\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2")
        buf.write("\u016b\u016e\7\5\2\2\u016c\u016e\t\5\2\2\u016d\u0163\3")
        buf.write("\2\2\2\u016d\u0167\3\2\2\2\u016d\u016c\3\2\2\2\u016e\u0170")
        buf.write("\3\2\2\2\u016f\u0162\3\2\2\2\u0170\u0173\3\2\2\2\u0171")
        buf.write("\u016f\3\2\2\2\u0171\u0172\3\2\2\2\u0172C\3\2\2\2\u0173")
        buf.write("\u0171\3\2\2\2\u0174\u017b\5F$\2\u0175\u017b\79\2\2\u0176")
        buf.write("\u0177\7\4\2\2\u0177\u0178\5,\27\2\u0178\u0179\7\5\2\2")
        buf.write("\u0179\u017b\3\2\2\2\u017a\u0174\3\2\2\2\u017a\u0175\3")
        buf.write("\2\2\2\u017a\u0176\3\2\2\2\u017bE\3\2\2\2\u017c\u017d")
        buf.write("\t\7\2\2\u017dG\3\2\2\2\u017e\u017f\t\b\2\2\u017fI\3\2")
        buf.write("\2\2\u0180\u0185\5.\30\2\u0181\u0182\7\7\2\2\u0182\u0184")
        buf.write("\5.\30\2\u0183\u0181\3\2\2\2\u0184\u0187\3\2\2\2\u0185")
        buf.write("\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186K\3\2\2\2\u0187")
        buf.write("\u0185\3\2\2\2-MRT\\fpy{\u0088\u0091\u009d\u00a0\u00a3")
        buf.write("\u00a7\u00b4\u00b9\u00bf\u00c6\u00cd\u00d3\u00de\u00e3")
        buf.write("\u00e8\u00ed\u00f1\u00fc\u0104\u010d\u0117\u0122\u012a")
        buf.write("\u0131\u013c\u013e\u014a\u014c\u0156\u015d\u0169\u016d")
        buf.write("\u0171\u017a\u0185")
        return buf.getvalue()


class SmallCParser ( Parser ):

    grammarFileName = "SmallC.g4"

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

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

    sharedContextCache = PredictionContextCache()

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

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "Whitespace", "Newline", 
                      "LineComment", "BlockComment", "FloatingConstant", 
                      "IntegerConstant", "CharacterConstant", "StringConstant", 
                      "BoolConstant", "Identifier" ]

    RULE_program = 0
    RULE_functionDeclaration = 1
    RULE_functionDefinition = 2
    RULE_parameterDeclarationList = 3
    RULE_parameterDeclaration = 4
    RULE_compoundStatement = 5
    RULE_statement = 6
    RULE_condStatement = 7
    RULE_whileStatement = 8
    RULE_forStatement = 9
    RULE_breakStatement = 10
    RULE_continueStatement = 11
    RULE_returnStatement = 12
    RULE_exprStatement = 13
    RULE_declaration = 14
    RULE_declarationSpecifiers = 15
    RULE_initDeclaratorList = 16
    RULE_initDeclarator = 17
    RULE_declarator = 18
    RULE_directDeclarator = 19
    RULE_pointer = 20
    RULE_expression = 21
    RULE_assignment = 22
    RULE_condition = 23
    RULE_disjunction = 24
    RULE_conjunction = 25
    RULE_comparison = 26
    RULE_relation = 27
    RULE_plus = 28
    RULE_times = 29
    RULE_cast = 30
    RULE_unary = 31
    RULE_postfix = 32
    RULE_primary = 33
    RULE_constant = 34
    RULE_assignmentOperator = 35
    RULE_expressionList = 36

    ruleNames =  [ "program", "functionDeclaration", "functionDefinition", 
                   "parameterDeclarationList", "parameterDeclaration", "compoundStatement", 
                   "statement", "condStatement", "whileStatement", "forStatement", 
                   "breakStatement", "continueStatement", "returnStatement", 
                   "exprStatement", "declaration", "declarationSpecifiers", 
                   "initDeclaratorList", "initDeclarator", "declarator", 
                   "directDeclarator", "pointer", "expression", "assignment", 
                   "condition", "disjunction", "conjunction", "comparison", 
                   "relation", "plus", "times", "cast", "unary", "postfix", 
                   "primary", "constant", "assignmentOperator", "expressionList" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    Whitespace=46
    Newline=47
    LineComment=48
    BlockComment=49
    FloatingConstant=50
    IntegerConstant=51
    CharacterConstant=52
    StringConstant=53
    BoolConstant=54
    Identifier=55

    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 functionDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SmallCParser.FunctionDeclarationContext)
            else:
                return self.getTypedRuleContext(SmallCParser.FunctionDeclarationContext,i)


        def functionDefinition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SmallCParser.FunctionDefinitionContext)
            else:
                return self.getTypedRuleContext(SmallCParser.FunctionDefinitionContext,i)


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


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.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 = 75
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SmallCParser.T__0:
                self.state = 74
                self.match(SmallCParser.T__0)


            self.state = 82
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__14) | (1 << SmallCParser.T__15) | (1 << SmallCParser.T__16) | (1 << SmallCParser.T__17) | (1 << SmallCParser.T__18) | (1 << SmallCParser.T__19))) != 0):
                self.state = 80
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
                if la_ == 1:
                    self.state = 77
                    self.functionDeclaration()
                    pass

                elif la_ == 2:
                    self.state = 78
                    self.functionDefinition()
                    pass

                elif la_ == 3:
                    self.state = 79
                    self.declaration()
                    pass


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

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

        def declarationSpecifiers(self):
            return self.getTypedRuleContext(SmallCParser.DeclarationSpecifiersContext,0)


        def pointer(self):
            return self.getTypedRuleContext(SmallCParser.PointerContext,0)


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

        def parameterDeclarationList(self):
            return self.getTypedRuleContext(SmallCParser.ParameterDeclarationListContext,0)


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.FunctionDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_functionDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 85
            self.declarationSpecifiers()
            self.state = 86
            self.pointer()
            self.state = 87
            self.match(SmallCParser.Identifier)
            self.state = 88
            self.match(SmallCParser.T__1)
            self.state = 90
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__14) | (1 << SmallCParser.T__15) | (1 << SmallCParser.T__16) | (1 << SmallCParser.T__17) | (1 << SmallCParser.T__18) | (1 << SmallCParser.T__19))) != 0):
                self.state = 89
                self.parameterDeclarationList()


            self.state = 92
            self.match(SmallCParser.T__2)
            self.state = 93
            self.match(SmallCParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FunctionDefinitionContext(ParserRuleContext):

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

        def declarationSpecifiers(self):
            return self.getTypedRuleContext(SmallCParser.DeclarationSpecifiersContext,0)


        def pointer(self):
            return self.getTypedRuleContext(SmallCParser.PointerContext,0)


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

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


        def parameterDeclarationList(self):
            return self.getTypedRuleContext(SmallCParser.ParameterDeclarationListContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_functionDefinition

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

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

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




    def functionDefinition(self):

        localctx = SmallCParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 95
            self.declarationSpecifiers()
            self.state = 96
            self.pointer()
            self.state = 97
            self.match(SmallCParser.Identifier)
            self.state = 98
            self.match(SmallCParser.T__1)
            self.state = 100
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__14) | (1 << SmallCParser.T__15) | (1 << SmallCParser.T__16) | (1 << SmallCParser.T__17) | (1 << SmallCParser.T__18) | (1 << SmallCParser.T__19))) != 0):
                self.state = 99
                self.parameterDeclarationList()


            self.state = 102
            self.match(SmallCParser.T__2)
            self.state = 103
            self.compoundStatement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParameterDeclarationListContext(ParserRuleContext):

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

        def parameterDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SmallCParser.ParameterDeclarationContext)
            else:
                return self.getTypedRuleContext(SmallCParser.ParameterDeclarationContext,i)


        def getRuleIndex(self):
            return SmallCParser.RULE_parameterDeclarationList

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

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

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




    def parameterDeclarationList(self):

        localctx = SmallCParser.ParameterDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_parameterDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 105
            self.parameterDeclaration()
            self.state = 110
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SmallCParser.T__4:
                self.state = 106
                self.match(SmallCParser.T__4)
                self.state = 107
                self.parameterDeclaration()
                self.state = 112
                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 ParameterDeclarationContext(ParserRuleContext):

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

        def declarationSpecifiers(self):
            return self.getTypedRuleContext(SmallCParser.DeclarationSpecifiersContext,0)


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


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_parameterDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 113
            self.declarationSpecifiers()
            self.state = 114
            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 CompoundStatementContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 116
            self.match(SmallCParser.T__5)
            self.state = 121
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__3) | (1 << SmallCParser.T__5) | (1 << SmallCParser.T__7) | (1 << SmallCParser.T__9) | (1 << SmallCParser.T__10) | (1 << SmallCParser.T__11) | (1 << SmallCParser.T__12) | (1 << SmallCParser.T__13) | (1 << SmallCParser.T__14) | (1 << SmallCParser.T__15) | (1 << SmallCParser.T__16) | (1 << SmallCParser.T__17) | (1 << SmallCParser.T__18) | (1 << SmallCParser.T__19) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                self.state = 119
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SmallCParser.T__14, SmallCParser.T__15, SmallCParser.T__16, SmallCParser.T__17, SmallCParser.T__18, SmallCParser.T__19]:
                    self.state = 117
                    self.declaration()
                    pass
                elif token in [SmallCParser.T__1, SmallCParser.T__3, SmallCParser.T__5, SmallCParser.T__7, SmallCParser.T__9, SmallCParser.T__10, SmallCParser.T__11, SmallCParser.T__12, SmallCParser.T__13, SmallCParser.T__23, SmallCParser.T__34, SmallCParser.T__35, SmallCParser.T__37, SmallCParser.T__38, SmallCParser.T__39, SmallCParser.T__40, SmallCParser.FloatingConstant, SmallCParser.IntegerConstant, SmallCParser.CharacterConstant, SmallCParser.StringConstant, SmallCParser.BoolConstant, SmallCParser.Identifier]:
                    self.state = 118
                    self.statement()
                    pass
                else:
                    raise NoViableAltException(self)

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

            self.state = 124
            self.match(SmallCParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StatementContext(ParserRuleContext):

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

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


        def condStatement(self):
            return self.getTypedRuleContext(SmallCParser.CondStatementContext,0)


        def whileStatement(self):
            return self.getTypedRuleContext(SmallCParser.WhileStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(SmallCParser.ForStatementContext,0)


        def breakStatement(self):
            return self.getTypedRuleContext(SmallCParser.BreakStatementContext,0)


        def continueStatement(self):
            return self.getTypedRuleContext(SmallCParser.ContinueStatementContext,0)


        def returnStatement(self):
            return self.getTypedRuleContext(SmallCParser.ReturnStatementContext,0)


        def exprStatement(self):
            return self.getTypedRuleContext(SmallCParser.ExprStatementContext,0)


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_statement)
        try:
            self.state = 134
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SmallCParser.T__5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 126
                self.compoundStatement()
                pass
            elif token in [SmallCParser.T__7]:
                self.enterOuterAlt(localctx, 2)
                self.state = 127
                self.condStatement()
                pass
            elif token in [SmallCParser.T__9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 128
                self.whileStatement()
                pass
            elif token in [SmallCParser.T__10]:
                self.enterOuterAlt(localctx, 4)
                self.state = 129
                self.forStatement()
                pass
            elif token in [SmallCParser.T__11]:
                self.enterOuterAlt(localctx, 5)
                self.state = 130
                self.breakStatement()
                pass
            elif token in [SmallCParser.T__12]:
                self.enterOuterAlt(localctx, 6)
                self.state = 131
                self.continueStatement()
                pass
            elif token in [SmallCParser.T__13]:
                self.enterOuterAlt(localctx, 7)
                self.state = 132
                self.returnStatement()
                pass
            elif token in [SmallCParser.T__1, SmallCParser.T__3, SmallCParser.T__23, SmallCParser.T__34, SmallCParser.T__35, SmallCParser.T__37, SmallCParser.T__38, SmallCParser.T__39, SmallCParser.T__40, SmallCParser.FloatingConstant, SmallCParser.IntegerConstant, SmallCParser.CharacterConstant, SmallCParser.StringConstant, SmallCParser.BoolConstant, SmallCParser.Identifier]:
                self.enterOuterAlt(localctx, 8)
                self.state = 133
                self.exprStatement()
                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 CondStatementContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return SmallCParser.RULE_condStatement

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

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

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




    def condStatement(self):

        localctx = SmallCParser.CondStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_condStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 136
            self.match(SmallCParser.T__7)
            self.state = 137
            self.match(SmallCParser.T__1)
            self.state = 138
            self.expression(0)
            self.state = 139
            self.match(SmallCParser.T__2)
            self.state = 140
            self.statement()
            self.state = 143
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 141
                self.match(SmallCParser.T__8)
                self.state = 142
                self.statement()


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

    class WhileStatementContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return SmallCParser.RULE_whileStatement

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

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

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




    def whileStatement(self):

        localctx = SmallCParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 145
            self.match(SmallCParser.T__9)
            self.state = 146
            self.match(SmallCParser.T__1)
            self.state = 147
            self.expression(0)
            self.state = 148
            self.match(SmallCParser.T__2)
            self.state = 149
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForStatementContext(ParserRuleContext):

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

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


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


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


        def getRuleIndex(self):
            return SmallCParser.RULE_forStatement

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

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

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




    def forStatement(self):

        localctx = SmallCParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 151
            self.match(SmallCParser.T__10)
            self.state = 152
            self.match(SmallCParser.T__1)
            self.state = 158
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SmallCParser.T__14, SmallCParser.T__15, SmallCParser.T__16, SmallCParser.T__17, SmallCParser.T__18, SmallCParser.T__19]:
                self.state = 153
                self.declaration()
                pass
            elif token in [SmallCParser.T__1, SmallCParser.T__3, SmallCParser.T__23, SmallCParser.T__34, SmallCParser.T__35, SmallCParser.T__37, SmallCParser.T__38, SmallCParser.T__39, SmallCParser.T__40, SmallCParser.FloatingConstant, SmallCParser.IntegerConstant, SmallCParser.CharacterConstant, SmallCParser.StringConstant, SmallCParser.BoolConstant, SmallCParser.Identifier]:
                self.state = 155
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                    self.state = 154
                    self.expression(0)


                self.state = 157
                self.match(SmallCParser.T__3)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 161
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                self.state = 160
                self.expression(0)


            self.state = 163
            self.match(SmallCParser.T__3)
            self.state = 165
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                self.state = 164
                self.expression(0)


            self.state = 167
            self.match(SmallCParser.T__2)
            self.state = 168
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BreakStatementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return SmallCParser.RULE_breakStatement

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

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

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




    def breakStatement(self):

        localctx = SmallCParser.BreakStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_breakStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 170
            self.match(SmallCParser.T__11)
            self.state = 171
            self.match(SmallCParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ContinueStatementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return SmallCParser.RULE_continueStatement

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

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

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




    def continueStatement(self):

        localctx = SmallCParser.ContinueStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_continueStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            self.match(SmallCParser.T__12)
            self.state = 174
            self.match(SmallCParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ReturnStatementContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return SmallCParser.RULE_returnStatement

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

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

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




    def returnStatement(self):

        localctx = SmallCParser.ReturnStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_returnStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 176
            self.match(SmallCParser.T__13)
            self.state = 178
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                self.state = 177
                self.expression(0)


            self.state = 180
            self.match(SmallCParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExprStatementContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return SmallCParser.RULE_exprStatement

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

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

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




    def exprStatement(self):

        localctx = SmallCParser.ExprStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_exprStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 183
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                self.state = 182
                self.expression(0)


            self.state = 185
            self.match(SmallCParser.T__3)
        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 declarationSpecifiers(self):
            return self.getTypedRuleContext(SmallCParser.DeclarationSpecifiersContext,0)


        def initDeclaratorList(self):
            return self.getTypedRuleContext(SmallCParser.InitDeclaratorListContext,0)


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 187
            self.declarationSpecifiers()
            self.state = 189
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.Identifier))) != 0):
                self.state = 188
                self.initDeclaratorList()


            self.state = 191
            self.match(SmallCParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DeclarationSpecifiersContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return SmallCParser.RULE_declarationSpecifiers

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

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

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




    def declarationSpecifiers(self):

        localctx = SmallCParser.DeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_declarationSpecifiers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 194 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 193
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__14) | (1 << SmallCParser.T__15) | (1 << SmallCParser.T__16) | (1 << SmallCParser.T__17) | (1 << SmallCParser.T__18) | (1 << SmallCParser.T__19))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 196 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__14) | (1 << SmallCParser.T__15) | (1 << SmallCParser.T__16) | (1 << SmallCParser.T__17) | (1 << SmallCParser.T__18) | (1 << SmallCParser.T__19))) != 0)):
                    break

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

    class InitDeclaratorListContext(ParserRuleContext):

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

        def initDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SmallCParser.InitDeclaratorContext)
            else:
                return self.getTypedRuleContext(SmallCParser.InitDeclaratorContext,i)


        def getRuleIndex(self):
            return SmallCParser.RULE_initDeclaratorList

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

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

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




    def initDeclaratorList(self):

        localctx = SmallCParser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 198
            self.initDeclarator()
            self.state = 203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SmallCParser.T__4:
                self.state = 199
                self.match(SmallCParser.T__4)
                self.state = 200
                self.initDeclarator()
                self.state = 205
                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 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(SmallCParser.DeclaratorContext,0)


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


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 206
            self.declarator()
            self.state = 209
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SmallCParser.T__20:
                self.state = 207
                self.match(SmallCParser.T__20)
                self.state = 208
                self.assignment()


        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 pointer(self):
            return self.getTypedRuleContext(SmallCParser.PointerContext,0)


        def directDeclarator(self):
            return self.getTypedRuleContext(SmallCParser.DirectDeclaratorContext,0)


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self.pointer()
            self.state = 212
            self.directDeclarator(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DirectDeclaratorContext(ParserRuleContext):

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

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

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


        def directDeclarator(self):
            return self.getTypedRuleContext(SmallCParser.DirectDeclaratorContext,0)


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


        def getRuleIndex(self):
            return SmallCParser.RULE_directDeclarator

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

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

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



    def directDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SmallCParser.DirectDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 38
        self.enterRecursionRule(localctx, 38, self.RULE_directDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 220
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SmallCParser.Identifier]:
                self.state = 215
                self.match(SmallCParser.Identifier)
                pass
            elif token in [SmallCParser.T__1]:
                self.state = 216
                self.match(SmallCParser.T__1)
                self.state = 217
                self.declarator()
                self.state = 218
                self.match(SmallCParser.T__2)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 230
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = SmallCParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                    self.state = 222
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 223
                    self.match(SmallCParser.T__21)
                    self.state = 225
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                        self.state = 224
                        self.assignment()


                    self.state = 227
                    self.match(SmallCParser.T__22) 
                self.state = 232
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

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

    class PointerContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return SmallCParser.RULE_pointer

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

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

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




    def pointer(self):

        localctx = SmallCParser.PointerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_pointer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SmallCParser.T__23:
                self.state = 233
                self.match(SmallCParser.T__23)
                self.state = 235
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SmallCParser.T__18:
                    self.state = 234
                    self.match(SmallCParser.T__18)


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

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

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


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


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 42
        self.enterRecursionRule(localctx, 42, self.RULE_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 243
            self.assignment()
            self._ctx.stop = self._input.LT(-1)
            self.state = 250
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,25,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 = SmallCParser.ExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                    self.state = 245
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 246
                    self.match(SmallCParser.T__4)
                    self.state = 247
                    self.assignment() 
                self.state = 252
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,25,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 AssignmentContext(ParserRuleContext):

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

        def unary(self):
            return self.getTypedRuleContext(SmallCParser.UnaryContext,0)


        def assignmentOperator(self):
            return self.getTypedRuleContext(SmallCParser.AssignmentOperatorContext,0)


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


        def condition(self):
            return self.getTypedRuleContext(SmallCParser.ConditionContext,0)


        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_assignment)
        try:
            self.state = 258
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 253
                self.unary()
                self.state = 254
                self.assignmentOperator()
                self.state = 255
                self.assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 257
                self.condition()
                pass


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

    class ConditionContext(ParserRuleContext):

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

        def disjunction(self):
            return self.getTypedRuleContext(SmallCParser.DisjunctionContext,0)


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


        def condition(self):
            return self.getTypedRuleContext(SmallCParser.ConditionContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_condition

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

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

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




    def condition(self):

        localctx = SmallCParser.ConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_condition)
        try:
            self.state = 267
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 260
                self.disjunction(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 261
                self.disjunction(0)
                self.state = 262
                self.match(SmallCParser.T__24)
                self.state = 263
                self.expression(0)
                self.state = 264
                self.match(SmallCParser.T__25)
                self.state = 265
                self.condition()
                pass


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

    class DisjunctionContext(ParserRuleContext):

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

        def conjunction(self):
            return self.getTypedRuleContext(SmallCParser.ConjunctionContext,0)


        def disjunction(self):
            return self.getTypedRuleContext(SmallCParser.DisjunctionContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_disjunction

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

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

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



    def disjunction(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SmallCParser.DisjunctionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 48
        self.enterRecursionRule(localctx, 48, self.RULE_disjunction, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.conjunction(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 277
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,28,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 = SmallCParser.DisjunctionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_disjunction)
                    self.state = 272
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 273
                    self.match(SmallCParser.T__26)
                    self.state = 274
                    self.conjunction(0) 
                self.state = 279
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,28,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 ConjunctionContext(ParserRuleContext):

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

        def comparison(self):
            return self.getTypedRuleContext(SmallCParser.ComparisonContext,0)


        def conjunction(self):
            return self.getTypedRuleContext(SmallCParser.ConjunctionContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_conjunction

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

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

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



    def conjunction(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SmallCParser.ConjunctionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 50
        self.enterRecursionRule(localctx, 50, self.RULE_conjunction, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 281
            self.comparison()
            self._ctx.stop = self._input.LT(-1)
            self.state = 288
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,29,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 = SmallCParser.ConjunctionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_conjunction)
                    self.state = 283
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 284
                    self.match(SmallCParser.T__27)
                    self.state = 285
                    self.comparison() 
                self.state = 290
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,29,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 ComparisonContext(ParserRuleContext):

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

        def relation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SmallCParser.RelationContext)
            else:
                return self.getTypedRuleContext(SmallCParser.RelationContext,i)


        def getRuleIndex(self):
            return SmallCParser.RULE_comparison

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

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

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




    def comparison(self):

        localctx = SmallCParser.ComparisonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_comparison)
        self._la = 0 # Token type
        try:
            self.state = 296
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 291
                self.relation()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 292
                self.relation()
                self.state = 293
                _la = self._input.LA(1)
                if not(_la==SmallCParser.T__28 or _la==SmallCParser.T__29):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 294
                self.relation()
                pass


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

    class RelationContext(ParserRuleContext):

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

        def plus(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SmallCParser.PlusContext)
            else:
                return self.getTypedRuleContext(SmallCParser.PlusContext,i)


        def getRuleIndex(self):
            return SmallCParser.RULE_relation

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

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

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




    def relation(self):

        localctx = SmallCParser.RelationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_relation)
        self._la = 0 # Token type
        try:
            self.state = 303
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 298
                self.plus(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 299
                self.plus(0)
                self.state = 300
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__30) | (1 << SmallCParser.T__31) | (1 << SmallCParser.T__32) | (1 << SmallCParser.T__33))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 301
                self.plus(0)
                pass


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

    class PlusContext(ParserRuleContext):

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

        def times(self):
            return self.getTypedRuleContext(SmallCParser.TimesContext,0)


        def plus(self):
            return self.getTypedRuleContext(SmallCParser.PlusContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_plus

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

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

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



    def plus(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SmallCParser.PlusContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 56
        self.enterRecursionRule(localctx, 56, self.RULE_plus, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 306
            self.times(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 316
            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
                    self.state = 314
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
                    if la_ == 1:
                        localctx = SmallCParser.PlusContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_plus)
                        self.state = 308
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 309
                        self.match(SmallCParser.T__34)
                        self.state = 310
                        self.times(0)
                        pass

                    elif la_ == 2:
                        localctx = SmallCParser.PlusContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_plus)
                        self.state = 311
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 312
                        self.match(SmallCParser.T__35)
                        self.state = 313
                        self.times(0)
                        pass

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

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

        def cast(self):
            return self.getTypedRuleContext(SmallCParser.CastContext,0)


        def times(self):
            return self.getTypedRuleContext(SmallCParser.TimesContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_times

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

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

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



    def times(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SmallCParser.TimesContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 58
        self.enterRecursionRule(localctx, 58, self.RULE_times, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 320
            self.cast()
            self._ctx.stop = self._input.LT(-1)
            self.state = 330
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,35,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 = 328
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                    if la_ == 1:
                        localctx = SmallCParser.TimesContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_times)
                        self.state = 322
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 323
                        self.match(SmallCParser.T__23)
                        self.state = 324
                        self.cast()
                        pass

                    elif la_ == 2:
                        localctx = SmallCParser.TimesContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_times)
                        self.state = 325
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 326
                        self.match(SmallCParser.T__36)
                        self.state = 327
                        self.cast()
                        pass

             
                self.state = 332
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,35,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 CastContext(ParserRuleContext):

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

        def unary(self):
            return self.getTypedRuleContext(SmallCParser.UnaryContext,0)


        def declarationSpecifiers(self):
            return self.getTypedRuleContext(SmallCParser.DeclarationSpecifiersContext,0)


        def pointer(self):
            return self.getTypedRuleContext(SmallCParser.PointerContext,0)


        def cast(self):
            return self.getTypedRuleContext(SmallCParser.CastContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_cast

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

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

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




    def cast(self):

        localctx = SmallCParser.CastContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_cast)
        try:
            self.state = 340
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 333
                self.unary()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 334
                self.match(SmallCParser.T__1)
                self.state = 335
                self.declarationSpecifiers()
                self.state = 336
                self.pointer()
                self.state = 337
                self.match(SmallCParser.T__2)
                self.state = 338
                self.cast()
                pass


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

    class UnaryContext(ParserRuleContext):

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

        def postfix(self):
            return self.getTypedRuleContext(SmallCParser.PostfixContext,0)


        def unary(self):
            return self.getTypedRuleContext(SmallCParser.UnaryContext,0)


        def cast(self):
            return self.getTypedRuleContext(SmallCParser.CastContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_unary

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

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

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




    def unary(self):

        localctx = SmallCParser.UnaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_unary)
        self._la = 0 # Token type
        try:
            self.state = 347
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SmallCParser.T__1, SmallCParser.FloatingConstant, SmallCParser.IntegerConstant, SmallCParser.CharacterConstant, SmallCParser.StringConstant, SmallCParser.BoolConstant, SmallCParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 342
                self.postfix(0)
                pass
            elif token in [SmallCParser.T__37, SmallCParser.T__38]:
                self.enterOuterAlt(localctx, 2)
                self.state = 343
                _la = self._input.LA(1)
                if not(_la==SmallCParser.T__37 or _la==SmallCParser.T__38):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 344
                self.unary()
                pass
            elif token in [SmallCParser.T__23, SmallCParser.T__34, SmallCParser.T__35, SmallCParser.T__39, SmallCParser.T__40]:
                self.enterOuterAlt(localctx, 3)
                self.state = 345
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 346
                self.cast()
                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 PostfixContext(ParserRuleContext):

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

        def primary(self):
            return self.getTypedRuleContext(SmallCParser.PrimaryContext,0)


        def postfix(self):
            return self.getTypedRuleContext(SmallCParser.PostfixContext,0)


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


        def expressionList(self):
            return self.getTypedRuleContext(SmallCParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return SmallCParser.RULE_postfix

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

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

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



    def postfix(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SmallCParser.PostfixContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 64
        self.enterRecursionRule(localctx, 64, self.RULE_postfix, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 350
            self.primary()
            self._ctx.stop = self._input.LT(-1)
            self.state = 367
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,40,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 = SmallCParser.PostfixContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_postfix)
                    self.state = 352
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 363
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [SmallCParser.T__21]:
                        self.state = 353
                        self.match(SmallCParser.T__21)
                        self.state = 354
                        self.expression(0)
                        self.state = 355
                        self.match(SmallCParser.T__22)
                        pass
                    elif token in [SmallCParser.T__1]:
                        self.state = 357
                        self.match(SmallCParser.T__1)
                        self.state = 359
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__1) | (1 << SmallCParser.T__23) | (1 << SmallCParser.T__34) | (1 << SmallCParser.T__35) | (1 << SmallCParser.T__37) | (1 << SmallCParser.T__38) | (1 << SmallCParser.T__39) | (1 << SmallCParser.T__40) | (1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant) | (1 << SmallCParser.Identifier))) != 0):
                            self.state = 358
                            self.expressionList()


                        self.state = 361
                        self.match(SmallCParser.T__2)
                        pass
                    elif token in [SmallCParser.T__37, SmallCParser.T__38]:
                        self.state = 362
                        _la = self._input.LA(1)
                        if not(_la==SmallCParser.T__37 or _la==SmallCParser.T__38):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 369
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,40,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 PrimaryContext(ParserRuleContext):

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

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


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

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


        def getRuleIndex(self):
            return SmallCParser.RULE_primary

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

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

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




    def primary(self):

        localctx = SmallCParser.PrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_primary)
        try:
            self.state = 376
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SmallCParser.FloatingConstant, SmallCParser.IntegerConstant, SmallCParser.CharacterConstant, SmallCParser.StringConstant, SmallCParser.BoolConstant]:
                self.enterOuterAlt(localctx, 1)
                self.state = 370
                self.constant()
                pass
            elif token in [SmallCParser.Identifier]:
                self.enterOuterAlt(localctx, 2)
                self.state = 371
                self.match(SmallCParser.Identifier)
                pass
            elif token in [SmallCParser.T__1]:
                self.enterOuterAlt(localctx, 3)
                self.state = 372
                self.match(SmallCParser.T__1)
                self.state = 373
                self.expression(0)
                self.state = 374
                self.match(SmallCParser.T__2)
                pass
            else:
                raise NoViableAltException(self)

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

    class ConstantContext(ParserRuleContext):

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

        def FloatingConstant(self):
            return self.getToken(SmallCParser.FloatingConstant, 0)

        def IntegerConstant(self):
            return self.getToken(SmallCParser.IntegerConstant, 0)

        def CharacterConstant(self):
            return self.getToken(SmallCParser.CharacterConstant, 0)

        def StringConstant(self):
            return self.getToken(SmallCParser.StringConstant, 0)

        def BoolConstant(self):
            return self.getToken(SmallCParser.BoolConstant, 0)

        def getRuleIndex(self):
            return SmallCParser.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 = SmallCParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_constant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.FloatingConstant) | (1 << SmallCParser.IntegerConstant) | (1 << SmallCParser.CharacterConstant) | (1 << SmallCParser.StringConstant) | (1 << SmallCParser.BoolConstant))) != 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 AssignmentOperatorContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return SmallCParser.RULE_assignmentOperator

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

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

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




    def assignmentOperator(self):

        localctx = SmallCParser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 380
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SmallCParser.T__20) | (1 << SmallCParser.T__41) | (1 << SmallCParser.T__42) | (1 << SmallCParser.T__43) | (1 << SmallCParser.T__44))) != 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 ExpressionListContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return SmallCParser.RULE_expressionList

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

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

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




    def expressionList(self):

        localctx = SmallCParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 382
            self.assignment()
            self.state = 387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SmallCParser.T__4:
                self.state = 383
                self.match(SmallCParser.T__4)
                self.state = 384
                self.assignment()
                self.state = 389
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[19] = self.directDeclarator_sempred
        self._predicates[21] = self.expression_sempred
        self._predicates[24] = self.disjunction_sempred
        self._predicates[25] = self.conjunction_sempred
        self._predicates[28] = self.plus_sempred
        self._predicates[29] = self.times_sempred
        self._predicates[32] = self.postfix_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 directDeclarator_sempred(self, localctx:DirectDeclaratorContext, 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, 1)
         

    def disjunction_sempred(self, localctx:DisjunctionContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 1)
         

    def conjunction_sempred(self, localctx:ConjunctionContext, predIndex:int):
            if predIndex == 3:
                return self.precpred(self._ctx, 1)
         

    def plus_sempred(self, localctx:PlusContext, predIndex:int):
            if predIndex == 4:
                return self.precpred(self._ctx, 3)
         

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

    def times_sempred(self, localctx:TimesContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 3)
         

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

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




