# flake8: noqa
# type: ignore
# Generated from C.g4 by ANTLR 4.8
# encoding: utf-8
from ..._vendor.antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3x")
        buf.write("\u0516\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\3\2\3\2\3\2\6\2\u00b4\n\2\r\2\16\2\u00b5")
        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\5\2\u00be\n\2\3\2\3\2\3\2\3\2")
        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3")
        buf.write("\2\5\2\u00d2\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3")
        buf.write("\4\3\4\3\4\3\4\7\4\u00e1\n\4\f\4\16\4\u00e4\13\4\3\5\3")
        buf.write("\5\3\5\3\5\3\5\3\5\3\5\5\5\u00ed\n\5\3\6\3\6\3\6\3\6\3")
        buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6")
        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
        buf.write("\6\3\6\3\6\5\6\u0111\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
        buf.write("\6\5\6\u011b\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
        buf.write("\6\3\6\7\6\u0128\n\6\f\6\16\6\u012b\13\6\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\7\7\u0133\n\7\f\7\16\7\u0136\13\7\3\b\3\b\3")
        buf.write("\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b")
        buf.write("\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u014e\n\b\3\t\3\t\3\n\3\n")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u015f")
        buf.write("\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\3\13\7\13\u016d\n\13\f\13\16\13\u0170\13\13\3\f")
        buf.write("\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\7\f\u017b\n\f\f\f\16")
        buf.write("\f\u017e\13\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r")
        buf.write("\u0189\n\r\f\r\16\r\u018c\13\r\3\16\3\16\3\16\3\16\3\16")
        buf.write("\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\7\16")
        buf.write("\u019d\n\16\f\16\16\16\u01a0\13\16\3\17\3\17\3\17\3\17")
        buf.write("\3\17\3\17\3\17\3\17\3\17\7\17\u01ab\n\17\f\17\16\17\u01ae")
        buf.write("\13\17\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u01b6\n\20\f")
        buf.write("\20\16\20\u01b9\13\20\3\21\3\21\3\21\3\21\3\21\3\21\7")
        buf.write("\21\u01c1\n\21\f\21\16\21\u01c4\13\21\3\22\3\22\3\22\3")
        buf.write("\22\3\22\3\22\7\22\u01cc\n\22\f\22\16\22\u01cf\13\22\3")
        buf.write("\23\3\23\3\23\3\23\3\23\3\23\7\23\u01d7\n\23\f\23\16\23")
        buf.write("\u01da\13\23\3\24\3\24\3\24\3\24\3\24\3\24\7\24\u01e2")
        buf.write("\n\24\f\24\16\24\u01e5\13\24\3\25\3\25\3\25\3\25\3\25")
        buf.write("\3\25\5\25\u01ed\n\25\3\26\3\26\3\26\3\26\3\26\3\26\5")
        buf.write("\26\u01f5\n\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30")
        buf.write("\7\30\u01ff\n\30\f\30\16\30\u0202\13\30\3\31\3\31\3\32")
        buf.write("\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u020e\n\32\3")
        buf.write("\33\6\33\u0211\n\33\r\33\16\33\u0212\3\34\6\34\u0216\n")
        buf.write("\34\r\34\16\34\u0217\3\35\3\35\3\35\3\35\3\35\5\35\u021f")
        buf.write("\n\35\3\36\3\36\3\36\3\36\3\36\3\36\7\36\u0227\n\36\f")
        buf.write("\36\16\36\u022a\13\36\3\37\3\37\3\37\3\37\3\37\5\37\u0231")
        buf.write("\n\37\3 \3 \3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!")
        buf.write("\3!\5!\u0244\n!\3!\3!\7!\u0248\n!\f!\16!\u024b\13!\3\"")
        buf.write("\3\"\5\"\u024f\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u0258")
        buf.write("\n\"\3#\3#\3$\3$\3$\3$\3$\7$\u0261\n$\f$\16$\u0264\13")
        buf.write("$\3%\3%\5%\u0268\n%\3%\3%\3%\5%\u026d\n%\3&\3&\5&\u0271")
        buf.write("\n&\3&\3&\5&\u0275\n&\5&\u0277\n&\3\'\3\'\3\'\3\'\3\'")
        buf.write("\3\'\7\'\u027f\n\'\f\'\16\'\u0282\13\'\3(\3(\5(\u0286")
        buf.write("\n(\3(\3(\5(\u028a\n(\3)\3)\5)\u028e\n)\3)\3)\3)\3)\3")
        buf.write(")\3)\5)\u0296\n)\3)\3)\3)\3)\3)\3)\3)\5)\u029f\n)\3*\3")
        buf.write("*\3*\3*\3*\3*\7*\u02a7\n*\f*\16*\u02aa\13*\3+\3+\3+\3")
        buf.write("+\3+\5+\u02b1\n+\3,\3,\3-\3-\3-\3-\3-\3.\3.\3/\3/\3/\3")
        buf.write("/\3/\3/\5/\u02c2\n/\3\60\3\60\3\60\3\60\3\60\3\60\3\60")
        buf.write("\3\60\3\60\3\60\5\60\u02ce\n\60\3\61\5\61\u02d1\n\61\3")
        buf.write("\61\3\61\7\61\u02d5\n\61\f\61\16\61\u02d8\13\61\3\62\3")
        buf.write("\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\5\62")
        buf.write("\u02e5\n\62\3\62\3\62\3\62\3\62\5\62\u02eb\n\62\3\62\3")
        buf.write("\62\3\62\5\62\u02f0\n\62\3\62\5\62\u02f3\n\62\3\62\3\62")
        buf.write("\3\62\3\62\3\62\5\62\u02fa\n\62\3\62\3\62\3\62\3\62\3")
        buf.write("\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\5\62\u0309")
        buf.write("\n\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62")
        buf.write("\5\62\u0315\n\62\3\62\7\62\u0318\n\62\f\62\16\62\u031b")
        buf.write("\13\62\3\63\3\63\3\63\6\63\u0320\n\63\r\63\16\63\u0321")
        buf.write("\3\63\3\63\5\63\u0326\n\63\3\64\3\64\3\64\3\64\3\64\3")
        buf.write("\64\3\64\3\65\3\65\3\65\7\65\u0332\n\65\f\65\16\65\u0335")
        buf.write("\13\65\3\65\5\65\u0338\n\65\3\66\3\66\3\66\5\66\u033d")
        buf.write("\n\66\3\66\5\66\u0340\n\66\3\66\5\66\u0343\n\66\3\67\3")
        buf.write("\67\3\67\3\67\3\67\7\67\u034a\n\67\f\67\16\67\u034d\13")
        buf.write("\67\38\38\58\u0351\n8\38\38\58\u0355\n8\38\38\38\58\u035a")
        buf.write("\n8\38\38\58\u035e\n8\38\58\u0361\n8\39\39\39\39\39\7")
        buf.write("9\u0368\n9\f9\169\u036b\139\3:\3:\3:\3:\3:\5:\u0372\n")
        buf.write(":\3;\3;\3;\3;\3;\3;\7;\u037a\n;\f;\16;\u037d\13;\3<\3")
        buf.write("<\3<\3<\3<\5<\u0384\n<\5<\u0386\n<\3=\3=\3=\3=\3=\3=\7")
        buf.write("=\u038e\n=\f=\16=\u0391\13=\3>\3>\5>\u0395\n>\3?\3?\5")
        buf.write("?\u0399\n?\3?\3?\7?\u039d\n?\f?\16?\u03a0\13?\5?\u03a2")
        buf.write("\n?\3@\3@\3@\3@\3@\7@\u03a9\n@\f@\16@\u03ac\13@\3@\3@")
        buf.write("\5@\u03b0\n@\3@\5@\u03b3\n@\3@\3@\3@\3@\5@\u03b9\n@\3")
        buf.write("@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u03c9\n@\3")
        buf.write("@\3@\7@\u03cd\n@\f@\16@\u03d0\13@\5@\u03d2\n@\3@\3@\3")
        buf.write("@\5@\u03d7\n@\3@\5@\u03da\n@\3@\3@\3@\3@\3@\5@\u03e1\n")
        buf.write("@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5")
        buf.write("@\u03f4\n@\3@\3@\7@\u03f8\n@\f@\16@\u03fb\13@\7@\u03fd")
        buf.write("\n@\f@\16@\u0400\13@\3A\3A\3B\3B\3B\3B\3B\3B\3B\3B\3B")
        buf.write("\3B\5B\u040e\nB\3C\3C\5C\u0412\nC\3C\3C\3C\3C\3C\5C\u0419")
        buf.write("\nC\3C\7C\u041c\nC\fC\16C\u041f\13C\3D\3D\3D\3E\3E\3E")
        buf.write("\3E\3E\7E\u0429\nE\fE\16E\u042c\13E\3F\3F\3F\3F\3F\3F")
        buf.write("\5F\u0434\nF\3G\3G\3G\3G\3G\6G\u043b\nG\rG\16G\u043c\3")
        buf.write("G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\7H\u044e\n")
        buf.write("H\fH\16H\u0451\13H\5H\u0453\nH\3H\3H\3H\3H\7H\u0459\n")
        buf.write("H\fH\16H\u045c\13H\5H\u045e\nH\7H\u0460\nH\fH\16H\u0463")
        buf.write("\13H\3H\3H\5H\u0467\nH\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3")
        buf.write("I\5I\u0474\nI\3J\3J\5J\u0478\nJ\3J\3J\3K\3K\3K\3K\3K\7")
        buf.write("K\u0481\nK\fK\16K\u0484\13K\3L\3L\5L\u0488\nL\3M\5M\u048b")
        buf.write("\nM\3M\3M\3N\3N\3N\3N\3N\3N\3N\5N\u0496\nN\3N\3N\3N\3")
        buf.write("N\3N\3N\5N\u049e\nN\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3")
        buf.write("O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u04b4\nO\3P\3P\3P\5P\u04b9")
        buf.write("\nP\3P\3P\5P\u04bd\nP\3P\5P\u04c0\nP\3P\3P\5P\u04c4\n")
        buf.write("P\3P\3P\5P\u04c8\nP\5P\u04ca\nP\3Q\3Q\3Q\3Q\5Q\u04d0\n")
        buf.write("Q\3R\3R\3R\3R\3R\3R\7R\u04d8\nR\fR\16R\u04db\13R\3S\3")
        buf.write("S\3S\3S\3S\3S\3S\3S\3S\5S\u04e6\nS\3S\3S\3S\3S\3S\5S\u04ed")
        buf.write("\nS\3T\5T\u04f0\nT\3T\3T\3U\3U\3U\3U\3U\7U\u04f9\nU\f")
        buf.write("U\16U\u04fc\13U\3V\3V\3V\5V\u0501\nV\3W\5W\u0504\nW\3")
        buf.write("W\3W\5W\u0508\nW\3W\3W\3X\3X\3X\3X\3X\7X\u0511\nX\fX\16")
        buf.write("X\u0514\13X\3X\2 \6\n\f\24\26\30\32\34\36 \"$&.:@FLRb")
        buf.write("ptx~\u0084\u0088\u0094\u00a2\u00a8\u00aeY\2\4\6\b\n\f")
        buf.write("\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@")
        buf.write("BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086")
        buf.write("\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098")
        buf.write("\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa")
        buf.write("\u00ac\u00ae\2\16\7\2@@BBDDGGLM\3\2R\\\b\2\5\5\20\20\30")
        buf.write("\30\36\36!!\60\60\n\2\b\b\r\r\21\21\26\27\33\34#$*+\61")
        buf.write("\63\3\2\61\63\4\2\37\37\"\"\6\2\t\t\31\31%%))\5\2\25\25")
        buf.write("..fg\4\2\64\65QQ\3\2\64\65\3\2\3\4\4\2%%jj\2\u058b\2\u00d1")
        buf.write("\3\2\2\2\4\u00d3\3\2\2\2\6\u00da\3\2\2\2\b\u00ec\3\2\2")
        buf.write("\2\n\u0110\3\2\2\2\f\u012c\3\2\2\2\16\u014d\3\2\2\2\20")
        buf.write("\u014f\3\2\2\2\22\u015e\3\2\2\2\24\u0160\3\2\2\2\26\u0171")
        buf.write("\3\2\2\2\30\u017f\3\2\2\2\32\u018d\3\2\2\2\34\u01a1\3")
        buf.write("\2\2\2\36\u01af\3\2\2\2 \u01ba\3\2\2\2\"\u01c5\3\2\2\2")
        buf.write("$\u01d0\3\2\2\2&\u01db\3\2\2\2(\u01e6\3\2\2\2*\u01f4\3")
        buf.write("\2\2\2,\u01f6\3\2\2\2.\u01f8\3\2\2\2\60\u0203\3\2\2\2")
        buf.write("\62\u020d\3\2\2\2\64\u0210\3\2\2\2\66\u0215\3\2\2\28\u021e")
        buf.write("\3\2\2\2:\u0220\3\2\2\2<\u0230\3\2\2\2>\u0232\3\2\2\2")
        buf.write("@\u0243\3\2\2\2B\u0257\3\2\2\2D\u0259\3\2\2\2F\u025b\3")
        buf.write("\2\2\2H\u026c\3\2\2\2J\u0276\3\2\2\2L\u0278\3\2\2\2N\u0289")
        buf.write("\3\2\2\2P\u029e\3\2\2\2R\u02a0\3\2\2\2T\u02b0\3\2\2\2")
        buf.write("V\u02b2\3\2\2\2X\u02b4\3\2\2\2Z\u02b9\3\2\2\2\\\u02c1")
        buf.write("\3\2\2\2^\u02cd\3\2\2\2`\u02d0\3\2\2\2b\u02ea\3\2\2\2")
        buf.write("d\u0325\3\2\2\2f\u0327\3\2\2\2h\u0337\3\2\2\2j\u0342\3")
        buf.write("\2\2\2l\u034b\3\2\2\2n\u0360\3\2\2\2p\u0362\3\2\2\2r\u0371")
        buf.write("\3\2\2\2t\u0373\3\2\2\2v\u0385\3\2\2\2x\u0387\3\2\2\2")
        buf.write("z\u0392\3\2\2\2|\u03a1\3\2\2\2~\u03d1\3\2\2\2\u0080\u0401")
        buf.write("\3\2\2\2\u0082\u040d\3\2\2\2\u0084\u040f\3\2\2\2\u0086")
        buf.write("\u0420\3\2\2\2\u0088\u0423\3\2\2\2\u008a\u0433\3\2\2\2")
        buf.write("\u008c\u0435\3\2\2\2\u008e\u0466\3\2\2\2\u0090\u0473\3")
        buf.write("\2\2\2\u0092\u0475\3\2\2\2\u0094\u047b\3\2\2\2\u0096\u0487")
        buf.write("\3\2\2\2\u0098\u048a\3\2\2\2\u009a\u049d\3\2\2\2\u009c")
        buf.write("\u04b3\3\2\2\2\u009e\u04c9\3\2\2\2\u00a0\u04cf\3\2\2\2")
        buf.write("\u00a2\u04d1\3\2\2\2\u00a4\u04ec\3\2\2\2\u00a6\u04ef\3")
        buf.write("\2\2\2\u00a8\u04f3\3\2\2\2\u00aa\u0500\3\2\2\2\u00ac\u0503")
        buf.write("\3\2\2\2\u00ae\u050b\3\2\2\2\u00b0\u00d2\7k\2\2\u00b1")
        buf.write("\u00d2\7l\2\2\u00b2\u00b4\7n\2\2\u00b3\u00b2\3\2\2\2\u00b4")
        buf.write("\u00b5\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2\2\2")
        buf.write("\u00b6\u00d2\3\2\2\2\u00b7\u00b8\7\64\2\2\u00b8\u00b9")
        buf.write("\5.\30\2\u00b9\u00ba\7\65\2\2\u00ba\u00d2\3\2\2\2\u00bb")
        buf.write("\u00d2\5\4\3\2\u00bc\u00be\7b\2\2\u00bd\u00bc\3\2\2\2")
        buf.write("\u00bd\u00be\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c0\7")
        buf.write("\64\2\2\u00c0\u00c1\5\u0092J\2\u00c1\u00c2\7\65\2\2\u00c2")
        buf.write("\u00d2\3\2\2\2\u00c3\u00c4\7c\2\2\u00c4\u00c5\7\64\2\2")
        buf.write("\u00c5\u00c6\5\16\b\2\u00c6\u00c7\7Q\2\2\u00c7\u00c8\5")
        buf.write("z>\2\u00c8\u00c9\7\65\2\2\u00c9\u00d2\3\2\2\2\u00ca\u00cb")
        buf.write("\7d\2\2\u00cb\u00cc\7\64\2\2\u00cc\u00cd\5z>\2\u00cd\u00ce")
        buf.write("\7Q\2\2\u00ce\u00cf\5\16\b\2\u00cf\u00d0\7\65\2\2\u00d0")
        buf.write("\u00d2\3\2\2\2\u00d1\u00b0\3\2\2\2\u00d1\u00b1\3\2\2\2")
        buf.write("\u00d1\u00b3\3\2\2\2\u00d1\u00b7\3\2\2\2\u00d1\u00bb\3")
        buf.write("\2\2\2\u00d1\u00bd\3\2\2\2\u00d1\u00c3\3\2\2\2\u00d1\u00ca")
        buf.write("\3\2\2\2\u00d2\3\3\2\2\2\u00d3\u00d4\7,\2\2\u00d4\u00d5")
        buf.write("\7\64\2\2\u00d5\u00d6\5*\26\2\u00d6\u00d7\7Q\2\2\u00d7")
        buf.write("\u00d8\5\6\4\2\u00d8\u00d9\7\65\2\2\u00d9\5\3\2\2\2\u00da")
        buf.write("\u00db\b\4\1\2\u00db\u00dc\5\b\5\2\u00dc\u00e2\3\2\2\2")
        buf.write("\u00dd\u00de\f\3\2\2\u00de\u00df\7Q\2\2\u00df\u00e1\5")
        buf.write("\b\5\2\u00e0\u00dd\3\2\2\2\u00e1\u00e4\3\2\2\2\u00e2\u00e0")
        buf.write("\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\7\3\2\2\2\u00e4\u00e2")
        buf.write("\3\2\2\2\u00e5\u00e6\5z>\2\u00e6\u00e7\7O\2\2\u00e7\u00e8")
        buf.write("\5*\26\2\u00e8\u00ed\3\2\2\2\u00e9\u00ea\7\13\2\2\u00ea")
        buf.write("\u00eb\7O\2\2\u00eb\u00ed\5*\26\2\u00ec\u00e5\3\2\2\2")
        buf.write("\u00ec\u00e9\3\2\2\2\u00ed\t\3\2\2\2\u00ee\u00ef\b\6\1")
        buf.write("\2\u00ef\u0111\5\2\2\2\u00f0\u00f1\7\64\2\2\u00f1\u00f2")
        buf.write("\5z>\2\u00f2\u00f3\7\65\2\2\u00f3\u00f4\78\2\2\u00f4\u00f5")
        buf.write("\5\u0084C\2\u00f5\u00f6\79\2\2\u00f6\u0111\3\2\2\2\u00f7")
        buf.write("\u00f8\7\64\2\2\u00f8\u00f9\5z>\2\u00f9\u00fa\7\65\2\2")
        buf.write("\u00fa\u00fb\78\2\2\u00fb\u00fc\5\u0084C\2\u00fc\u00fd")
        buf.write("\7Q\2\2\u00fd\u00fe\79\2\2\u00fe\u0111\3\2\2\2\u00ff\u0100")
        buf.write("\7b\2\2\u0100\u0101\7\64\2\2\u0101\u0102\5z>\2\u0102\u0103")
        buf.write("\7\65\2\2\u0103\u0104\78\2\2\u0104\u0105\5\u0084C\2\u0105")
        buf.write("\u0106\79\2\2\u0106\u0111\3\2\2\2\u0107\u0108\7b\2\2\u0108")
        buf.write("\u0109\7\64\2\2\u0109\u010a\5z>\2\u010a\u010b\7\65\2\2")
        buf.write("\u010b\u010c\78\2\2\u010c\u010d\5\u0084C\2\u010d\u010e")
        buf.write("\7Q\2\2\u010e\u010f\79\2\2\u010f\u0111\3\2\2\2\u0110\u00ee")
        buf.write("\3\2\2\2\u0110\u00f0\3\2\2\2\u0110\u00f7\3\2\2\2\u0110")
        buf.write("\u00ff\3\2\2\2\u0110\u0107\3\2\2\2\u0111\u0129\3\2\2\2")
        buf.write("\u0112\u0113\f\f\2\2\u0113\u0114\7\66\2\2\u0114\u0115")
        buf.write("\5.\30\2\u0115\u0116\7\67\2\2\u0116\u0128\3\2\2\2\u0117")
        buf.write("\u0118\f\13\2\2\u0118\u011a\7\64\2\2\u0119\u011b\5\f\7")
        buf.write("\2\u011a\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011c")
        buf.write("\3\2\2\2\u011c\u0128\7\65\2\2\u011d\u011e\f\n\2\2\u011e")
        buf.write("\u011f\7`\2\2\u011f\u0128\7k\2\2\u0120\u0121\f\t\2\2\u0121")
        buf.write("\u0122\7_\2\2\u0122\u0128\7k\2\2\u0123\u0124\f\b\2\2\u0124")
        buf.write("\u0128\7A\2\2\u0125\u0126\f\7\2\2\u0126\u0128\7C\2\2\u0127")
        buf.write("\u0112\3\2\2\2\u0127\u0117\3\2\2\2\u0127\u011d\3\2\2\2")
        buf.write("\u0127\u0120\3\2\2\2\u0127\u0123\3\2\2\2\u0127\u0125\3")
        buf.write("\2\2\2\u0128\u012b\3\2\2\2\u0129\u0127\3\2\2\2\u0129\u012a")
        buf.write("\3\2\2\2\u012a\13\3\2\2\2\u012b\u0129\3\2\2\2\u012c\u012d")
        buf.write("\b\7\1\2\u012d\u012e\5*\26\2\u012e\u0134\3\2\2\2\u012f")
        buf.write("\u0130\f\3\2\2\u0130\u0131\7Q\2\2\u0131\u0133\5*\26\2")
        buf.write("\u0132\u012f\3\2\2\2\u0133\u0136\3\2\2\2\u0134\u0132\3")
        buf.write("\2\2\2\u0134\u0135\3\2\2\2\u0135\r\3\2\2\2\u0136\u0134")
        buf.write("\3\2\2\2\u0137\u014e\5\n\6\2\u0138\u0139\7A\2\2\u0139")
        buf.write("\u014e\5\16\b\2\u013a\u013b\7C\2\2\u013b\u014e\5\16\b")
        buf.write("\2\u013c\u013d\5\20\t\2\u013d\u013e\5\22\n\2\u013e\u014e")
        buf.write("\3\2\2\2\u013f\u0140\7\35\2\2\u0140\u014e\5\16\b\2\u0141")
        buf.write("\u0142\7\35\2\2\u0142\u0143\7\64\2\2\u0143\u0144\5z>\2")
        buf.write("\u0144\u0145\7\65\2\2\u0145\u014e\3\2\2\2\u0146\u0147")
        buf.write("\7(\2\2\u0147\u0148\7\64\2\2\u0148\u0149\5z>\2\u0149\u014a")
        buf.write("\7\65\2\2\u014a\u014e\3\2\2\2\u014b\u014c\7I\2\2\u014c")
        buf.write("\u014e\7k\2\2\u014d\u0137\3\2\2\2\u014d\u0138\3\2\2\2")
        buf.write("\u014d\u013a\3\2\2\2\u014d\u013c\3\2\2\2\u014d\u013f\3")
        buf.write("\2\2\2\u014d\u0141\3\2\2\2\u014d\u0146\3\2\2\2\u014d\u014b")
        buf.write("\3\2\2\2\u014e\17\3\2\2\2\u014f\u0150\t\2\2\2\u0150\21")
        buf.write("\3\2\2\2\u0151\u0152\7\64\2\2\u0152\u0153\5z>\2\u0153")
        buf.write("\u0154\7\65\2\2\u0154\u0155\5\22\n\2\u0155\u015f\3\2\2")
        buf.write("\2\u0156\u0157\7b\2\2\u0157\u0158\7\64\2\2\u0158\u0159")
        buf.write("\5z>\2\u0159\u015a\7\65\2\2\u015a\u015b\5\22\n\2\u015b")
        buf.write("\u015f\3\2\2\2\u015c\u015f\5\16\b\2\u015d\u015f\7m\2\2")
        buf.write("\u015e\u0151\3\2\2\2\u015e\u0156\3\2\2\2\u015e\u015c\3")
        buf.write("\2\2\2\u015e\u015d\3\2\2\2\u015f\23\3\2\2\2\u0160\u0161")
        buf.write("\b\13\1\2\u0161\u0162\5\22\n\2\u0162\u016e\3\2\2\2\u0163")
        buf.write("\u0164\f\5\2\2\u0164\u0165\7D\2\2\u0165\u016d\5\22\n\2")
        buf.write("\u0166\u0167\f\4\2\2\u0167\u0168\7E\2\2\u0168\u016d\5")
        buf.write("\22\n\2\u0169\u016a\f\3\2\2\u016a\u016b\7F\2\2\u016b\u016d")
        buf.write("\5\22\n\2\u016c\u0163\3\2\2\2\u016c\u0166\3\2\2\2\u016c")
        buf.write("\u0169\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3\2\2\2")
        buf.write("\u016e\u016f\3\2\2\2\u016f\25\3\2\2\2\u0170\u016e\3\2")
        buf.write("\2\2\u0171\u0172\b\f\1\2\u0172\u0173\5\24\13\2\u0173\u017c")
        buf.write("\3\2\2\2\u0174\u0175\f\4\2\2\u0175\u0176\7@\2\2\u0176")
        buf.write("\u017b\5\24\13\2\u0177\u0178\f\3\2\2\u0178\u0179\7B\2")
        buf.write("\2\u0179\u017b\5\24\13\2\u017a\u0174\3\2\2\2\u017a\u0177")
        buf.write("\3\2\2\2\u017b\u017e\3\2\2\2\u017c\u017a\3\2\2\2\u017c")
        buf.write("\u017d\3\2\2\2\u017d\27\3\2\2\2\u017e\u017c\3\2\2\2\u017f")
        buf.write("\u0180\b\r\1\2\u0180\u0181\5\26\f\2\u0181\u018a\3\2\2")
        buf.write("\2\u0182\u0183\f\4\2\2\u0183\u0184\7>\2\2\u0184\u0189")
        buf.write("\5\26\f\2\u0185\u0186\f\3\2\2\u0186\u0187\7?\2\2\u0187")
        buf.write("\u0189\5\26\f\2\u0188\u0182\3\2\2\2\u0188\u0185\3\2\2")
        buf.write("\2\u0189\u018c\3\2\2\2\u018a\u0188\3\2\2\2\u018a\u018b")
        buf.write("\3\2\2\2\u018b\31\3\2\2\2\u018c\u018a\3\2\2\2\u018d\u018e")
        buf.write("\b\16\1\2\u018e\u018f\5\30\r\2\u018f\u019e\3\2\2\2\u0190")
        buf.write("\u0191\f\6\2\2\u0191\u0192\7:\2\2\u0192\u019d\5\30\r\2")
        buf.write("\u0193\u0194\f\5\2\2\u0194\u0195\7<\2\2\u0195\u019d\5")
        buf.write("\30\r\2\u0196\u0197\f\4\2\2\u0197\u0198\7;\2\2\u0198\u019d")
        buf.write("\5\30\r\2\u0199\u019a\f\3\2\2\u019a\u019b\7=\2\2\u019b")
        buf.write("\u019d\5\30\r\2\u019c\u0190\3\2\2\2\u019c\u0193\3\2\2")
        buf.write("\2\u019c\u0196\3\2\2\2\u019c\u0199\3\2\2\2\u019d\u01a0")
        buf.write("\3\2\2\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2\2\u019f")
        buf.write("\33\3\2\2\2\u01a0\u019e\3\2\2\2\u01a1\u01a2\b\17\1\2\u01a2")
        buf.write("\u01a3\5\32\16\2\u01a3\u01ac\3\2\2\2\u01a4\u01a5\f\4\2")
        buf.write("\2\u01a5\u01a6\7]\2\2\u01a6\u01ab\5\32\16\2\u01a7\u01a8")
        buf.write("\f\3\2\2\u01a8\u01a9\7^\2\2\u01a9\u01ab\5\32\16\2\u01aa")
        buf.write("\u01a4\3\2\2\2\u01aa\u01a7\3\2\2\2\u01ab\u01ae\3\2\2\2")
        buf.write("\u01ac\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\35\3\2")
        buf.write("\2\2\u01ae\u01ac\3\2\2\2\u01af\u01b0\b\20\1\2\u01b0\u01b1")
        buf.write("\5\34\17\2\u01b1\u01b7\3\2\2\2\u01b2\u01b3\f\3\2\2\u01b3")
        buf.write("\u01b4\7G\2\2\u01b4\u01b6\5\34\17\2\u01b5\u01b2\3\2\2")
        buf.write("\2\u01b6\u01b9\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b7\u01b8")
        buf.write("\3\2\2\2\u01b8\37\3\2\2\2\u01b9\u01b7\3\2\2\2\u01ba\u01bb")
        buf.write("\b\21\1\2\u01bb\u01bc\5\36\20\2\u01bc\u01c2\3\2\2\2\u01bd")
        buf.write("\u01be\f\3\2\2\u01be\u01bf\7K\2\2\u01bf\u01c1\5\36\20")
        buf.write("\2\u01c0\u01bd\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0")
        buf.write("\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3!\3\2\2\2\u01c4\u01c2")
        buf.write("\3\2\2\2\u01c5\u01c6\b\22\1\2\u01c6\u01c7\5 \21\2\u01c7")
        buf.write("\u01cd\3\2\2\2\u01c8\u01c9\f\3\2\2\u01c9\u01ca\7H\2\2")
        buf.write("\u01ca\u01cc\5 \21\2\u01cb\u01c8\3\2\2\2\u01cc\u01cf\3")
        buf.write("\2\2\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce#")
        buf.write("\3\2\2\2\u01cf\u01cd\3\2\2\2\u01d0\u01d1\b\23\1\2\u01d1")
        buf.write("\u01d2\5\"\22\2\u01d2\u01d8\3\2\2\2\u01d3\u01d4\f\3\2")
        buf.write("\2\u01d4\u01d5\7I\2\2\u01d5\u01d7\5\"\22\2\u01d6\u01d3")
        buf.write("\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8")
        buf.write("\u01d9\3\2\2\2\u01d9%\3\2\2\2\u01da\u01d8\3\2\2\2\u01db")
        buf.write("\u01dc\b\24\1\2\u01dc\u01dd\5$\23\2\u01dd\u01e3\3\2\2")
        buf.write("\2\u01de\u01df\f\3\2\2\u01df\u01e0\7J\2\2\u01e0\u01e2")
        buf.write("\5$\23\2\u01e1\u01de\3\2\2\2\u01e2\u01e5\3\2\2\2\u01e3")
        buf.write("\u01e1\3\2\2\2\u01e3\u01e4\3\2\2\2\u01e4\'\3\2\2\2\u01e5")
        buf.write("\u01e3\3\2\2\2\u01e6\u01ec\5&\24\2\u01e7\u01e8\7N\2\2")
        buf.write("\u01e8\u01e9\5.\30\2\u01e9\u01ea\7O\2\2\u01ea\u01eb\5")
        buf.write("(\25\2\u01eb\u01ed\3\2\2\2\u01ec\u01e7\3\2\2\2\u01ec\u01ed")
        buf.write("\3\2\2\2\u01ed)\3\2\2\2\u01ee\u01f5\5(\25\2\u01ef\u01f0")
        buf.write("\5\16\b\2\u01f0\u01f1\5,\27\2\u01f1\u01f2\5*\26\2\u01f2")
        buf.write("\u01f5\3\2\2\2\u01f3\u01f5\7m\2\2\u01f4\u01ee\3\2\2\2")
        buf.write("\u01f4\u01ef\3\2\2\2\u01f4\u01f3\3\2\2\2\u01f5+\3\2\2")
        buf.write("\2\u01f6\u01f7\t\3\2\2\u01f7-\3\2\2\2\u01f8\u01f9\b\30")
        buf.write("\1\2\u01f9\u01fa\5*\26\2\u01fa\u0200\3\2\2\2\u01fb\u01fc")
        buf.write("\f\3\2\2\u01fc\u01fd\7Q\2\2\u01fd\u01ff\5*\26\2\u01fe")
        buf.write("\u01fb\3\2\2\2\u01ff\u0202\3\2\2\2\u0200\u01fe\3\2\2\2")
        buf.write("\u0200\u0201\3\2\2\2\u0201/\3\2\2\2\u0202\u0200\3\2\2")
        buf.write("\2\u0203\u0204\5(\25\2\u0204\61\3\2\2\2\u0205\u0206\5")
        buf.write("\64\33\2\u0206\u0207\5:\36\2\u0207\u0208\7P\2\2\u0208")
        buf.write("\u020e\3\2\2\2\u0209\u020a\5\64\33\2\u020a\u020b\7P\2")
        buf.write("\2\u020b\u020e\3\2\2\2\u020c\u020e\5\u008cG\2\u020d\u0205")
        buf.write("\3\2\2\2\u020d\u0209\3\2\2\2\u020d\u020c\3\2\2\2\u020e")
        buf.write("\63\3\2\2\2\u020f\u0211\58\35\2\u0210\u020f\3\2\2\2\u0211")
        buf.write("\u0212\3\2\2\2\u0212\u0210\3\2\2\2\u0212\u0213\3\2\2\2")
        buf.write("\u0213\65\3\2\2\2\u0214\u0216\58\35\2\u0215\u0214\3\2")
        buf.write("\2\2\u0216\u0217\3\2\2\2\u0217\u0215\3\2\2\2\u0217\u0218")
        buf.write("\3\2\2\2\u0218\67\3\2\2\2\u0219\u021f\5> \2\u021a\u021f")
        buf.write("\5@!\2\u021b\u021f\5Z.\2\u021c\u021f\5\\/\2\u021d\u021f")
        buf.write("\5^\60\2\u021e\u0219\3\2\2\2\u021e\u021a\3\2\2\2\u021e")
        buf.write("\u021b\3\2\2\2\u021e\u021c\3\2\2\2\u021e\u021d\3\2\2\2")
        buf.write("\u021f9\3\2\2\2\u0220\u0221\b\36\1\2\u0221\u0222\5<\37")
        buf.write("\2\u0222\u0228\3\2\2\2\u0223\u0224\f\3\2\2\u0224\u0225")
        buf.write("\7Q\2\2\u0225\u0227\5<\37\2\u0226\u0223\3\2\2\2\u0227")
        buf.write("\u022a\3\2\2\2\u0228\u0226\3\2\2\2\u0228\u0229\3\2\2\2")
        buf.write("\u0229;\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u0231\5`\61")
        buf.write("\2\u022c\u022d\5`\61\2\u022d\u022e\7R\2\2\u022e\u022f")
        buf.write("\5\u0082B\2\u022f\u0231\3\2\2\2\u0230\u022b\3\2\2\2\u0230")
        buf.write("\u022c\3\2\2\2\u0231=\3\2\2\2\u0232\u0233\t\4\2\2\u0233")
        buf.write("?\3\2\2\2\u0234\u0235\b!\1\2\u0235\u0244\t\5\2\2\u0236")
        buf.write("\u0237\7b\2\2\u0237\u0238\7\64\2\2\u0238\u0239\t\6\2\2")
        buf.write("\u0239\u0244\7\65\2\2\u023a\u0244\5X-\2\u023b\u0244\5")
        buf.write("B\"\2\u023c\u0244\5P)\2\u023d\u0244\5\u0080A\2\u023e\u023f")
        buf.write("\7e\2\2\u023f\u0240\7\64\2\2\u0240\u0241\5\60\31\2\u0241")
        buf.write("\u0242\7\65\2\2\u0242\u0244\3\2\2\2\u0243\u0234\3\2\2")
        buf.write("\2\u0243\u0236\3\2\2\2\u0243\u023a\3\2\2\2\u0243\u023b")
        buf.write("\3\2\2\2\u0243\u023c\3\2\2\2\u0243\u023d\3\2\2\2\u0243")
        buf.write("\u023e\3\2\2\2\u0244\u0249\3\2\2\2\u0245\u0246\f\3\2\2")
        buf.write("\u0246\u0248\5n8\2\u0247\u0245\3\2\2\2\u0248\u024b\3\2")
        buf.write("\2\2\u0249\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024aA\3")
        buf.write("\2\2\2\u024b\u0249\3\2\2\2\u024c\u024e\5D#\2\u024d\u024f")
        buf.write("\7k\2\2\u024e\u024d\3\2\2\2\u024e\u024f\3\2\2\2\u024f")
        buf.write("\u0250\3\2\2\2\u0250\u0251\78\2\2\u0251\u0252\5F$\2\u0252")
        buf.write("\u0253\79\2\2\u0253\u0258\3\2\2\2\u0254\u0255\5D#\2\u0255")
        buf.write("\u0256\7k\2\2\u0256\u0258\3\2\2\2\u0257\u024c\3\2\2\2")
        buf.write("\u0257\u0254\3\2\2\2\u0258C\3\2\2\2\u0259\u025a\t\7\2")
        buf.write("\2\u025aE\3\2\2\2\u025b\u025c\b$\1\2\u025c\u025d\5H%\2")
        buf.write("\u025d\u0262\3\2\2\2\u025e\u025f\f\3\2\2\u025f\u0261\5")
        buf.write("H%\2\u0260\u025e\3\2\2\2\u0261\u0264\3\2\2\2\u0262\u0260")
        buf.write("\3\2\2\2\u0262\u0263\3\2\2\2\u0263G\3\2\2\2\u0264\u0262")
        buf.write("\3\2\2\2\u0265\u0267\5J&\2\u0266\u0268\5L\'\2\u0267\u0266")
        buf.write("\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u0269\3\2\2\2\u0269")
        buf.write("\u026a\7P\2\2\u026a\u026d\3\2\2\2\u026b\u026d\5\u008c")
        buf.write("G\2\u026c\u0265\3\2\2\2\u026c\u026b\3\2\2\2\u026dI\3\2")
        buf.write("\2\2\u026e\u0270\5@!\2\u026f\u0271\5J&\2\u0270\u026f\3")
        buf.write("\2\2\2\u0270\u0271\3\2\2\2\u0271\u0277\3\2\2\2\u0272\u0274")
        buf.write("\5Z.\2\u0273\u0275\5J&\2\u0274\u0273\3\2\2\2\u0274\u0275")
        buf.write("\3\2\2\2\u0275\u0277\3\2\2\2\u0276\u026e\3\2\2\2\u0276")
        buf.write("\u0272\3\2\2\2\u0277K\3\2\2\2\u0278\u0279\b\'\1\2\u0279")
        buf.write("\u027a\5N(\2\u027a\u0280\3\2\2\2\u027b\u027c\f\3\2\2\u027c")
        buf.write("\u027d\7Q\2\2\u027d\u027f\5N(\2\u027e\u027b\3\2\2\2\u027f")
        buf.write("\u0282\3\2\2\2\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2")
        buf.write("\u0281M\3\2\2\2\u0282\u0280\3\2\2\2\u0283\u028a\5`\61")
        buf.write("\2\u0284\u0286\5`\61\2\u0285\u0284\3\2\2\2\u0285\u0286")
        buf.write("\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\7O\2\2\u0288")
        buf.write("\u028a\5\60\31\2\u0289\u0283\3\2\2\2\u0289\u0285\3\2\2")
        buf.write("\2\u028aO\3\2\2\2\u028b\u028d\7\17\2\2\u028c\u028e\7k")
        buf.write("\2\2\u028d\u028c\3\2\2\2\u028d\u028e\3\2\2\2\u028e\u028f")
        buf.write("\3\2\2\2\u028f\u0290\78\2\2\u0290\u0291\5R*\2\u0291\u0292")
        buf.write("\79\2\2\u0292\u029f\3\2\2\2\u0293\u0295\7\17\2\2\u0294")
        buf.write("\u0296\7k\2\2\u0295\u0294\3\2\2\2\u0295\u0296\3\2\2\2")
        buf.write("\u0296\u0297\3\2\2\2\u0297\u0298\78\2\2\u0298\u0299\5")
        buf.write("R*\2\u0299\u029a\7Q\2\2\u029a\u029b\79\2\2\u029b\u029f")
        buf.write("\3\2\2\2\u029c\u029d\7\17\2\2\u029d\u029f\7k\2\2\u029e")
        buf.write("\u028b\3\2\2\2\u029e\u0293\3\2\2\2\u029e\u029c\3\2\2\2")
        buf.write("\u029fQ\3\2\2\2\u02a0\u02a1\b*\1\2\u02a1\u02a2\5T+\2\u02a2")
        buf.write("\u02a8\3\2\2\2\u02a3\u02a4\f\3\2\2\u02a4\u02a5\7Q\2\2")
        buf.write("\u02a5\u02a7\5T+\2\u02a6\u02a3\3\2\2\2\u02a7\u02aa\3\2")
        buf.write("\2\2\u02a8\u02a6\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9S\3")
        buf.write("\2\2\2\u02aa\u02a8\3\2\2\2\u02ab\u02b1\5V,\2\u02ac\u02ad")
        buf.write("\5V,\2\u02ad\u02ae\7R\2\2\u02ae\u02af\5\60\31\2\u02af")
        buf.write("\u02b1\3\2\2\2\u02b0\u02ab\3\2\2\2\u02b0\u02ac\3\2\2\2")
        buf.write("\u02b1U\3\2\2\2\u02b2\u02b3\7k\2\2\u02b3W\3\2\2\2\u02b4")
        buf.write("\u02b5\7)\2\2\u02b5\u02b6\7\64\2\2\u02b6\u02b7\5z>\2\u02b7")
        buf.write("\u02b8\7\65\2\2\u02b8Y\3\2\2\2\u02b9\u02ba\t\b\2\2\u02ba")
        buf.write("[\3\2\2\2\u02bb\u02c2\t\t\2\2\u02bc\u02c2\5f\64\2\u02bd")
        buf.write("\u02be\7h\2\2\u02be\u02bf\7\64\2\2\u02bf\u02c0\7k\2\2")
        buf.write("\u02c0\u02c2\7\65\2\2\u02c1\u02bb\3\2\2\2\u02c1\u02bc")
        buf.write("\3\2\2\2\u02c1\u02bd\3\2\2\2\u02c2]\3\2\2\2\u02c3\u02c4")
        buf.write("\7\'\2\2\u02c4\u02c5\7\64\2\2\u02c5\u02c6\5z>\2\u02c6")
        buf.write("\u02c7\7\65\2\2\u02c7\u02ce\3\2\2\2\u02c8\u02c9\7\'\2")
        buf.write("\2\u02c9\u02ca\7\64\2\2\u02ca\u02cb\5\60\31\2\u02cb\u02cc")
        buf.write("\7\65\2\2\u02cc\u02ce\3\2\2\2\u02cd\u02c3\3\2\2\2\u02cd")
        buf.write("\u02c8\3\2\2\2\u02ce_\3\2\2\2\u02cf\u02d1\5n8\2\u02d0")
        buf.write("\u02cf\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\3\2\2\2")
        buf.write("\u02d2\u02d6\5b\62\2\u02d3\u02d5\5d\63\2\u02d4\u02d3\3")
        buf.write("\2\2\2\u02d5\u02d8\3\2\2\2\u02d6\u02d4\3\2\2\2\u02d6\u02d7")
        buf.write("\3\2\2\2\u02d7a\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d9\u02da")
        buf.write("\b\62\1\2\u02da\u02eb\7k\2\2\u02db\u02dc\7\64\2\2\u02dc")
        buf.write("\u02dd\5`\61\2\u02dd\u02de\7\65\2\2\u02de\u02eb\3\2\2")
        buf.write("\2\u02df\u02e0\7k\2\2\u02e0\u02e1\7O\2\2\u02e1\u02eb\7")
        buf.write("m\2\2\u02e2\u02e4\7\64\2\2\u02e3\u02e5\5@!\2\u02e4\u02e3")
        buf.write("\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6")
        buf.write("\u02e7\5n8\2\u02e7\u02e8\5b\62\2\u02e8\u02e9\7\65\2\2")
        buf.write("\u02e9\u02eb\3\2\2\2\u02ea\u02d9\3\2\2\2\u02ea\u02db\3")
        buf.write("\2\2\2\u02ea\u02df\3\2\2\2\u02ea\u02e2\3\2\2\2\u02eb\u0319")
        buf.write("\3\2\2\2\u02ec\u02ed\f\n\2\2\u02ed\u02ef\7\66\2\2\u02ee")
        buf.write("\u02f0\5p9\2\u02ef\u02ee\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0")
        buf.write("\u02f2\3\2\2\2\u02f1\u02f3\5*\26\2\u02f2\u02f1\3\2\2\2")
        buf.write("\u02f2\u02f3\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4\u0318\7")
        buf.write("\67\2\2\u02f5\u02f6\f\t\2\2\u02f6\u02f7\7\66\2\2\u02f7")
        buf.write("\u02f9\7\36\2\2\u02f8\u02fa\5p9\2\u02f9\u02f8\3\2\2\2")
        buf.write("\u02f9\u02fa\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb\u02fc\5")
        buf.write("*\26\2\u02fc\u02fd\7\67\2\2\u02fd\u0318\3\2\2\2\u02fe")
        buf.write("\u02ff\f\b\2\2\u02ff\u0300\7\66\2\2\u0300\u0301\5p9\2")
        buf.write("\u0301\u0302\7\36\2\2\u0302\u0303\5*\26\2\u0303\u0304")
        buf.write("\7\67\2\2\u0304\u0318\3\2\2\2\u0305\u0306\f\7\2\2\u0306")
        buf.write("\u0308\7\66\2\2\u0307\u0309\5p9\2\u0308\u0307\3\2\2\2")
        buf.write("\u0308\u0309\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030b\7")
        buf.write("D\2\2\u030b\u0318\7\67\2\2\u030c\u030d\f\6\2\2\u030d\u030e")
        buf.write("\7\64\2\2\u030e\u030f\5r:\2\u030f\u0310\7\65\2\2\u0310")
        buf.write("\u0318\3\2\2\2\u0311\u0312\f\5\2\2\u0312\u0314\7\64\2")
        buf.write("\2\u0313\u0315\5x=\2\u0314\u0313\3\2\2\2\u0314\u0315\3")
        buf.write("\2\2\2\u0315\u0316\3\2\2\2\u0316\u0318\7\65\2\2\u0317")
        buf.write("\u02ec\3\2\2\2\u0317\u02f5\3\2\2\2\u0317\u02fe\3\2\2\2")
        buf.write("\u0317\u0305\3\2\2\2\u0317\u030c\3\2\2\2\u0317\u0311\3")
        buf.write("\2\2\2\u0318\u031b\3\2\2\2\u0319\u0317\3\2\2\2\u0319\u031a")
        buf.write("\3\2\2\2\u031ac\3\2\2\2\u031b\u0319\3\2\2\2\u031c\u031d")
        buf.write("\7\3\2\2\u031d\u031f\7\64\2\2\u031e\u0320\7n\2\2\u031f")
        buf.write("\u031e\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u031f\3\2\2\2")
        buf.write("\u0321\u0322\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0326\7")
        buf.write("\65\2\2\u0324\u0326\5f\64\2\u0325\u031c\3\2\2\2\u0325")
        buf.write("\u0324\3\2\2\2\u0326e\3\2\2\2\u0327\u0328\7i\2\2\u0328")
        buf.write("\u0329\7\64\2\2\u0329\u032a\7\64\2\2\u032a\u032b\5h\65")
        buf.write("\2\u032b\u032c\7\65\2\2\u032c\u032d\7\65\2\2\u032dg\3")
        buf.write("\2\2\2\u032e\u0333\5j\66\2\u032f\u0330\7Q\2\2\u0330\u0332")
        buf.write("\5j\66\2\u0331\u032f\3\2\2\2\u0332\u0335\3\2\2\2\u0333")
        buf.write("\u0331\3\2\2\2\u0333\u0334\3\2\2\2\u0334\u0338\3\2\2\2")
        buf.write("\u0335\u0333\3\2\2\2\u0336\u0338\3\2\2\2\u0337\u032e\3")
        buf.write("\2\2\2\u0337\u0336\3\2\2\2\u0338i\3\2\2\2\u0339\u033f")
        buf.write("\n\n\2\2\u033a\u033c\7\64\2\2\u033b\u033d\5\f\7\2\u033c")
        buf.write("\u033b\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033e\3\2\2\2")
        buf.write("\u033e\u0340\7\65\2\2\u033f\u033a\3\2\2\2\u033f\u0340")
        buf.write("\3\2\2\2\u0340\u0343\3\2\2\2\u0341\u0343\3\2\2\2\u0342")
        buf.write("\u0339\3\2\2\2\u0342\u0341\3\2\2\2\u0343k\3\2\2\2\u0344")
        buf.write("\u034a\n\13\2\2\u0345\u0346\7\64\2\2\u0346\u0347\5l\67")
        buf.write("\2\u0347\u0348\7\65\2\2\u0348\u034a\3\2\2\2\u0349\u0344")
        buf.write("\3\2\2\2\u0349\u0345\3\2\2\2\u034a\u034d\3\2\2\2\u034b")
        buf.write("\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034cm\3\2\2\2\u034d")
        buf.write("\u034b\3\2\2\2\u034e\u0350\7D\2\2\u034f\u0351\5p9\2\u0350")
        buf.write("\u034f\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0361\3\2\2\2")
        buf.write("\u0352\u0354\7D\2\2\u0353\u0355\5p9\2\u0354\u0353\3\2")
        buf.write("\2\2\u0354\u0355\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0361")
        buf.write("\5n8\2\u0357\u0359\7K\2\2\u0358\u035a\5p9\2\u0359\u0358")
        buf.write("\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u0361\3\2\2\2\u035b")
        buf.write("\u035d\7K\2\2\u035c\u035e\5p9\2\u035d\u035c\3\2\2\2\u035d")
        buf.write("\u035e\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0361\5n8\2\u0360")
        buf.write("\u034e\3\2\2\2\u0360\u0352\3\2\2\2\u0360\u0357\3\2\2\2")
        buf.write("\u0360\u035b\3\2\2\2\u0361o\3\2\2\2\u0362\u0363\b9\1\2")
        buf.write("\u0363\u0364\5Z.\2\u0364\u0369\3\2\2\2\u0365\u0366\f\3")
        buf.write("\2\2\u0366\u0368\5Z.\2\u0367\u0365\3\2\2\2\u0368\u036b")
        buf.write("\3\2\2\2\u0369\u0367\3\2\2\2\u0369\u036a\3\2\2\2\u036a")
        buf.write("q\3\2\2\2\u036b\u0369\3\2\2\2\u036c\u0372\5t;\2\u036d")
        buf.write("\u036e\5t;\2\u036e\u036f\7Q\2\2\u036f\u0370\7a\2\2\u0370")
        buf.write("\u0372\3\2\2\2\u0371\u036c\3\2\2\2\u0371\u036d\3\2\2\2")
        buf.write("\u0372s\3\2\2\2\u0373\u0374\b;\1\2\u0374\u0375\5v<\2\u0375")
        buf.write("\u037b\3\2\2\2\u0376\u0377\f\3\2\2\u0377\u0378\7Q\2\2")
        buf.write("\u0378\u037a\5v<\2\u0379\u0376\3\2\2\2\u037a\u037d\3\2")
        buf.write("\2\2\u037b\u0379\3\2\2\2\u037b\u037c\3\2\2\2\u037cu\3")
        buf.write("\2\2\2\u037d\u037b\3\2\2\2\u037e\u037f\5\64\33\2\u037f")
        buf.write("\u0380\5`\61\2\u0380\u0386\3\2\2\2\u0381\u0383\5\66\34")
        buf.write("\2\u0382\u0384\5|?\2\u0383\u0382\3\2\2\2\u0383\u0384\3")
        buf.write("\2\2\2\u0384\u0386\3\2\2\2\u0385\u037e\3\2\2\2\u0385\u0381")
        buf.write("\3\2\2\2\u0386w\3\2\2\2\u0387\u0388\b=\1\2\u0388\u0389")
        buf.write("\7k\2\2\u0389\u038f\3\2\2\2\u038a\u038b\f\3\2\2\u038b")
        buf.write("\u038c\7Q\2\2\u038c\u038e\7k\2\2\u038d\u038a\3\2\2\2\u038e")
        buf.write("\u0391\3\2\2\2\u038f\u038d\3\2\2\2\u038f\u0390\3\2\2\2")
        buf.write("\u0390y\3\2\2\2\u0391\u038f\3\2\2\2\u0392\u0394\5J&\2")
        buf.write("\u0393\u0395\5|?\2\u0394\u0393\3\2\2\2\u0394\u0395\3\2")
        buf.write("\2\2\u0395{\3\2\2\2\u0396\u03a2\5n8\2\u0397\u0399\5n8")
        buf.write("\2\u0398\u0397\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u039a")
        buf.write("\3\2\2\2\u039a\u039e\5~@\2\u039b\u039d\5d\63\2\u039c\u039b")
        buf.write("\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039e")
        buf.write("\u039f\3\2\2\2\u039f\u03a2\3\2\2\2\u03a0\u039e\3\2\2\2")
        buf.write("\u03a1\u0396\3\2\2\2\u03a1\u0398\3\2\2\2\u03a2}\3\2\2")
        buf.write("\2\u03a3\u03a4\b@\1\2\u03a4\u03a5\7\64\2\2\u03a5\u03a6")
        buf.write("\5|?\2\u03a6\u03aa\7\65\2\2\u03a7\u03a9\5d\63\2\u03a8")
        buf.write("\u03a7\3\2\2\2\u03a9\u03ac\3\2\2\2\u03aa\u03a8\3\2\2\2")
        buf.write("\u03aa\u03ab\3\2\2\2\u03ab\u03d2\3\2\2\2\u03ac\u03aa\3")
        buf.write("\2\2\2\u03ad\u03af\7\66\2\2\u03ae\u03b0\5p9\2\u03af\u03ae")
        buf.write("\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0\u03b2\3\2\2\2\u03b1")
        buf.write("\u03b3\5*\26\2\u03b2\u03b1\3\2\2\2\u03b2\u03b3\3\2\2\2")
        buf.write("\u03b3\u03b4\3\2\2\2\u03b4\u03d2\7\67\2\2\u03b5\u03b6")
        buf.write("\7\66\2\2\u03b6\u03b8\7\36\2\2\u03b7\u03b9\5p9\2\u03b8")
        buf.write("\u03b7\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba\3\2\2\2")
        buf.write("\u03ba\u03bb\5*\26\2\u03bb\u03bc\7\67\2\2\u03bc\u03d2")
        buf.write("\3\2\2\2\u03bd\u03be\7\66\2\2\u03be\u03bf\5p9\2\u03bf")
        buf.write("\u03c0\7\36\2\2\u03c0\u03c1\5*\26\2\u03c1\u03c2\7\67\2")
        buf.write("\2\u03c2\u03d2\3\2\2\2\u03c3\u03c4\7\66\2\2\u03c4\u03c5")
        buf.write("\7D\2\2\u03c5\u03d2\7\67\2\2\u03c6\u03c8\7\64\2\2\u03c7")
        buf.write("\u03c9\5r:\2\u03c8\u03c7\3\2\2\2\u03c8\u03c9\3\2\2\2\u03c9")
        buf.write("\u03ca\3\2\2\2\u03ca\u03ce\7\65\2\2\u03cb\u03cd\5d\63")
        buf.write("\2\u03cc\u03cb\3\2\2\2\u03cd\u03d0\3\2\2\2\u03ce\u03cc")
        buf.write("\3\2\2\2\u03ce\u03cf\3\2\2\2\u03cf\u03d2\3\2\2\2\u03d0")
        buf.write("\u03ce\3\2\2\2\u03d1\u03a3\3\2\2\2\u03d1\u03ad\3\2\2\2")
        buf.write("\u03d1\u03b5\3\2\2\2\u03d1\u03bd\3\2\2\2\u03d1\u03c3\3")
        buf.write("\2\2\2\u03d1\u03c6\3\2\2\2\u03d2\u03fe\3\2\2\2\u03d3\u03d4")
        buf.write("\f\7\2\2\u03d4\u03d6\7\66\2\2\u03d5\u03d7\5p9\2\u03d6")
        buf.write("\u03d5\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03d9\3\2\2\2")
        buf.write("\u03d8\u03da\5*\26\2\u03d9\u03d8\3\2\2\2\u03d9\u03da\3")
        buf.write("\2\2\2\u03da\u03db\3\2\2\2\u03db\u03fd\7\67\2\2\u03dc")
        buf.write("\u03dd\f\6\2\2\u03dd\u03de\7\66\2\2\u03de\u03e0\7\36\2")
        buf.write("\2\u03df\u03e1\5p9\2\u03e0\u03df\3\2\2\2\u03e0\u03e1\3")
        buf.write("\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e3\5*\26\2\u03e3\u03e4")
        buf.write("\7\67\2\2\u03e4\u03fd\3\2\2\2\u03e5\u03e6\f\5\2\2\u03e6")
        buf.write("\u03e7\7\66\2\2\u03e7\u03e8\5p9\2\u03e8\u03e9\7\36\2\2")
        buf.write("\u03e9\u03ea\5*\26\2\u03ea\u03eb\7\67\2\2\u03eb\u03fd")
        buf.write("\3\2\2\2\u03ec\u03ed\f\4\2\2\u03ed\u03ee\7\66\2\2\u03ee")
        buf.write("\u03ef\7D\2\2\u03ef\u03fd\7\67\2\2\u03f0\u03f1\f\3\2\2")
        buf.write("\u03f1\u03f3\7\64\2\2\u03f2\u03f4\5r:\2\u03f3\u03f2\3")
        buf.write("\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f9")
        buf.write("\7\65\2\2\u03f6\u03f8\5d\63\2\u03f7\u03f6\3\2\2\2\u03f8")
        buf.write("\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2\2\2")
        buf.write("\u03fa\u03fd\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03d3\3")
        buf.write("\2\2\2\u03fc\u03dc\3\2\2\2\u03fc\u03e5\3\2\2\2\u03fc\u03ec")
        buf.write("\3\2\2\2\u03fc\u03f0\3\2\2\2\u03fd\u0400\3\2\2\2\u03fe")
        buf.write("\u03fc\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\177\3\2\2\2\u0400")
        buf.write("\u03fe\3\2\2\2\u0401\u0402\7k\2\2\u0402\u0081\3\2\2\2")
        buf.write("\u0403\u040e\5*\26\2\u0404\u0405\78\2\2\u0405\u0406\5")
        buf.write("\u0084C\2\u0406\u0407\79\2\2\u0407\u040e\3\2\2\2\u0408")
        buf.write("\u0409\78\2\2\u0409\u040a\5\u0084C\2\u040a\u040b\7Q\2")
        buf.write("\2\u040b\u040c\79\2\2\u040c\u040e\3\2\2\2\u040d\u0403")
        buf.write("\3\2\2\2\u040d\u0404\3\2\2\2\u040d\u0408\3\2\2\2\u040e")
        buf.write("\u0083\3\2\2\2\u040f\u0411\bC\1\2\u0410\u0412\5\u0086")
        buf.write("D\2\u0411\u0410\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0413")
        buf.write("\3\2\2\2\u0413\u0414\5\u0082B\2\u0414\u041d\3\2\2\2\u0415")
        buf.write("\u0416\f\3\2\2\u0416\u0418\7Q\2\2\u0417\u0419\5\u0086")
        buf.write("D\2\u0418\u0417\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041a")
        buf.write("\3\2\2\2\u041a\u041c\5\u0082B\2\u041b\u0415\3\2\2\2\u041c")
        buf.write("\u041f\3\2\2\2\u041d\u041b\3\2\2\2\u041d\u041e\3\2\2\2")
        buf.write("\u041e\u0085\3\2\2\2\u041f\u041d\3\2\2\2\u0420\u0421\5")
        buf.write("\u0088E\2\u0421\u0422\7R\2\2\u0422\u0087\3\2\2\2\u0423")
        buf.write("\u0424\bE\1\2\u0424\u0425\5\u008aF\2\u0425\u042a\3\2\2")
        buf.write("\2\u0426\u0427\f\3\2\2\u0427\u0429\5\u008aF\2\u0428\u0426")
        buf.write("\3\2\2\2\u0429\u042c\3\2\2\2\u042a\u0428\3\2\2\2\u042a")
        buf.write("\u042b\3\2\2\2\u042b\u0089\3\2\2\2\u042c\u042a\3\2\2\2")
        buf.write("\u042d\u042e\7\66\2\2\u042e\u042f\5\60\31\2\u042f\u0430")
        buf.write("\7\67\2\2\u0430\u0434\3\2\2\2\u0431\u0432\7`\2\2\u0432")
        buf.write("\u0434\7k\2\2\u0433\u042d\3\2\2\2\u0433\u0431\3\2\2\2")
        buf.write("\u0434\u008b\3\2\2\2\u0435\u0436\7/\2\2\u0436\u0437\7")
        buf.write("\64\2\2\u0437\u0438\5\60\31\2\u0438\u043a\7Q\2\2\u0439")
        buf.write("\u043b\7n\2\2\u043a\u0439\3\2\2\2\u043b\u043c\3\2\2\2")
        buf.write("\u043c\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d\u043e\3")
        buf.write("\2\2\2\u043e\u043f\7\65\2\2\u043f\u0440\7P\2\2\u0440\u008d")
        buf.write("\3\2\2\2\u0441\u0467\5\u0090I\2\u0442\u0467\5\u0092J\2")
        buf.write("\u0443\u0467\5\u0098M\2\u0444\u0467\5\u009aN\2\u0445\u0467")
        buf.write("\5\u009cO\2\u0446\u0467\5\u00a4S\2\u0447\u0448\t\f\2\2")
        buf.write("\u0448\u0449\t\r\2\2\u0449\u0452\7\64\2\2\u044a\u044f")
        buf.write("\5&\24\2\u044b\u044c\7Q\2\2\u044c\u044e\5&\24\2\u044d")
        buf.write("\u044b\3\2\2\2\u044e\u0451\3\2\2\2\u044f\u044d\3\2\2\2")
        buf.write("\u044f\u0450\3\2\2\2\u0450\u0453\3\2\2\2\u0451\u044f\3")
        buf.write("\2\2\2\u0452\u044a\3\2\2\2\u0452\u0453\3\2\2\2\u0453\u0461")
        buf.write("\3\2\2\2\u0454\u045d\7O\2\2\u0455\u045a\5&\24\2\u0456")
        buf.write("\u0457\7Q\2\2\u0457\u0459\5&\24\2\u0458\u0456\3\2\2\2")
        buf.write("\u0459\u045c\3\2\2\2\u045a\u0458\3\2\2\2\u045a\u045b\3")
        buf.write("\2\2\2\u045b\u045e\3\2\2\2\u045c\u045a\3\2\2\2\u045d\u0455")
        buf.write("\3\2\2\2\u045d\u045e\3\2\2\2\u045e\u0460\3\2\2\2\u045f")
        buf.write("\u0454\3\2\2\2\u0460\u0463\3\2\2\2\u0461\u045f\3\2\2\2")
        buf.write("\u0461\u0462\3\2\2\2\u0462\u0464\3\2\2\2\u0463\u0461\3")
        buf.write("\2\2\2\u0464\u0465\7\65\2\2\u0465\u0467\7P\2\2\u0466\u0441")
        buf.write("\3\2\2\2\u0466\u0442\3\2\2\2\u0466\u0443\3\2\2\2\u0466")
        buf.write("\u0444\3\2\2\2\u0466\u0445\3\2\2\2\u0466\u0446\3\2\2\2")
        buf.write("\u0466\u0447\3\2\2\2\u0467\u008f\3\2\2\2\u0468\u0469\7")
        buf.write("k\2\2\u0469\u046a\7O\2\2\u046a\u0474\5\u008eH\2\u046b")
        buf.write("\u046c\7\7\2\2\u046c\u046d\5\60\31\2\u046d\u046e\7O\2")
        buf.write("\2\u046e\u046f\5\u008eH\2\u046f\u0474\3\2\2\2\u0470\u0471")
        buf.write("\7\13\2\2\u0471\u0472\7O\2\2\u0472\u0474\5\u008eH\2\u0473")
        buf.write("\u0468\3\2\2\2\u0473\u046b\3\2\2\2\u0473\u0470\3\2\2\2")
        buf.write("\u0474\u0091\3\2\2\2\u0475\u0477\78\2\2\u0476\u0478\5")
        buf.write("\u0094K\2\u0477\u0476\3\2\2\2\u0477\u0478\3\2\2\2\u0478")
        buf.write("\u0479\3\2\2\2\u0479\u047a\79\2\2\u047a\u0093\3\2\2\2")
        buf.write("\u047b\u047c\bK\1\2\u047c\u047d\5\u0096L\2\u047d\u0482")
        buf.write("\3\2\2\2\u047e\u047f\f\3\2\2\u047f\u0481\5\u0096L\2\u0480")
        buf.write("\u047e\3\2\2\2\u0481\u0484\3\2\2\2\u0482\u0480\3\2\2\2")
        buf.write("\u0482\u0483\3\2\2\2\u0483\u0095\3\2\2\2\u0484\u0482\3")
        buf.write("\2\2\2\u0485\u0488\5\u008eH\2\u0486\u0488\5\62\32\2\u0487")
        buf.write("\u0485\3\2\2\2\u0487\u0486\3\2\2\2\u0488\u0097\3\2\2\2")
        buf.write("\u0489\u048b\5.\30\2\u048a\u0489\3\2\2\2\u048a\u048b\3")
        buf.write("\2\2\2\u048b\u048c\3\2\2\2\u048c\u048d\7P\2\2\u048d\u0099")
        buf.write("\3\2\2\2\u048e\u048f\7\24\2\2\u048f\u0490\7\64\2\2\u0490")
        buf.write("\u0491\5.\30\2\u0491\u0492\7\65\2\2\u0492\u0495\5\u008e")
        buf.write("H\2\u0493\u0494\7\16\2\2\u0494\u0496\5\u008eH\2\u0495")
        buf.write("\u0493\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u049e\3\2\2\2")
        buf.write("\u0497\u0498\7 \2\2\u0498\u0499\7\64\2\2\u0499\u049a\5")
        buf.write(".\30\2\u049a\u049b\7\65\2\2\u049b\u049c\5\u008eH\2\u049c")
        buf.write("\u049e\3\2\2\2\u049d\u048e\3\2\2\2\u049d\u0497\3\2\2\2")
        buf.write("\u049e\u009b\3\2\2\2\u049f\u04a0\7&\2\2\u04a0\u04a1\7")
        buf.write("\64\2\2\u04a1\u04a2\5.\30\2\u04a2\u04a3\7\65\2\2\u04a3")
        buf.write("\u04a4\5\u008eH\2\u04a4\u04b4\3\2\2\2\u04a5\u04a6\7\f")
        buf.write("\2\2\u04a6\u04a7\5\u008eH\2\u04a7\u04a8\7&\2\2\u04a8\u04a9")
        buf.write("\7\64\2\2\u04a9\u04aa\5.\30\2\u04aa\u04ab\7\65\2\2\u04ab")
        buf.write("\u04ac\7P\2\2\u04ac\u04b4\3\2\2\2\u04ad\u04ae\7\22\2\2")
        buf.write("\u04ae\u04af\7\64\2\2\u04af\u04b0\5\u009eP\2\u04b0\u04b1")
        buf.write("\7\65\2\2\u04b1\u04b2\5\u008eH\2\u04b2\u04b4\3\2\2\2\u04b3")
        buf.write("\u049f\3\2\2\2\u04b3\u04a5\3\2\2\2\u04b3\u04ad\3\2\2\2")
        buf.write("\u04b4\u009d\3\2\2\2\u04b5\u04b6\5\u00a0Q\2\u04b6\u04b8")
        buf.write("\7P\2\2\u04b7\u04b9\5\u00a2R\2\u04b8\u04b7\3\2\2\2\u04b8")
        buf.write("\u04b9\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bc\7P\2\2")
        buf.write("\u04bb\u04bd\5\u00a2R\2\u04bc\u04bb\3\2\2\2\u04bc\u04bd")
        buf.write("\3\2\2\2\u04bd\u04ca\3\2\2\2\u04be\u04c0\5.\30\2\u04bf")
        buf.write("\u04be\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c1\3\2\2\2")
        buf.write("\u04c1\u04c3\7P\2\2\u04c2\u04c4\5\u00a2R\2\u04c3\u04c2")
        buf.write("\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5")
        buf.write("\u04c7\7P\2\2\u04c6\u04c8\5\u00a2R\2\u04c7\u04c6\3\2\2")
        buf.write("\2\u04c7\u04c8\3\2\2\2\u04c8\u04ca\3\2\2\2\u04c9\u04b5")
        buf.write("\3\2\2\2\u04c9\u04bf\3\2\2\2\u04ca\u009f\3\2\2\2\u04cb")
        buf.write("\u04cc\5\64\33\2\u04cc\u04cd\5:\36\2\u04cd\u04d0\3\2\2")
        buf.write("\2\u04ce\u04d0\5\64\33\2\u04cf\u04cb\3\2\2\2\u04cf\u04ce")
        buf.write("\3\2\2\2\u04d0\u00a1\3\2\2\2\u04d1\u04d2\bR\1\2\u04d2")
        buf.write("\u04d3\5*\26\2\u04d3\u04d9\3\2\2\2\u04d4\u04d5\f\3\2\2")
        buf.write("\u04d5\u04d6\7Q\2\2\u04d6\u04d8\5*\26\2\u04d7\u04d4\3")
        buf.write("\2\2\2\u04d8\u04db\3\2\2\2\u04d9\u04d7\3\2\2\2\u04d9\u04da")
        buf.write("\3\2\2\2\u04da\u00a3\3\2\2\2\u04db\u04d9\3\2\2\2\u04dc")
        buf.write("\u04dd\7\23\2\2\u04dd\u04de\7k\2\2\u04de\u04ed\7P\2\2")
        buf.write("\u04df\u04e0\7\n\2\2\u04e0\u04ed\7P\2\2\u04e1\u04e2\7")
        buf.write("\6\2\2\u04e2\u04ed\7P\2\2\u04e3\u04e5\7\32\2\2\u04e4\u04e6")
        buf.write("\5.\30\2\u04e5\u04e4\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6")
        buf.write("\u04e7\3\2\2\2\u04e7\u04ed\7P\2\2\u04e8\u04e9\7\23\2\2")
        buf.write("\u04e9\u04ea\5\16\b\2\u04ea\u04eb\7P\2\2\u04eb\u04ed\3")
        buf.write("\2\2\2\u04ec\u04dc\3\2\2\2\u04ec\u04df\3\2\2\2\u04ec\u04e1")
        buf.write("\3\2\2\2\u04ec\u04e3\3\2\2\2\u04ec\u04e8\3\2\2\2\u04ed")
        buf.write("\u00a5\3\2\2\2\u04ee\u04f0\5\u00a8U\2\u04ef\u04ee\3\2")
        buf.write("\2\2\u04ef\u04f0\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1\u04f2")
        buf.write("\7\2\2\3\u04f2\u00a7\3\2\2\2\u04f3\u04f4\bU\1\2\u04f4")
        buf.write("\u04f5\5\u00aaV\2\u04f5\u04fa\3\2\2\2\u04f6\u04f7\f\3")
        buf.write("\2\2\u04f7\u04f9\5\u00aaV\2\u04f8\u04f6\3\2\2\2\u04f9")
        buf.write("\u04fc\3\2\2\2\u04fa\u04f8\3\2\2\2\u04fa\u04fb\3\2\2\2")
        buf.write("\u04fb\u00a9\3\2\2\2\u04fc\u04fa\3\2\2\2\u04fd\u0501\5")
        buf.write("\u00acW\2\u04fe\u0501\5\62\32\2\u04ff\u0501\7P\2\2\u0500")
        buf.write("\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2")
        buf.write("\u0501\u00ab\3\2\2\2\u0502\u0504\5\64\33\2\u0503\u0502")
        buf.write("\3\2\2\2\u0503\u0504\3\2\2\2\u0504\u0505\3\2\2\2\u0505")
        buf.write("\u0507\5`\61\2\u0506\u0508\5\u00aeX\2\u0507\u0506\3\2")
        buf.write("\2\2\u0507\u0508\3\2\2\2\u0508\u0509\3\2\2\2\u0509\u050a")
        buf.write("\5\u0092J\2\u050a\u00ad\3\2\2\2\u050b\u050c\bX\1\2\u050c")
        buf.write("\u050d\5\62\32\2\u050d\u0512\3\2\2\2\u050e\u050f\f\3\2")
        buf.write("\2\u050f\u0511\5\62\32\2\u0510\u050e\3\2\2\2\u0511\u0514")
        buf.write("\3\2\2\2\u0512\u0510\3\2\2\2\u0512\u0513\3\2\2\2\u0513")
        buf.write("\u00af\3\2\2\2\u0514\u0512\3\2\2\2\u0090\u00b5\u00bd\u00d1")
        buf.write("\u00e2\u00ec\u0110\u011a\u0127\u0129\u0134\u014d\u015e")
        buf.write("\u016c\u016e\u017a\u017c\u0188\u018a\u019c\u019e\u01aa")
        buf.write("\u01ac\u01b7\u01c2\u01cd\u01d8\u01e3\u01ec\u01f4\u0200")
        buf.write("\u020d\u0212\u0217\u021e\u0228\u0230\u0243\u0249\u024e")
        buf.write("\u0257\u0262\u0267\u026c\u0270\u0274\u0276\u0280\u0285")
        buf.write("\u0289\u028d\u0295\u029e\u02a8\u02b0\u02c1\u02cd\u02d0")
        buf.write("\u02d6\u02e4\u02ea\u02ef\u02f2\u02f9\u0308\u0314\u0317")
        buf.write("\u0319\u0321\u0325\u0333\u0337\u033c\u033f\u0342\u0349")
        buf.write("\u034b\u0350\u0354\u0359\u035d\u0360\u0369\u0371\u037b")
        buf.write("\u0383\u0385\u038f\u0394\u0398\u039e\u03a1\u03aa\u03af")
        buf.write("\u03b2\u03b8\u03c8\u03ce\u03d1\u03d6\u03d9\u03e0\u03f3")
        buf.write("\u03f9\u03fc\u03fe\u040d\u0411\u0418\u041d\u042a\u0433")
        buf.write("\u043c\u044f\u0452\u045a\u045d\u0461\u0466\u0473\u0477")
        buf.write("\u0482\u0487\u048a\u0495\u049d\u04b3\u04b8\u04bc\u04bf")
        buf.write("\u04c3\u04c7\u04c9\u04cf\u04d9\u04e5\u04ec\u04ef\u04fa")
        buf.write("\u0500\u0503\u0507\u0512")
        return buf.getvalue()


class CParser ( Parser ):

    grammarFileName = "C.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'__asm'", "'__asm__'", "'auto'", "'break'", 
                     "'case'", "'char'", "'const'", "'continue'", "'default'", 
                     "'do'", "'double'", "'else'", "'enum'", "'extern'", 
                     "'float'", "'for'", "'goto'", "'if'", "'inline'", "'int'", 
                     "'long'", "'register'", "'restrict'", "'return'", "'short'", 
                     "'signed'", "'sizeof'", "'static'", "'struct'", "'switch'", 
                     "'typedef'", "'union'", "'unsigned'", "'void'", "'volatile'", 
                     "'while'", "'_Alignas'", "'_Alignof'", "'_Atomic'", 
                     "'_Bool'", "'_Complex'", "'_Generic'", "'_Imaginary'", 
                     "'_Noreturn'", "'_Static_assert'", "'_Thread_local'", 
                     "'__m128'", "'__m128d'", "'__m128i'", "'('", "')'", 
                     "'['", "']'", "'{'", "'}'", "'<'", "'<='", "'>'", "'>='", 
                     "'<<'", "'>>'", "'+'", "'++'", "'-'", "'--'", "'*'", 
                     "'/'", "'%'", "'&'", "'|'", "'&&'", "'||'", "'^'", 
                     "'!'", "'~'", "'?'", "':'", "';'", "','", "'='", "'*='", 
                     "'/='", "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", 
                     "'^='", "'|='", "'=='", "'!='", "'->'", "'.'", "'...'", 
                     "'__extension__'", "'__builtin_va_arg'", "'__builtin_offsetof'", 
                     "'__typeof__'", "'__inline__'", "'__stdcall'", "'__declspec'", 
                     "'__attribute__'", "'__volatile__'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "AUTO", "BREAK", 
                      "CASE", "CHAR", "CONST", "CONTINUE", "DEFAULT", "DO", 
                      "DOUBLE", "ELSE", "ENUM", "EXTERN", "FLOAT", "FOR", 
                      "GOTO", "IF", "INLINE", "INT", "LONG", "REGISTER", 
                      "RESTRICT", "RETURN", "SHORT", "SIGNED", "SIZEOF", 
                      "STATIC", "STRUCT", "SWITCH", "TYPEDEF", "UNION", 
                      "UNSIGNED", "VOID", "VOLATILE", "WHILE", "ALIGNAS", 
                      "ALIGNOF", "ATOMIC", "BOOL", "COMPLEX", "GENERIC", 
                      "IMAGINARY", "NORETURN", "STATICASSERT", "THREADLOCAL", 
                      "M128", "M128D", "M128I", "LEFTPAREN", "RIGHTPAREN", 
                      "LEFTBRACKET", "RIGHTBRACKET", "LEFTBRACE", "RIGHTBRACE", 
                      "LESS", "LESSEQUAL", "GREATER", "GREATEREQUAL", "LEFTSHIFT", 
                      "RIGHTSHIFT", "PLUS", "PLUSPLUS", "MINUS", "MINUSMINUS", 
                      "STAR", "DIV", "MOD", "AND", "OR", "ANDAND", "OROR", 
                      "CARET", "NOT", "TILDE", "QUESTION", "COLON", "SEMI", 
                      "COMMA", "ASSIGN", "STARASSIGN", "DIVASSIGN", "MODASSIGN", 
                      "PLUSASSIGN", "MINUSASSIGN", "LEFTSHIFTASSIGN", "RIGHTSHIFTASSIGN", 
                      "ANDASSIGN", "XORASSIGN", "ORASSIGN", "EQUAL", "NOTEQUAL", 
                      "ARROW", "DOT", "ELLIPSIS", "EXTENSION", "BUILTIN_VA_ARG", 
                      "BUILTIN_OFFSETOF", "TYPEOF", "DUNDER_INLINE", "STDCALL", 
                      "DECLSPEC", "ATTRIBUTE", "DUNDER_VOLATILE", "IDENTIFIER", 
                      "CONSTANT", "DIGIT_SEQUENCE", "STRING_LITERAL", "COMPLEX_DEFINE", 
                      "INCLUDE_DIRECTIVE", "ASM_BLOCK", "LINE_AFTER_PREPROCESSING", 
                      "LINE_DIRECTIVE", "PRAGMA_DIRECTIVE", "WHITESPACE", 
                      "NEW_LINE", "BLOCK_COMMENT", "LINE_COMMENT" ]

    RULE_primaryExpression = 0
    RULE_genericSelection = 1
    RULE_genericAssocList = 2
    RULE_genericAssociation = 3
    RULE_postfixExpression = 4
    RULE_argumentExpressionList = 5
    RULE_unaryExpression = 6
    RULE_unaryOperator = 7
    RULE_castExpression = 8
    RULE_multiplicativeExpression = 9
    RULE_additiveExpression = 10
    RULE_shiftExpression = 11
    RULE_relationalExpression = 12
    RULE_equalityExpression = 13
    RULE_andExpression = 14
    RULE_exclusiveOrExpression = 15
    RULE_inclusiveOrExpression = 16
    RULE_logicalAndExpression = 17
    RULE_logicalOrExpression = 18
    RULE_conditionalExpression = 19
    RULE_assignmentExpression = 20
    RULE_assignmentOperator = 21
    RULE_expression = 22
    RULE_constantExpression = 23
    RULE_declaration = 24
    RULE_declarationSpecifiers = 25
    RULE_declarationSpecifiers2 = 26
    RULE_declarationSpecifier = 27
    RULE_initDeclaratorList = 28
    RULE_initDeclarator = 29
    RULE_storageClassSpecifier = 30
    RULE_typeSpecifier = 31
    RULE_structOrUnionSpecifier = 32
    RULE_structOrUnion = 33
    RULE_structDeclarationList = 34
    RULE_structDeclaration = 35
    RULE_specifierQualifierList = 36
    RULE_structDeclaratorList = 37
    RULE_structDeclarator = 38
    RULE_enumSpecifier = 39
    RULE_enumeratorList = 40
    RULE_enumerator = 41
    RULE_enumerationConstant = 42
    RULE_atomicTypeSpecifier = 43
    RULE_typeQualifier = 44
    RULE_functionSpecifier = 45
    RULE_alignmentSpecifier = 46
    RULE_declarator = 47
    RULE_directDeclarator = 48
    RULE_gccDeclaratorExtension = 49
    RULE_gccAttributeSpecifier = 50
    RULE_gccAttributeList = 51
    RULE_gccAttribute = 52
    RULE_nestedParenthesesBlock = 53
    RULE_pointer = 54
    RULE_typeQualifierList = 55
    RULE_parameterTypeList = 56
    RULE_parameterList = 57
    RULE_parameterDeclaration = 58
    RULE_identifierList = 59
    RULE_typeName = 60
    RULE_abstractDeclarator = 61
    RULE_directAbstractDeclarator = 62
    RULE_typedefName = 63
    RULE_initializer = 64
    RULE_initializerList = 65
    RULE_designation = 66
    RULE_designatorList = 67
    RULE_designator = 68
    RULE_staticAssertDeclaration = 69
    RULE_statement = 70
    RULE_labeledStatement = 71
    RULE_compoundStatement = 72
    RULE_blockItemList = 73
    RULE_blockItem = 74
    RULE_expressionStatement = 75
    RULE_selectionStatement = 76
    RULE_iterationStatement = 77
    RULE_forCondition = 78
    RULE_forDeclaration = 79
    RULE_forExpression = 80
    RULE_jumpStatement = 81
    RULE_compilationUnit = 82
    RULE_translationUnit = 83
    RULE_externalDeclaration = 84
    RULE_functionDefinition = 85
    RULE_declarationList = 86

    ruleNames =  [ "primaryExpression", "genericSelection", "genericAssocList", 
                   "genericAssociation", "postfixExpression", "argumentExpressionList", 
                   "unaryExpression", "unaryOperator", "castExpression", 
                   "multiplicativeExpression", "additiveExpression", "shiftExpression", 
                   "relationalExpression", "equalityExpression", "andExpression", 
                   "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression", 
                   "logicalOrExpression", "conditionalExpression", "assignmentExpression", 
                   "assignmentOperator", "expression", "constantExpression", 
                   "declaration", "declarationSpecifiers", "declarationSpecifiers2", 
                   "declarationSpecifier", "initDeclaratorList", "initDeclarator", 
                   "storageClassSpecifier", "typeSpecifier", "structOrUnionSpecifier", 
                   "structOrUnion", "structDeclarationList", "structDeclaration", 
                   "specifierQualifierList", "structDeclaratorList", "structDeclarator", 
                   "enumSpecifier", "enumeratorList", "enumerator", "enumerationConstant", 
                   "atomicTypeSpecifier", "typeQualifier", "functionSpecifier", 
                   "alignmentSpecifier", "declarator", "directDeclarator", 
                   "gccDeclaratorExtension", "gccAttributeSpecifier", "gccAttributeList", 
                   "gccAttribute", "nestedParenthesesBlock", "pointer", 
                   "typeQualifierList", "parameterTypeList", "parameterList", 
                   "parameterDeclaration", "identifierList", "typeName", 
                   "abstractDeclarator", "directAbstractDeclarator", "typedefName", 
                   "initializer", "initializerList", "designation", "designatorList", 
                   "designator", "staticAssertDeclaration", "statement", 
                   "labeledStatement", "compoundStatement", "blockItemList", 
                   "blockItem", "expressionStatement", "selectionStatement", 
                   "iterationStatement", "forCondition", "forDeclaration", 
                   "forExpression", "jumpStatement", "compilationUnit", 
                   "translationUnit", "externalDeclaration", "functionDefinition", 
                   "declarationList" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    AUTO=3
    BREAK=4
    CASE=5
    CHAR=6
    CONST=7
    CONTINUE=8
    DEFAULT=9
    DO=10
    DOUBLE=11
    ELSE=12
    ENUM=13
    EXTERN=14
    FLOAT=15
    FOR=16
    GOTO=17
    IF=18
    INLINE=19
    INT=20
    LONG=21
    REGISTER=22
    RESTRICT=23
    RETURN=24
    SHORT=25
    SIGNED=26
    SIZEOF=27
    STATIC=28
    STRUCT=29
    SWITCH=30
    TYPEDEF=31
    UNION=32
    UNSIGNED=33
    VOID=34
    VOLATILE=35
    WHILE=36
    ALIGNAS=37
    ALIGNOF=38
    ATOMIC=39
    BOOL=40
    COMPLEX=41
    GENERIC=42
    IMAGINARY=43
    NORETURN=44
    STATICASSERT=45
    THREADLOCAL=46
    M128=47
    M128D=48
    M128I=49
    LEFTPAREN=50
    RIGHTPAREN=51
    LEFTBRACKET=52
    RIGHTBRACKET=53
    LEFTBRACE=54
    RIGHTBRACE=55
    LESS=56
    LESSEQUAL=57
    GREATER=58
    GREATEREQUAL=59
    LEFTSHIFT=60
    RIGHTSHIFT=61
    PLUS=62
    PLUSPLUS=63
    MINUS=64
    MINUSMINUS=65
    STAR=66
    DIV=67
    MOD=68
    AND=69
    OR=70
    ANDAND=71
    OROR=72
    CARET=73
    NOT=74
    TILDE=75
    QUESTION=76
    COLON=77
    SEMI=78
    COMMA=79
    ASSIGN=80
    STARASSIGN=81
    DIVASSIGN=82
    MODASSIGN=83
    PLUSASSIGN=84
    MINUSASSIGN=85
    LEFTSHIFTASSIGN=86
    RIGHTSHIFTASSIGN=87
    ANDASSIGN=88
    XORASSIGN=89
    ORASSIGN=90
    EQUAL=91
    NOTEQUAL=92
    ARROW=93
    DOT=94
    ELLIPSIS=95
    EXTENSION=96
    BUILTIN_VA_ARG=97
    BUILTIN_OFFSETOF=98
    TYPEOF=99
    DUNDER_INLINE=100
    STDCALL=101
    DECLSPEC=102
    ATTRIBUTE=103
    DUNDER_VOLATILE=104
    IDENTIFIER=105
    CONSTANT=106
    DIGIT_SEQUENCE=107
    STRING_LITERAL=108
    COMPLEX_DEFINE=109
    INCLUDE_DIRECTIVE=110
    ASM_BLOCK=111
    LINE_AFTER_PREPROCESSING=112
    LINE_DIRECTIVE=113
    PRAGMA_DIRECTIVE=114
    WHITESPACE=115
    NEW_LINE=116
    BLOCK_COMMENT=117
    LINE_COMMENT=118

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




    class PrimaryExpressionContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def CONSTANT(self):
            return self.getToken(CParser.CONSTANT, 0)

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

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

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


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def genericSelection(self):
            return self.getTypedRuleContext(CParser.GenericSelectionContext,0)


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


        def EXTENSION(self):
            return self.getToken(CParser.EXTENSION, 0)

        def BUILTIN_VA_ARG(self):
            return self.getToken(CParser.BUILTIN_VA_ARG, 0)

        def unaryExpression(self):
            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def BUILTIN_OFFSETOF(self):
            return self.getToken(CParser.BUILTIN_OFFSETOF, 0)

        def getRuleIndex(self):
            return CParser.RULE_primaryExpression

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

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

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




    def primaryExpression(self):

        localctx = CParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_primaryExpression)
        self._la = 0 # Token type
        try:
            self.state = 207
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 174
                self.match(CParser.IDENTIFIER)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 175
                self.match(CParser.CONSTANT)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 177 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 176
                        self.match(CParser.STRING_LITERAL)

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

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 181
                self.match(CParser.LEFTPAREN)
                self.state = 182
                self.expression(0)
                self.state = 183
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 185
                self.genericSelection()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CParser.EXTENSION:
                    self.state = 186
                    self.match(CParser.EXTENSION)


                self.state = 189
                self.match(CParser.LEFTPAREN)
                self.state = 190
                self.compoundStatement()
                self.state = 191
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 193
                self.match(CParser.BUILTIN_VA_ARG)
                self.state = 194
                self.match(CParser.LEFTPAREN)
                self.state = 195
                self.unaryExpression()
                self.state = 196
                self.match(CParser.COMMA)
                self.state = 197
                self.typeName()
                self.state = 198
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 200
                self.match(CParser.BUILTIN_OFFSETOF)
                self.state = 201
                self.match(CParser.LEFTPAREN)
                self.state = 202
                self.typeName()
                self.state = 203
                self.match(CParser.COMMA)
                self.state = 204
                self.unaryExpression()
                self.state = 205
                self.match(CParser.RIGHTPAREN)
                pass


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


    class GenericSelectionContext(ParserRuleContext):

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

        def GENERIC(self):
            return self.getToken(CParser.GENERIC, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def genericAssocList(self):
            return self.getTypedRuleContext(CParser.GenericAssocListContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def getRuleIndex(self):
            return CParser.RULE_genericSelection

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

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

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




    def genericSelection(self):

        localctx = CParser.GenericSelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_genericSelection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self.match(CParser.GENERIC)
            self.state = 210
            self.match(CParser.LEFTPAREN)
            self.state = 211
            self.assignmentExpression()
            self.state = 212
            self.match(CParser.COMMA)
            self.state = 213
            self.genericAssocList(0)
            self.state = 214
            self.match(CParser.RIGHTPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GenericAssocListContext(ParserRuleContext):

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

        def genericAssociation(self):
            return self.getTypedRuleContext(CParser.GenericAssociationContext,0)


        def genericAssocList(self):
            return self.getTypedRuleContext(CParser.GenericAssocListContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_genericAssocList

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

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

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



    def genericAssocList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.GenericAssocListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 4
        self.enterRecursionRule(localctx, 4, self.RULE_genericAssocList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 217
            self.genericAssociation()
            self._ctx.stop = self._input.LT(-1)
            self.state = 224
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,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 = CParser.GenericAssocListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_genericAssocList)
                    self.state = 219
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 220
                    self.match(CParser.COMMA)
                    self.state = 221
                    self.genericAssociation() 
                self.state = 226
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,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 GenericAssociationContext(ParserRuleContext):

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

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def COLON(self):
            return self.getToken(CParser.COLON, 0)

        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def DEFAULT(self):
            return self.getToken(CParser.DEFAULT, 0)

        def getRuleIndex(self):
            return CParser.RULE_genericAssociation

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

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

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




    def genericAssociation(self):

        localctx = CParser.GenericAssociationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_genericAssociation)
        try:
            self.state = 234
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.CHAR, CParser.CONST, CParser.DOUBLE, CParser.ENUM, CParser.FLOAT, CParser.INT, CParser.LONG, CParser.RESTRICT, CParser.SHORT, CParser.SIGNED, CParser.STRUCT, CParser.UNION, CParser.UNSIGNED, CParser.VOID, CParser.VOLATILE, CParser.ATOMIC, CParser.BOOL, CParser.COMPLEX, CParser.M128, CParser.M128D, CParser.M128I, CParser.EXTENSION, CParser.TYPEOF, CParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 227
                self.typeName()
                self.state = 228
                self.match(CParser.COLON)
                self.state = 229
                self.assignmentExpression()
                pass
            elif token in [CParser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 231
                self.match(CParser.DEFAULT)
                self.state = 232
                self.match(CParser.COLON)
                self.state = 233
                self.assignmentExpression()
                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 PostfixExpressionContext(ParserRuleContext):

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

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


        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def LEFTBRACE(self):
            return self.getToken(CParser.LEFTBRACE, 0)

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


        def RIGHTBRACE(self):
            return self.getToken(CParser.RIGHTBRACE, 0)

        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def EXTENSION(self):
            return self.getToken(CParser.EXTENSION, 0)

        def postfixExpression(self):
            return self.getTypedRuleContext(CParser.PostfixExpressionContext,0)


        def LEFTBRACKET(self):
            return self.getToken(CParser.LEFTBRACKET, 0)

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


        def RIGHTBRACKET(self):
            return self.getToken(CParser.RIGHTBRACKET, 0)

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


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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def ARROW(self):
            return self.getToken(CParser.ARROW, 0)

        def PLUSPLUS(self):
            return self.getToken(CParser.PLUSPLUS, 0)

        def MINUSMINUS(self):
            return self.getToken(CParser.MINUSMINUS, 0)

        def getRuleIndex(self):
            return CParser.RULE_postfixExpression

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

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

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



    def postfixExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.PostfixExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 8
        self.enterRecursionRule(localctx, 8, self.RULE_postfixExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.state = 237
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.state = 238
                self.match(CParser.LEFTPAREN)
                self.state = 239
                self.typeName()
                self.state = 240
                self.match(CParser.RIGHTPAREN)
                self.state = 241
                self.match(CParser.LEFTBRACE)
                self.state = 242
                self.initializerList(0)
                self.state = 243
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 3:
                self.state = 245
                self.match(CParser.LEFTPAREN)
                self.state = 246
                self.typeName()
                self.state = 247
                self.match(CParser.RIGHTPAREN)
                self.state = 248
                self.match(CParser.LEFTBRACE)
                self.state = 249
                self.initializerList(0)
                self.state = 250
                self.match(CParser.COMMA)
                self.state = 251
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 4:
                self.state = 253
                self.match(CParser.EXTENSION)
                self.state = 254
                self.match(CParser.LEFTPAREN)
                self.state = 255
                self.typeName()
                self.state = 256
                self.match(CParser.RIGHTPAREN)
                self.state = 257
                self.match(CParser.LEFTBRACE)
                self.state = 258
                self.initializerList(0)
                self.state = 259
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 5:
                self.state = 261
                self.match(CParser.EXTENSION)
                self.state = 262
                self.match(CParser.LEFTPAREN)
                self.state = 263
                self.typeName()
                self.state = 264
                self.match(CParser.RIGHTPAREN)
                self.state = 265
                self.match(CParser.LEFTBRACE)
                self.state = 266
                self.initializerList(0)
                self.state = 267
                self.match(CParser.COMMA)
                self.state = 268
                self.match(CParser.RIGHTBRACE)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 295
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,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 = 293
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                    if la_ == 1:
                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 272
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 273
                        self.match(CParser.LEFTBRACKET)
                        self.state = 274
                        self.expression(0)
                        self.state = 275
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 2:
                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 277
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 278
                        self.match(CParser.LEFTPAREN)
                        self.state = 280
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                            self.state = 279
                            self.argumentExpressionList(0)


                        self.state = 282
                        self.match(CParser.RIGHTPAREN)
                        pass

                    elif la_ == 3:
                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 283
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 284
                        self.match(CParser.DOT)
                        self.state = 285
                        self.match(CParser.IDENTIFIER)
                        pass

                    elif la_ == 4:
                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 286
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 287
                        self.match(CParser.ARROW)
                        self.state = 288
                        self.match(CParser.IDENTIFIER)
                        pass

                    elif la_ == 5:
                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 289
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 290
                        self.match(CParser.PLUSPLUS)
                        pass

                    elif la_ == 6:
                        localctx = CParser.PostfixExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                        self.state = 291
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 292
                        self.match(CParser.MINUSMINUS)
                        pass

             
                self.state = 297
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

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


    class ArgumentExpressionListContext(ParserRuleContext):

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

        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


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


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_argumentExpressionList

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

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

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



    def argumentExpressionList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.ArgumentExpressionListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 10
        self.enterRecursionRule(localctx, 10, self.RULE_argumentExpressionList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 299
            self.assignmentExpression()
            self._ctx.stop = self._input.LT(-1)
            self.state = 306
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,9,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 = CParser.ArgumentExpressionListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_argumentExpressionList)
                    self.state = 301
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 302
                    self.match(CParser.COMMA)
                    self.state = 303
                    self.assignmentExpression() 
                self.state = 308
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,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 UnaryExpressionContext(ParserRuleContext):

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

        def postfixExpression(self):
            return self.getTypedRuleContext(CParser.PostfixExpressionContext,0)


        def PLUSPLUS(self):
            return self.getToken(CParser.PLUSPLUS, 0)

        def unaryExpression(self):
            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)


        def MINUSMINUS(self):
            return self.getToken(CParser.MINUSMINUS, 0)

        def unaryOperator(self):
            return self.getTypedRuleContext(CParser.UnaryOperatorContext,0)


        def castExpression(self):
            return self.getTypedRuleContext(CParser.CastExpressionContext,0)


        def SIZEOF(self):
            return self.getToken(CParser.SIZEOF, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def ALIGNOF(self):
            return self.getToken(CParser.ALIGNOF, 0)

        def ANDAND(self):
            return self.getToken(CParser.ANDAND, 0)

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return CParser.RULE_unaryExpression

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

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

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




    def unaryExpression(self):

        localctx = CParser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_unaryExpression)
        try:
            self.state = 331
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 309
                self.postfixExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 310
                self.match(CParser.PLUSPLUS)
                self.state = 311
                self.unaryExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 312
                self.match(CParser.MINUSMINUS)
                self.state = 313
                self.unaryExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 314
                self.unaryOperator()
                self.state = 315
                self.castExpression()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 317
                self.match(CParser.SIZEOF)
                self.state = 318
                self.unaryExpression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 319
                self.match(CParser.SIZEOF)
                self.state = 320
                self.match(CParser.LEFTPAREN)
                self.state = 321
                self.typeName()
                self.state = 322
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 324
                self.match(CParser.ALIGNOF)
                self.state = 325
                self.match(CParser.LEFTPAREN)
                self.state = 326
                self.typeName()
                self.state = 327
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 329
                self.match(CParser.ANDAND)
                self.state = 330
                self.match(CParser.IDENTIFIER)
                pass


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


    class UnaryOperatorContext(ParserRuleContext):

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

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

        def STAR(self):
            return self.getToken(CParser.STAR, 0)

        def PLUS(self):
            return self.getToken(CParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(CParser.MINUS, 0)

        def TILDE(self):
            return self.getToken(CParser.TILDE, 0)

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

        def getRuleIndex(self):
            return CParser.RULE_unaryOperator

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

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

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




    def unaryOperator(self):

        localctx = CParser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 333
            _la = self._input.LA(1)
            if not(((((_la - 62)) & ~0x3f) == 0 and ((1 << (_la - 62)) & ((1 << (CParser.PLUS - 62)) | (1 << (CParser.MINUS - 62)) | (1 << (CParser.STAR - 62)) | (1 << (CParser.AND - 62)) | (1 << (CParser.NOT - 62)) | (1 << (CParser.TILDE - 62)))) != 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 CastExpressionContext(ParserRuleContext):

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

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def castExpression(self):
            return self.getTypedRuleContext(CParser.CastExpressionContext,0)


        def EXTENSION(self):
            return self.getToken(CParser.EXTENSION, 0)

        def unaryExpression(self):
            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)


        def DIGIT_SEQUENCE(self):
            return self.getToken(CParser.DIGIT_SEQUENCE, 0)

        def getRuleIndex(self):
            return CParser.RULE_castExpression

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

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

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




    def castExpression(self):

        localctx = CParser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_castExpression)
        try:
            self.state = 348
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 335
                self.match(CParser.LEFTPAREN)
                self.state = 336
                self.typeName()
                self.state = 337
                self.match(CParser.RIGHTPAREN)
                self.state = 338
                self.castExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 340
                self.match(CParser.EXTENSION)
                self.state = 341
                self.match(CParser.LEFTPAREN)
                self.state = 342
                self.typeName()
                self.state = 343
                self.match(CParser.RIGHTPAREN)
                self.state = 344
                self.castExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 346
                self.unaryExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 347
                self.match(CParser.DIGIT_SEQUENCE)
                pass


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


    class MultiplicativeExpressionContext(ParserRuleContext):

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

        def castExpression(self):
            return self.getTypedRuleContext(CParser.CastExpressionContext,0)


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


        def STAR(self):
            return self.getToken(CParser.STAR, 0)

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

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

        def getRuleIndex(self):
            return CParser.RULE_multiplicativeExpression

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

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

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



    def multiplicativeExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.MultiplicativeExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 18
        self.enterRecursionRule(localctx, 18, self.RULE_multiplicativeExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 351
            self.castExpression()
            self._ctx.stop = self._input.LT(-1)
            self.state = 364
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,13,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 = 362
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                    if la_ == 1:
                        localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
                        self.state = 353
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 354
                        self.match(CParser.STAR)
                        self.state = 355
                        self.castExpression()
                        pass

                    elif la_ == 2:
                        localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
                        self.state = 356
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 357
                        self.match(CParser.DIV)
                        self.state = 358
                        self.castExpression()
                        pass

                    elif la_ == 3:
                        localctx = CParser.MultiplicativeExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_multiplicativeExpression)
                        self.state = 359
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 360
                        self.match(CParser.MOD)
                        self.state = 361
                        self.castExpression()
                        pass

             
                self.state = 366
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)

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


    class AdditiveExpressionContext(ParserRuleContext):

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

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


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


        def PLUS(self):
            return self.getToken(CParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(CParser.MINUS, 0)

        def getRuleIndex(self):
            return CParser.RULE_additiveExpression

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

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

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



    def additiveExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.AdditiveExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 20
        self.enterRecursionRule(localctx, 20, self.RULE_additiveExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 368
            self.multiplicativeExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 378
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,15,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 = 376
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                    if la_ == 1:
                        localctx = CParser.AdditiveExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression)
                        self.state = 370
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 371
                        self.match(CParser.PLUS)
                        self.state = 372
                        self.multiplicativeExpression(0)
                        pass

                    elif la_ == 2:
                        localctx = CParser.AdditiveExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_additiveExpression)
                        self.state = 373
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 374
                        self.match(CParser.MINUS)
                        self.state = 375
                        self.multiplicativeExpression(0)
                        pass

             
                self.state = 380
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,15,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 ShiftExpressionContext(ParserRuleContext):

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

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


        def shiftExpression(self):
            return self.getTypedRuleContext(CParser.ShiftExpressionContext,0)


        def LEFTSHIFT(self):
            return self.getToken(CParser.LEFTSHIFT, 0)

        def RIGHTSHIFT(self):
            return self.getToken(CParser.RIGHTSHIFT, 0)

        def getRuleIndex(self):
            return CParser.RULE_shiftExpression

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

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

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



    def shiftExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.ShiftExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 22
        self.enterRecursionRule(localctx, 22, self.RULE_shiftExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 382
            self.additiveExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 392
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,17,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 = 390
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
                    if la_ == 1:
                        localctx = CParser.ShiftExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftExpression)
                        self.state = 384
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 385
                        self.match(CParser.LEFTSHIFT)
                        self.state = 386
                        self.additiveExpression(0)
                        pass

                    elif la_ == 2:
                        localctx = CParser.ShiftExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_shiftExpression)
                        self.state = 387
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 388
                        self.match(CParser.RIGHTSHIFT)
                        self.state = 389
                        self.additiveExpression(0)
                        pass

             
                self.state = 394
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,17,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 RelationalExpressionContext(ParserRuleContext):

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

        def shiftExpression(self):
            return self.getTypedRuleContext(CParser.ShiftExpressionContext,0)


        def relationalExpression(self):
            return self.getTypedRuleContext(CParser.RelationalExpressionContext,0)


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

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

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

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

        def getRuleIndex(self):
            return CParser.RULE_relationalExpression

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

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

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



    def relationalExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.RelationalExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 24
        self.enterRecursionRule(localctx, 24, self.RULE_relationalExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 396
            self.shiftExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 412
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 410
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                    if la_ == 1:
                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
                        self.state = 398
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 399
                        self.match(CParser.LESS)
                        self.state = 400
                        self.shiftExpression(0)
                        pass

                    elif la_ == 2:
                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
                        self.state = 401
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 402
                        self.match(CParser.GREATER)
                        self.state = 403
                        self.shiftExpression(0)
                        pass

                    elif la_ == 3:
                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
                        self.state = 404
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 405
                        self.match(CParser.LESSEQUAL)
                        self.state = 406
                        self.shiftExpression(0)
                        pass

                    elif la_ == 4:
                        localctx = CParser.RelationalExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_relationalExpression)
                        self.state = 407
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 408
                        self.match(CParser.GREATEREQUAL)
                        self.state = 409
                        self.shiftExpression(0)
                        pass

             
                self.state = 414
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,19,self._ctx)

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


    class EqualityExpressionContext(ParserRuleContext):

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

        def relationalExpression(self):
            return self.getTypedRuleContext(CParser.RelationalExpressionContext,0)


        def equalityExpression(self):
            return self.getTypedRuleContext(CParser.EqualityExpressionContext,0)


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

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

        def getRuleIndex(self):
            return CParser.RULE_equalityExpression

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

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

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



    def equalityExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.EqualityExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 26
        self.enterRecursionRule(localctx, 26, self.RULE_equalityExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 416
            self.relationalExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 426
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 424
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                    if la_ == 1:
                        localctx = CParser.EqualityExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityExpression)
                        self.state = 418
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 419
                        self.match(CParser.EQUAL)
                        self.state = 420
                        self.relationalExpression(0)
                        pass

                    elif la_ == 2:
                        localctx = CParser.EqualityExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_equalityExpression)
                        self.state = 421
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 422
                        self.match(CParser.NOTEQUAL)
                        self.state = 423
                        self.relationalExpression(0)
                        pass

             
                self.state = 428
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)

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


    class AndExpressionContext(ParserRuleContext):

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

        def equalityExpression(self):
            return self.getTypedRuleContext(CParser.EqualityExpressionContext,0)


        def andExpression(self):
            return self.getTypedRuleContext(CParser.AndExpressionContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_andExpression

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

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

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



    def andExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.AndExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 28
        self.enterRecursionRule(localctx, 28, self.RULE_andExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 430
            self.equalityExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 437
            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 = CParser.AndExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_andExpression)
                    self.state = 432
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 433
                    self.match(CParser.AND)
                    self.state = 434
                    self.equalityExpression(0) 
                self.state = 439
                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 ExclusiveOrExpressionContext(ParserRuleContext):

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

        def andExpression(self):
            return self.getTypedRuleContext(CParser.AndExpressionContext,0)


        def exclusiveOrExpression(self):
            return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,0)


        def CARET(self):
            return self.getToken(CParser.CARET, 0)

        def getRuleIndex(self):
            return CParser.RULE_exclusiveOrExpression

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

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

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



    def exclusiveOrExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.ExclusiveOrExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 30
        self.enterRecursionRule(localctx, 30, self.RULE_exclusiveOrExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 441
            self.andExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 448
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,23,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 = CParser.ExclusiveOrExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_exclusiveOrExpression)
                    self.state = 443
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 444
                    self.match(CParser.CARET)
                    self.state = 445
                    self.andExpression(0) 
                self.state = 450
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,23,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 InclusiveOrExpressionContext(ParserRuleContext):

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

        def exclusiveOrExpression(self):
            return self.getTypedRuleContext(CParser.ExclusiveOrExpressionContext,0)


        def inclusiveOrExpression(self):
            return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_inclusiveOrExpression

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

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

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



    def inclusiveOrExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.InclusiveOrExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 32
        self.enterRecursionRule(localctx, 32, self.RULE_inclusiveOrExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 452
            self.exclusiveOrExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 459
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CParser.InclusiveOrExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_inclusiveOrExpression)
                    self.state = 454
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 455
                    self.match(CParser.OR)
                    self.state = 456
                    self.exclusiveOrExpression(0) 
                self.state = 461
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,24,self._ctx)

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


    class LogicalAndExpressionContext(ParserRuleContext):

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

        def inclusiveOrExpression(self):
            return self.getTypedRuleContext(CParser.InclusiveOrExpressionContext,0)


        def logicalAndExpression(self):
            return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,0)


        def ANDAND(self):
            return self.getToken(CParser.ANDAND, 0)

        def getRuleIndex(self):
            return CParser.RULE_logicalAndExpression

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

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

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



    def logicalAndExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.LogicalAndExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 34
        self.enterRecursionRule(localctx, 34, self.RULE_logicalAndExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.inclusiveOrExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 470
            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 = CParser.LogicalAndExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalAndExpression)
                    self.state = 465
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 466
                    self.match(CParser.ANDAND)
                    self.state = 467
                    self.inclusiveOrExpression(0) 
                self.state = 472
                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 LogicalOrExpressionContext(ParserRuleContext):

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

        def logicalAndExpression(self):
            return self.getTypedRuleContext(CParser.LogicalAndExpressionContext,0)


        def logicalOrExpression(self):
            return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,0)


        def OROR(self):
            return self.getToken(CParser.OROR, 0)

        def getRuleIndex(self):
            return CParser.RULE_logicalOrExpression

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

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

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



    def logicalOrExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.LogicalOrExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 36
        self.enterRecursionRule(localctx, 36, self.RULE_logicalOrExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 474
            self.logicalAndExpression(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 481
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = CParser.LogicalOrExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_logicalOrExpression)
                    self.state = 476
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 477
                    self.match(CParser.OROR)
                    self.state = 478
                    self.logicalAndExpression(0) 
                self.state = 483
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,26,self._ctx)

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


    class ConditionalExpressionContext(ParserRuleContext):

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

        def logicalOrExpression(self):
            return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,0)


        def QUESTION(self):
            return self.getToken(CParser.QUESTION, 0)

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


        def COLON(self):
            return self.getToken(CParser.COLON, 0)

        def conditionalExpression(self):
            return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_conditionalExpression

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

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

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




    def conditionalExpression(self):

        localctx = CParser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_conditionalExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 484
            self.logicalOrExpression(0)
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 485
                self.match(CParser.QUESTION)
                self.state = 486
                self.expression(0)
                self.state = 487
                self.match(CParser.COLON)
                self.state = 488
                self.conditionalExpression()


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


    class AssignmentExpressionContext(ParserRuleContext):

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

        def conditionalExpression(self):
            return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0)


        def unaryExpression(self):
            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)


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


        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def DIGIT_SEQUENCE(self):
            return self.getToken(CParser.DIGIT_SEQUENCE, 0)

        def getRuleIndex(self):
            return CParser.RULE_assignmentExpression

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

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

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




    def assignmentExpression(self):

        localctx = CParser.AssignmentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_assignmentExpression)
        try:
            self.state = 498
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 492
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 493
                self.unaryExpression()
                self.state = 494
                self.assignmentOperator()
                self.state = 495
                self.assignmentExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 497
                self.match(CParser.DIGIT_SEQUENCE)
                pass


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

        def STARASSIGN(self):
            return self.getToken(CParser.STARASSIGN, 0)

        def DIVASSIGN(self):
            return self.getToken(CParser.DIVASSIGN, 0)

        def MODASSIGN(self):
            return self.getToken(CParser.MODASSIGN, 0)

        def PLUSASSIGN(self):
            return self.getToken(CParser.PLUSASSIGN, 0)

        def MINUSASSIGN(self):
            return self.getToken(CParser.MINUSASSIGN, 0)

        def LEFTSHIFTASSIGN(self):
            return self.getToken(CParser.LEFTSHIFTASSIGN, 0)

        def RIGHTSHIFTASSIGN(self):
            return self.getToken(CParser.RIGHTSHIFTASSIGN, 0)

        def ANDASSIGN(self):
            return self.getToken(CParser.ANDASSIGN, 0)

        def XORASSIGN(self):
            return self.getToken(CParser.XORASSIGN, 0)

        def ORASSIGN(self):
            return self.getToken(CParser.ORASSIGN, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 500
            _la = self._input.LA(1)
            if not(((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & ((1 << (CParser.ASSIGN - 80)) | (1 << (CParser.STARASSIGN - 80)) | (1 << (CParser.DIVASSIGN - 80)) | (1 << (CParser.MODASSIGN - 80)) | (1 << (CParser.PLUSASSIGN - 80)) | (1 << (CParser.MINUSASSIGN - 80)) | (1 << (CParser.LEFTSHIFTASSIGN - 80)) | (1 << (CParser.RIGHTSHIFTASSIGN - 80)) | (1 << (CParser.ANDASSIGN - 80)) | (1 << (CParser.XORASSIGN - 80)) | (1 << (CParser.ORASSIGN - 80)))) != 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 ExpressionContext(ParserRuleContext):

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

        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


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


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 44
        self.enterRecursionRule(localctx, 44, self.RULE_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 503
            self.assignmentExpression()
            self._ctx.stop = self._input.LT(-1)
            self.state = 510
            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 = CParser.ExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                    self.state = 505
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 506
                    self.match(CParser.COMMA)
                    self.state = 507
                    self.assignmentExpression() 
                self.state = 512
                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 ConstantExpressionContext(ParserRuleContext):

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

        def conditionalExpression(self):
            return self.getTypedRuleContext(CParser.ConditionalExpressionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_constantExpression

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

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

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




    def constantExpression(self):

        localctx = CParser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 513
            self.conditionalExpression()
        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(CParser.DeclarationSpecifiersContext,0)


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


        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

        def staticAssertDeclaration(self):
            return self.getTypedRuleContext(CParser.StaticAssertDeclarationContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_declaration)
        try:
            self.state = 523
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 515
                self.declarationSpecifiers()
                self.state = 516
                self.initDeclaratorList(0)
                self.state = 517
                self.match(CParser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 519
                self.declarationSpecifiers()
                self.state = 520
                self.match(CParser.SEMI)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 522
                self.staticAssertDeclaration()
                pass


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


        def getRuleIndex(self):
            return CParser.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 = CParser.DeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_declarationSpecifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 526 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 525
                    self.declarationSpecifier()

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

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


    class DeclarationSpecifiers2Context(ParserRuleContext):

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

        def declarationSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.DeclarationSpecifierContext)
            else:
                return self.getTypedRuleContext(CParser.DeclarationSpecifierContext,i)


        def getRuleIndex(self):
            return CParser.RULE_declarationSpecifiers2

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

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

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




    def declarationSpecifiers2(self):

        localctx = CParser.DeclarationSpecifiers2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_declarationSpecifiers2)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 530
                    self.declarationSpecifier()

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

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


    class DeclarationSpecifierContext(ParserRuleContext):

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

        def storageClassSpecifier(self):
            return self.getTypedRuleContext(CParser.StorageClassSpecifierContext,0)


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


        def typeQualifier(self):
            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)


        def functionSpecifier(self):
            return self.getTypedRuleContext(CParser.FunctionSpecifierContext,0)


        def alignmentSpecifier(self):
            return self.getTypedRuleContext(CParser.AlignmentSpecifierContext,0)


        def getRuleIndex(self):
            return CParser.RULE_declarationSpecifier

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

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

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




    def declarationSpecifier(self):

        localctx = CParser.DeclarationSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_declarationSpecifier)
        try:
            self.state = 540
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 535
                self.storageClassSpecifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 536
                self.typeSpecifier(0)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 537
                self.typeQualifier()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 538
                self.functionSpecifier()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 539
                self.alignmentSpecifier()
                pass


        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):
            return self.getTypedRuleContext(CParser.InitDeclaratorContext,0)


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


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.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, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.InitDeclaratorListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 56
        self.enterRecursionRule(localctx, 56, self.RULE_initDeclaratorList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            self.initDeclarator()
            self._ctx.stop = self._input.LT(-1)
            self.state = 550
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,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 = CParser.InitDeclaratorListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_initDeclaratorList)
                    self.state = 545
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 546
                    self.match(CParser.COMMA)
                    self.state = 547
                    self.initDeclarator() 
                self.state = 552
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,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 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(CParser.DeclaratorContext,0)


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

        def initializer(self):
            return self.getTypedRuleContext(CParser.InitializerContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_initDeclarator)
        try:
            self.state = 558
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 553
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 554
                self.declarator()
                self.state = 555
                self.match(CParser.ASSIGN)
                self.state = 556
                self.initializer()
                pass


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


    class StorageClassSpecifierContext(ParserRuleContext):

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

        def TYPEDEF(self):
            return self.getToken(CParser.TYPEDEF, 0)

        def EXTERN(self):
            return self.getToken(CParser.EXTERN, 0)

        def STATIC(self):
            return self.getToken(CParser.STATIC, 0)

        def THREADLOCAL(self):
            return self.getToken(CParser.THREADLOCAL, 0)

        def AUTO(self):
            return self.getToken(CParser.AUTO, 0)

        def REGISTER(self):
            return self.getToken(CParser.REGISTER, 0)

        def getRuleIndex(self):
            return CParser.RULE_storageClassSpecifier

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

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

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




    def storageClassSpecifier(self):

        localctx = CParser.StorageClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_storageClassSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.AUTO) | (1 << CParser.EXTERN) | (1 << CParser.REGISTER) | (1 << CParser.STATIC) | (1 << CParser.TYPEDEF) | (1 << CParser.THREADLOCAL))) != 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 TypeSpecifierContext(ParserRuleContext):

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

        def VOID(self):
            return self.getToken(CParser.VOID, 0)

        def CHAR(self):
            return self.getToken(CParser.CHAR, 0)

        def SHORT(self):
            return self.getToken(CParser.SHORT, 0)

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

        def LONG(self):
            return self.getToken(CParser.LONG, 0)

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

        def DOUBLE(self):
            return self.getToken(CParser.DOUBLE, 0)

        def SIGNED(self):
            return self.getToken(CParser.SIGNED, 0)

        def UNSIGNED(self):
            return self.getToken(CParser.UNSIGNED, 0)

        def BOOL(self):
            return self.getToken(CParser.BOOL, 0)

        def COMPLEX(self):
            return self.getToken(CParser.COMPLEX, 0)

        def M128(self):
            return self.getToken(CParser.M128, 0)

        def M128D(self):
            return self.getToken(CParser.M128D, 0)

        def M128I(self):
            return self.getToken(CParser.M128I, 0)

        def EXTENSION(self):
            return self.getToken(CParser.EXTENSION, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def atomicTypeSpecifier(self):
            return self.getTypedRuleContext(CParser.AtomicTypeSpecifierContext,0)


        def structOrUnionSpecifier(self):
            return self.getTypedRuleContext(CParser.StructOrUnionSpecifierContext,0)


        def enumSpecifier(self):
            return self.getTypedRuleContext(CParser.EnumSpecifierContext,0)


        def typedefName(self):
            return self.getTypedRuleContext(CParser.TypedefNameContext,0)


        def TYPEOF(self):
            return self.getToken(CParser.TYPEOF, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


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


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


        def getRuleIndex(self):
            return CParser.RULE_typeSpecifier

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

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

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



    def typeSpecifier(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.TypeSpecifierContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 62
        self.enterRecursionRule(localctx, 62, self.RULE_typeSpecifier, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 577
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.CHAR, CParser.DOUBLE, CParser.FLOAT, CParser.INT, CParser.LONG, CParser.SHORT, CParser.SIGNED, CParser.UNSIGNED, CParser.VOID, CParser.BOOL, CParser.COMPLEX, CParser.M128, CParser.M128D, CParser.M128I]:
                self.state = 563
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CHAR) | (1 << CParser.DOUBLE) | (1 << CParser.FLOAT) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [CParser.EXTENSION]:
                self.state = 564
                self.match(CParser.EXTENSION)
                self.state = 565
                self.match(CParser.LEFTPAREN)
                self.state = 566
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 567
                self.match(CParser.RIGHTPAREN)
                pass
            elif token in [CParser.ATOMIC]:
                self.state = 568
                self.atomicTypeSpecifier()
                pass
            elif token in [CParser.STRUCT, CParser.UNION]:
                self.state = 569
                self.structOrUnionSpecifier()
                pass
            elif token in [CParser.ENUM]:
                self.state = 570
                self.enumSpecifier()
                pass
            elif token in [CParser.IDENTIFIER]:
                self.state = 571
                self.typedefName()
                pass
            elif token in [CParser.TYPEOF]:
                self.state = 572
                self.match(CParser.TYPEOF)
                self.state = 573
                self.match(CParser.LEFTPAREN)
                self.state = 574
                self.constantExpression()
                self.state = 575
                self.match(CParser.RIGHTPAREN)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 583
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,37,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 = CParser.TypeSpecifierContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeSpecifier)
                    self.state = 579
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 580
                    self.pointer() 
                self.state = 585
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,37,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 StructOrUnionSpecifierContext(ParserRuleContext):

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

        def structOrUnion(self):
            return self.getTypedRuleContext(CParser.StructOrUnionContext,0)


        def LEFTBRACE(self):
            return self.getToken(CParser.LEFTBRACE, 0)

        def structDeclarationList(self):
            return self.getTypedRuleContext(CParser.StructDeclarationListContext,0)


        def RIGHTBRACE(self):
            return self.getToken(CParser.RIGHTBRACE, 0)

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return CParser.RULE_structOrUnionSpecifier

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

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

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




    def structOrUnionSpecifier(self):

        localctx = CParser.StructOrUnionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_structOrUnionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 586
                self.structOrUnion()
                self.state = 588
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CParser.IDENTIFIER:
                    self.state = 587
                    self.match(CParser.IDENTIFIER)


                self.state = 590
                self.match(CParser.LEFTBRACE)
                self.state = 591
                self.structDeclarationList(0)
                self.state = 592
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 594
                self.structOrUnion()
                self.state = 595
                self.match(CParser.IDENTIFIER)
                pass


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


    class StructOrUnionContext(ParserRuleContext):

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

        def STRUCT(self):
            return self.getToken(CParser.STRUCT, 0)

        def UNION(self):
            return self.getToken(CParser.UNION, 0)

        def getRuleIndex(self):
            return CParser.RULE_structOrUnion

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

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

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




    def structOrUnion(self):

        localctx = CParser.StructOrUnionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_structOrUnion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 599
            _la = self._input.LA(1)
            if not(_la==CParser.STRUCT or _la==CParser.UNION):
                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 StructDeclarationListContext(ParserRuleContext):

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

        def structDeclaration(self):
            return self.getTypedRuleContext(CParser.StructDeclarationContext,0)


        def structDeclarationList(self):
            return self.getTypedRuleContext(CParser.StructDeclarationListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_structDeclarationList

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

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

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



    def structDeclarationList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.StructDeclarationListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 68
        self.enterRecursionRule(localctx, 68, self.RULE_structDeclarationList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 602
            self.structDeclaration()
            self._ctx.stop = self._input.LT(-1)
            self.state = 608
            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 = CParser.StructDeclarationListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_structDeclarationList)
                    self.state = 604
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 605
                    self.structDeclaration() 
                self.state = 610
                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 StructDeclarationContext(ParserRuleContext):

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

        def specifierQualifierList(self):
            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)


        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

        def structDeclaratorList(self):
            return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0)


        def staticAssertDeclaration(self):
            return self.getTypedRuleContext(CParser.StaticAssertDeclarationContext,0)


        def getRuleIndex(self):
            return CParser.RULE_structDeclaration

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

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

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




    def structDeclaration(self):

        localctx = CParser.StructDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_structDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 618
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.CHAR, CParser.CONST, CParser.DOUBLE, CParser.ENUM, CParser.FLOAT, CParser.INT, CParser.LONG, CParser.RESTRICT, CParser.SHORT, CParser.SIGNED, CParser.STRUCT, CParser.UNION, CParser.UNSIGNED, CParser.VOID, CParser.VOLATILE, CParser.ATOMIC, CParser.BOOL, CParser.COMPLEX, CParser.M128, CParser.M128D, CParser.M128I, CParser.EXTENSION, CParser.TYPEOF, CParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 611
                self.specifierQualifierList()
                self.state = 613
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 50)) & ~0x3f) == 0 and ((1 << (_la - 50)) & ((1 << (CParser.LEFTPAREN - 50)) | (1 << (CParser.STAR - 50)) | (1 << (CParser.CARET - 50)) | (1 << (CParser.COLON - 50)) | (1 << (CParser.IDENTIFIER - 50)))) != 0):
                    self.state = 612
                    self.structDeclaratorList(0)


                self.state = 615
                self.match(CParser.SEMI)
                pass
            elif token in [CParser.STATICASSERT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 617
                self.staticAssertDeclaration()
                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 SpecifierQualifierListContext(ParserRuleContext):

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

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


        def specifierQualifierList(self):
            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)


        def typeQualifier(self):
            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)


        def getRuleIndex(self):
            return CParser.RULE_specifierQualifierList

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

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

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




    def specifierQualifierList(self):

        localctx = CParser.SpecifierQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_specifierQualifierList)
        try:
            self.state = 628
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 620
                self.typeSpecifier(0)
                self.state = 622
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                if la_ == 1:
                    self.state = 621
                    self.specifierQualifierList()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 624
                self.typeQualifier()
                self.state = 626
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
                if la_ == 1:
                    self.state = 625
                    self.specifierQualifierList()


                pass


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


    class StructDeclaratorListContext(ParserRuleContext):

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

        def structDeclarator(self):
            return self.getTypedRuleContext(CParser.StructDeclaratorContext,0)


        def structDeclaratorList(self):
            return self.getTypedRuleContext(CParser.StructDeclaratorListContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_structDeclaratorList

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

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

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



    def structDeclaratorList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.StructDeclaratorListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 74
        self.enterRecursionRule(localctx, 74, self.RULE_structDeclaratorList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self.structDeclarator()
            self._ctx.stop = self._input.LT(-1)
            self.state = 638
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,46,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 = CParser.StructDeclaratorListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_structDeclaratorList)
                    self.state = 633
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 634
                    self.match(CParser.COMMA)
                    self.state = 635
                    self.structDeclarator() 
                self.state = 640
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,46,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 StructDeclaratorContext(ParserRuleContext):

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

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


        def COLON(self):
            return self.getToken(CParser.COLON, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_structDeclarator

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

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

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




    def structDeclarator(self):

        localctx = CParser.StructDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_structDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 647
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 641
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 643
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 50)) & ~0x3f) == 0 and ((1 << (_la - 50)) & ((1 << (CParser.LEFTPAREN - 50)) | (1 << (CParser.STAR - 50)) | (1 << (CParser.CARET - 50)) | (1 << (CParser.IDENTIFIER - 50)))) != 0):
                    self.state = 642
                    self.declarator()


                self.state = 645
                self.match(CParser.COLON)
                self.state = 646
                self.constantExpression()
                pass


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


    class EnumSpecifierContext(ParserRuleContext):

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

        def ENUM(self):
            return self.getToken(CParser.ENUM, 0)

        def LEFTBRACE(self):
            return self.getToken(CParser.LEFTBRACE, 0)

        def enumeratorList(self):
            return self.getTypedRuleContext(CParser.EnumeratorListContext,0)


        def RIGHTBRACE(self):
            return self.getToken(CParser.RIGHTBRACE, 0)

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_enumSpecifier

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

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

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




    def enumSpecifier(self):

        localctx = CParser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 668
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 649
                self.match(CParser.ENUM)
                self.state = 651
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CParser.IDENTIFIER:
                    self.state = 650
                    self.match(CParser.IDENTIFIER)


                self.state = 653
                self.match(CParser.LEFTBRACE)
                self.state = 654
                self.enumeratorList(0)
                self.state = 655
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 657
                self.match(CParser.ENUM)
                self.state = 659
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CParser.IDENTIFIER:
                    self.state = 658
                    self.match(CParser.IDENTIFIER)


                self.state = 661
                self.match(CParser.LEFTBRACE)
                self.state = 662
                self.enumeratorList(0)
                self.state = 663
                self.match(CParser.COMMA)
                self.state = 664
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 666
                self.match(CParser.ENUM)
                self.state = 667
                self.match(CParser.IDENTIFIER)
                pass


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


    class EnumeratorListContext(ParserRuleContext):

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

        def enumerator(self):
            return self.getTypedRuleContext(CParser.EnumeratorContext,0)


        def enumeratorList(self):
            return self.getTypedRuleContext(CParser.EnumeratorListContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_enumeratorList

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

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

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



    def enumeratorList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.EnumeratorListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 80
        self.enterRecursionRule(localctx, 80, self.RULE_enumeratorList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            self.enumerator()
            self._ctx.stop = self._input.LT(-1)
            self.state = 678
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,52,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 = CParser.EnumeratorListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_enumeratorList)
                    self.state = 673
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 674
                    self.match(CParser.COMMA)
                    self.state = 675
                    self.enumerator() 
                self.state = 680
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,52,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 EnumeratorContext(ParserRuleContext):

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

        def enumerationConstant(self):
            return self.getTypedRuleContext(CParser.EnumerationConstantContext,0)


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

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_enumerator

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

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

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




    def enumerator(self):

        localctx = CParser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_enumerator)
        try:
            self.state = 686
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 681
                self.enumerationConstant()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 682
                self.enumerationConstant()
                self.state = 683
                self.match(CParser.ASSIGN)
                self.state = 684
                self.constantExpression()
                pass


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


    class EnumerationConstantContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return CParser.RULE_enumerationConstant

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

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

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




    def enumerationConstant(self):

        localctx = CParser.EnumerationConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_enumerationConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 688
            self.match(CParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtomicTypeSpecifierContext(ParserRuleContext):

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

        def ATOMIC(self):
            return self.getToken(CParser.ATOMIC, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def getRuleIndex(self):
            return CParser.RULE_atomicTypeSpecifier

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

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

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




    def atomicTypeSpecifier(self):

        localctx = CParser.AtomicTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_atomicTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 690
            self.match(CParser.ATOMIC)
            self.state = 691
            self.match(CParser.LEFTPAREN)
            self.state = 692
            self.typeName()
            self.state = 693
            self.match(CParser.RIGHTPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypeQualifierContext(ParserRuleContext):

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

        def CONST(self):
            return self.getToken(CParser.CONST, 0)

        def RESTRICT(self):
            return self.getToken(CParser.RESTRICT, 0)

        def VOLATILE(self):
            return self.getToken(CParser.VOLATILE, 0)

        def ATOMIC(self):
            return self.getToken(CParser.ATOMIC, 0)

        def getRuleIndex(self):
            return CParser.RULE_typeQualifier

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

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

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




    def typeQualifier(self):

        localctx = CParser.TypeQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_typeQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 695
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 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 FunctionSpecifierContext(ParserRuleContext):

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

        def INLINE(self):
            return self.getToken(CParser.INLINE, 0)

        def NORETURN(self):
            return self.getToken(CParser.NORETURN, 0)

        def DUNDER_INLINE(self):
            return self.getToken(CParser.DUNDER_INLINE, 0)

        def STDCALL(self):
            return self.getToken(CParser.STDCALL, 0)

        def gccAttributeSpecifier(self):
            return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0)


        def DECLSPEC(self):
            return self.getToken(CParser.DECLSPEC, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def getRuleIndex(self):
            return CParser.RULE_functionSpecifier

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

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

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




    def functionSpecifier(self):

        localctx = CParser.FunctionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_functionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 703
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.INLINE, CParser.NORETURN, CParser.DUNDER_INLINE, CParser.STDCALL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 697
                _la = self._input.LA(1)
                if not(_la==CParser.INLINE or _la==CParser.NORETURN or _la==CParser.DUNDER_INLINE or _la==CParser.STDCALL):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [CParser.ATTRIBUTE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 698
                self.gccAttributeSpecifier()
                pass
            elif token in [CParser.DECLSPEC]:
                self.enterOuterAlt(localctx, 3)
                self.state = 699
                self.match(CParser.DECLSPEC)
                self.state = 700
                self.match(CParser.LEFTPAREN)
                self.state = 701
                self.match(CParser.IDENTIFIER)
                self.state = 702
                self.match(CParser.RIGHTPAREN)
                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 AlignmentSpecifierContext(ParserRuleContext):

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

        def ALIGNAS(self):
            return self.getToken(CParser.ALIGNAS, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def typeName(self):
            return self.getTypedRuleContext(CParser.TypeNameContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_alignmentSpecifier

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

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

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




    def alignmentSpecifier(self):

        localctx = CParser.AlignmentSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_alignmentSpecifier)
        try:
            self.state = 715
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 705
                self.match(CParser.ALIGNAS)
                self.state = 706
                self.match(CParser.LEFTPAREN)
                self.state = 707
                self.typeName()
                self.state = 708
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 710
                self.match(CParser.ALIGNAS)
                self.state = 711
                self.match(CParser.LEFTPAREN)
                self.state = 712
                self.constantExpression()
                self.state = 713
                self.match(CParser.RIGHTPAREN)
                pass


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


    class DeclaratorContext(ParserRuleContext):

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

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


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


        def gccDeclaratorExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
            else:
                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)


        def getRuleIndex(self):
            return CParser.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 = CParser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 718
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CParser.STAR or _la==CParser.CARET:
                self.state = 717
                self.pointer()


            self.state = 720
            self.directDeclarator(0)
            self.state = 724
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 721
                    self.gccDeclaratorExtension() 
                self.state = 726
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,57,self._ctx)

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


    class 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(CParser.IDENTIFIER, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

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


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def COLON(self):
            return self.getToken(CParser.COLON, 0)

        def DIGIT_SEQUENCE(self):
            return self.getToken(CParser.DIGIT_SEQUENCE, 0)

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


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


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


        def LEFTBRACKET(self):
            return self.getToken(CParser.LEFTBRACKET, 0)

        def RIGHTBRACKET(self):
            return self.getToken(CParser.RIGHTBRACKET, 0)

        def typeQualifierList(self):
            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)


        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def STATIC(self):
            return self.getToken(CParser.STATIC, 0)

        def STAR(self):
            return self.getToken(CParser.STAR, 0)

        def parameterTypeList(self):
            return self.getTypedRuleContext(CParser.ParameterTypeListContext,0)


        def identifierList(self):
            return self.getTypedRuleContext(CParser.IdentifierListContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.DirectDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 96
        self.enterRecursionRule(localctx, 96, self.RULE_directDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
            if la_ == 1:
                self.state = 728
                self.match(CParser.IDENTIFIER)
                pass

            elif la_ == 2:
                self.state = 729
                self.match(CParser.LEFTPAREN)
                self.state = 730
                self.declarator()
                self.state = 731
                self.match(CParser.RIGHTPAREN)
                pass

            elif la_ == 3:
                self.state = 733
                self.match(CParser.IDENTIFIER)
                self.state = 734
                self.match(CParser.COLON)
                self.state = 735
                self.match(CParser.DIGIT_SEQUENCE)
                pass

            elif la_ == 4:
                self.state = 736
                self.match(CParser.LEFTPAREN)
                self.state = 738
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CHAR) | (1 << CParser.DOUBLE) | (1 << CParser.ENUM) | (1 << CParser.FLOAT) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.STRUCT) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (CParser.EXTENSION - 96)) | (1 << (CParser.TYPEOF - 96)) | (1 << (CParser.IDENTIFIER - 96)))) != 0):
                    self.state = 737
                    self.typeSpecifier(0)


                self.state = 740
                self.pointer()
                self.state = 741
                self.directDeclarator(0)
                self.state = 742
                self.match(CParser.RIGHTPAREN)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 791
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,66,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 = 789
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
                    if la_ == 1:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 746
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 747
                        self.match(CParser.LEFTBRACKET)
                        self.state = 749
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                            self.state = 748
                            self.typeQualifierList(0)


                        self.state = 752
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                            self.state = 751
                            self.assignmentExpression()


                        self.state = 754
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 2:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 755
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 756
                        self.match(CParser.LEFTBRACKET)
                        self.state = 757
                        self.match(CParser.STATIC)
                        self.state = 759
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                            self.state = 758
                            self.typeQualifierList(0)


                        self.state = 761
                        self.assignmentExpression()
                        self.state = 762
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 3:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 764
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 765
                        self.match(CParser.LEFTBRACKET)
                        self.state = 766
                        self.typeQualifierList(0)
                        self.state = 767
                        self.match(CParser.STATIC)
                        self.state = 768
                        self.assignmentExpression()
                        self.state = 769
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 4:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 771
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 772
                        self.match(CParser.LEFTBRACKET)
                        self.state = 774
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                            self.state = 773
                            self.typeQualifierList(0)


                        self.state = 776
                        self.match(CParser.STAR)
                        self.state = 777
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 5:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 778
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 779
                        self.match(CParser.LEFTPAREN)
                        self.state = 780
                        self.parameterTypeList()
                        self.state = 781
                        self.match(CParser.RIGHTPAREN)
                        pass

                    elif la_ == 6:
                        localctx = CParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 783
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 784
                        self.match(CParser.LEFTPAREN)
                        self.state = 786
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CParser.IDENTIFIER:
                            self.state = 785
                            self.identifierList(0)


                        self.state = 788
                        self.match(CParser.RIGHTPAREN)
                        pass

             
                self.state = 793
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,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 GccDeclaratorExtensionContext(ParserRuleContext):

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

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

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

        def gccAttributeSpecifier(self):
            return self.getTypedRuleContext(CParser.GccAttributeSpecifierContext,0)


        def getRuleIndex(self):
            return CParser.RULE_gccDeclaratorExtension

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

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

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




    def gccDeclaratorExtension(self):

        localctx = CParser.GccDeclaratorExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_gccDeclaratorExtension)
        self._la = 0 # Token type
        try:
            self.state = 803
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.T__0]:
                self.enterOuterAlt(localctx, 1)
                self.state = 794
                self.match(CParser.T__0)
                self.state = 795
                self.match(CParser.LEFTPAREN)
                self.state = 797 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 796
                    self.match(CParser.STRING_LITERAL)
                    self.state = 799 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==CParser.STRING_LITERAL):
                        break

                self.state = 801
                self.match(CParser.RIGHTPAREN)
                pass
            elif token in [CParser.ATTRIBUTE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 802
                self.gccAttributeSpecifier()
                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 GccAttributeSpecifierContext(ParserRuleContext):

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

        def ATTRIBUTE(self):
            return self.getToken(CParser.ATTRIBUTE, 0)

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

        def gccAttributeList(self):
            return self.getTypedRuleContext(CParser.GccAttributeListContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_gccAttributeSpecifier

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

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

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




    def gccAttributeSpecifier(self):

        localctx = CParser.GccAttributeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_gccAttributeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 805
            self.match(CParser.ATTRIBUTE)
            self.state = 806
            self.match(CParser.LEFTPAREN)
            self.state = 807
            self.match(CParser.LEFTPAREN)
            self.state = 808
            self.gccAttributeList()
            self.state = 809
            self.match(CParser.RIGHTPAREN)
            self.state = 810
            self.match(CParser.RIGHTPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GccAttributeListContext(ParserRuleContext):

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

        def gccAttribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccAttributeContext)
            else:
                return self.getTypedRuleContext(CParser.GccAttributeContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_gccAttributeList

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

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

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




    def gccAttributeList(self):

        localctx = CParser.GccAttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_gccAttributeList)
        self._la = 0 # Token type
        try:
            self.state = 821
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 812
                self.gccAttribute()
                self.state = 817
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CParser.COMMA:
                    self.state = 813
                    self.match(CParser.COMMA)
                    self.state = 814
                    self.gccAttribute()
                    self.state = 819
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

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

                pass


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


    class GccAttributeContext(ParserRuleContext):

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

        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

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

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

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


        def getRuleIndex(self):
            return CParser.RULE_gccAttribute

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

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

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




    def gccAttribute(self):

        localctx = CParser.GccAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_gccAttribute)
        self._la = 0 # Token type
        try:
            self.state = 832
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.T__0, CParser.T__1, CParser.AUTO, CParser.BREAK, CParser.CASE, CParser.CHAR, CParser.CONST, CParser.CONTINUE, CParser.DEFAULT, CParser.DO, CParser.DOUBLE, CParser.ELSE, CParser.ENUM, CParser.EXTERN, CParser.FLOAT, CParser.FOR, CParser.GOTO, CParser.IF, CParser.INLINE, CParser.INT, CParser.LONG, CParser.REGISTER, CParser.RESTRICT, CParser.RETURN, CParser.SHORT, CParser.SIGNED, CParser.SIZEOF, CParser.STATIC, CParser.STRUCT, CParser.SWITCH, CParser.TYPEDEF, CParser.UNION, CParser.UNSIGNED, CParser.VOID, CParser.VOLATILE, CParser.WHILE, CParser.ALIGNAS, CParser.ALIGNOF, CParser.ATOMIC, CParser.BOOL, CParser.COMPLEX, CParser.GENERIC, CParser.IMAGINARY, CParser.NORETURN, CParser.STATICASSERT, CParser.THREADLOCAL, CParser.M128, CParser.M128D, CParser.M128I, CParser.LEFTBRACKET, CParser.RIGHTBRACKET, CParser.LEFTBRACE, CParser.RIGHTBRACE, CParser.LESS, CParser.LESSEQUAL, CParser.GREATER, CParser.GREATEREQUAL, CParser.LEFTSHIFT, CParser.RIGHTSHIFT, CParser.PLUS, CParser.PLUSPLUS, CParser.MINUS, CParser.MINUSMINUS, CParser.STAR, CParser.DIV, CParser.MOD, CParser.AND, CParser.OR, CParser.ANDAND, CParser.OROR, CParser.CARET, CParser.NOT, CParser.TILDE, CParser.QUESTION, CParser.COLON, CParser.SEMI, CParser.ASSIGN, CParser.STARASSIGN, CParser.DIVASSIGN, CParser.MODASSIGN, CParser.PLUSASSIGN, CParser.MINUSASSIGN, CParser.LEFTSHIFTASSIGN, CParser.RIGHTSHIFTASSIGN, CParser.ANDASSIGN, CParser.XORASSIGN, CParser.ORASSIGN, CParser.EQUAL, CParser.NOTEQUAL, CParser.ARROW, CParser.DOT, CParser.ELLIPSIS, CParser.EXTENSION, CParser.BUILTIN_VA_ARG, CParser.BUILTIN_OFFSETOF, CParser.TYPEOF, CParser.DUNDER_INLINE, CParser.STDCALL, CParser.DECLSPEC, CParser.ATTRIBUTE, CParser.DUNDER_VOLATILE, CParser.IDENTIFIER, CParser.CONSTANT, CParser.DIGIT_SEQUENCE, CParser.STRING_LITERAL, CParser.COMPLEX_DEFINE, CParser.INCLUDE_DIRECTIVE, CParser.ASM_BLOCK, CParser.LINE_AFTER_PREPROCESSING, CParser.LINE_DIRECTIVE, CParser.PRAGMA_DIRECTIVE, CParser.WHITESPACE, CParser.NEW_LINE, CParser.BLOCK_COMMENT, CParser.LINE_COMMENT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 823
                _la = self._input.LA(1)
                if _la <= 0 or ((((_la - 50)) & ~0x3f) == 0 and ((1 << (_la - 50)) & ((1 << (CParser.LEFTPAREN - 50)) | (1 << (CParser.RIGHTPAREN - 50)) | (1 << (CParser.COMMA - 50)))) != 0):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 829
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CParser.LEFTPAREN:
                    self.state = 824
                    self.match(CParser.LEFTPAREN)
                    self.state = 826
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                        self.state = 825
                        self.argumentExpressionList(0)


                    self.state = 828
                    self.match(CParser.RIGHTPAREN)


                pass
            elif token in [CParser.RIGHTPAREN, CParser.COMMA]:
                self.enterOuterAlt(localctx, 2)

                pass
            else:
                raise NoViableAltException(self)

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


    class NestedParenthesesBlockContext(ParserRuleContext):

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

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

        def nestedParenthesesBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.NestedParenthesesBlockContext)
            else:
                return self.getTypedRuleContext(CParser.NestedParenthesesBlockContext,i)


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

        def getRuleIndex(self):
            return CParser.RULE_nestedParenthesesBlock

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

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

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




    def nestedParenthesesBlock(self):

        localctx = CParser.NestedParenthesesBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_nestedParenthesesBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 841
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.AUTO) | (1 << CParser.BREAK) | (1 << CParser.CASE) | (1 << CParser.CHAR) | (1 << CParser.CONST) | (1 << CParser.CONTINUE) | (1 << CParser.DEFAULT) | (1 << CParser.DO) | (1 << CParser.DOUBLE) | (1 << CParser.ELSE) | (1 << CParser.ENUM) | (1 << CParser.EXTERN) | (1 << CParser.FLOAT) | (1 << CParser.FOR) | (1 << CParser.GOTO) | (1 << CParser.IF) | (1 << CParser.INLINE) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.REGISTER) | (1 << CParser.RESTRICT) | (1 << CParser.RETURN) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.SIZEOF) | (1 << CParser.STATIC) | (1 << CParser.STRUCT) | (1 << CParser.SWITCH) | (1 << CParser.TYPEDEF) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.VOLATILE) | (1 << CParser.WHILE) | (1 << CParser.ALIGNAS) | (1 << CParser.ALIGNOF) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.GENERIC) | (1 << CParser.IMAGINARY) | (1 << CParser.NORETURN) | (1 << CParser.STATICASSERT) | (1 << CParser.THREADLOCAL) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I) | (1 << CParser.LEFTPAREN) | (1 << CParser.LEFTBRACKET) | (1 << CParser.RIGHTBRACKET) | (1 << CParser.LEFTBRACE) | (1 << CParser.RIGHTBRACE) | (1 << CParser.LESS) | (1 << CParser.LESSEQUAL) | (1 << CParser.GREATER) | (1 << CParser.GREATEREQUAL) | (1 << CParser.LEFTSHIFT) | (1 << CParser.RIGHTSHIFT) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.DIV - 64)) | (1 << (CParser.MOD - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.OR - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.OROR - 64)) | (1 << (CParser.CARET - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.QUESTION - 64)) | (1 << (CParser.COLON - 64)) | (1 << (CParser.SEMI - 64)) | (1 << (CParser.COMMA - 64)) | (1 << (CParser.ASSIGN - 64)) | (1 << (CParser.STARASSIGN - 64)) | (1 << (CParser.DIVASSIGN - 64)) | (1 << (CParser.MODASSIGN - 64)) | (1 << (CParser.PLUSASSIGN - 64)) | (1 << (CParser.MINUSASSIGN - 64)) | (1 << (CParser.LEFTSHIFTASSIGN - 64)) | (1 << (CParser.RIGHTSHIFTASSIGN - 64)) | (1 << (CParser.ANDASSIGN - 64)) | (1 << (CParser.XORASSIGN - 64)) | (1 << (CParser.ORASSIGN - 64)) | (1 << (CParser.EQUAL - 64)) | (1 << (CParser.NOTEQUAL - 64)) | (1 << (CParser.ARROW - 64)) | (1 << (CParser.DOT - 64)) | (1 << (CParser.ELLIPSIS - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.TYPEOF - 64)) | (1 << (CParser.DUNDER_INLINE - 64)) | (1 << (CParser.STDCALL - 64)) | (1 << (CParser.DECLSPEC - 64)) | (1 << (CParser.ATTRIBUTE - 64)) | (1 << (CParser.DUNDER_VOLATILE - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)) | (1 << (CParser.COMPLEX_DEFINE - 64)) | (1 << (CParser.INCLUDE_DIRECTIVE - 64)) | (1 << (CParser.ASM_BLOCK - 64)) | (1 << (CParser.LINE_AFTER_PREPROCESSING - 64)) | (1 << (CParser.LINE_DIRECTIVE - 64)) | (1 << (CParser.PRAGMA_DIRECTIVE - 64)) | (1 << (CParser.WHITESPACE - 64)) | (1 << (CParser.NEW_LINE - 64)) | (1 << (CParser.BLOCK_COMMENT - 64)) | (1 << (CParser.LINE_COMMENT - 64)))) != 0):
                self.state = 839
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CParser.T__0, CParser.T__1, CParser.AUTO, CParser.BREAK, CParser.CASE, CParser.CHAR, CParser.CONST, CParser.CONTINUE, CParser.DEFAULT, CParser.DO, CParser.DOUBLE, CParser.ELSE, CParser.ENUM, CParser.EXTERN, CParser.FLOAT, CParser.FOR, CParser.GOTO, CParser.IF, CParser.INLINE, CParser.INT, CParser.LONG, CParser.REGISTER, CParser.RESTRICT, CParser.RETURN, CParser.SHORT, CParser.SIGNED, CParser.SIZEOF, CParser.STATIC, CParser.STRUCT, CParser.SWITCH, CParser.TYPEDEF, CParser.UNION, CParser.UNSIGNED, CParser.VOID, CParser.VOLATILE, CParser.WHILE, CParser.ALIGNAS, CParser.ALIGNOF, CParser.ATOMIC, CParser.BOOL, CParser.COMPLEX, CParser.GENERIC, CParser.IMAGINARY, CParser.NORETURN, CParser.STATICASSERT, CParser.THREADLOCAL, CParser.M128, CParser.M128D, CParser.M128I, CParser.LEFTBRACKET, CParser.RIGHTBRACKET, CParser.LEFTBRACE, CParser.RIGHTBRACE, CParser.LESS, CParser.LESSEQUAL, CParser.GREATER, CParser.GREATEREQUAL, CParser.LEFTSHIFT, CParser.RIGHTSHIFT, CParser.PLUS, CParser.PLUSPLUS, CParser.MINUS, CParser.MINUSMINUS, CParser.STAR, CParser.DIV, CParser.MOD, CParser.AND, CParser.OR, CParser.ANDAND, CParser.OROR, CParser.CARET, CParser.NOT, CParser.TILDE, CParser.QUESTION, CParser.COLON, CParser.SEMI, CParser.COMMA, CParser.ASSIGN, CParser.STARASSIGN, CParser.DIVASSIGN, CParser.MODASSIGN, CParser.PLUSASSIGN, CParser.MINUSASSIGN, CParser.LEFTSHIFTASSIGN, CParser.RIGHTSHIFTASSIGN, CParser.ANDASSIGN, CParser.XORASSIGN, CParser.ORASSIGN, CParser.EQUAL, CParser.NOTEQUAL, CParser.ARROW, CParser.DOT, CParser.ELLIPSIS, CParser.EXTENSION, CParser.BUILTIN_VA_ARG, CParser.BUILTIN_OFFSETOF, CParser.TYPEOF, CParser.DUNDER_INLINE, CParser.STDCALL, CParser.DECLSPEC, CParser.ATTRIBUTE, CParser.DUNDER_VOLATILE, CParser.IDENTIFIER, CParser.CONSTANT, CParser.DIGIT_SEQUENCE, CParser.STRING_LITERAL, CParser.COMPLEX_DEFINE, CParser.INCLUDE_DIRECTIVE, CParser.ASM_BLOCK, CParser.LINE_AFTER_PREPROCESSING, CParser.LINE_DIRECTIVE, CParser.PRAGMA_DIRECTIVE, CParser.WHITESPACE, CParser.NEW_LINE, CParser.BLOCK_COMMENT, CParser.LINE_COMMENT]:
                    self.state = 834
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==CParser.LEFTPAREN or _la==CParser.RIGHTPAREN:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                elif token in [CParser.LEFTPAREN]:
                    self.state = 835
                    self.match(CParser.LEFTPAREN)
                    self.state = 836
                    self.nestedParenthesesBlock()
                    self.state = 837
                    self.match(CParser.RIGHTPAREN)
                    pass
                else:
                    raise NoViableAltException(self)

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

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

        def STAR(self):
            return self.getToken(CParser.STAR, 0)

        def typeQualifierList(self):
            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)


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


        def CARET(self):
            return self.getToken(CParser.CARET, 0)

        def getRuleIndex(self):
            return CParser.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 = CParser.PointerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_pointer)
        self._la = 0 # Token type
        try:
            self.state = 862
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 844
                self.match(CParser.STAR)
                self.state = 846
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
                if la_ == 1:
                    self.state = 845
                    self.typeQualifierList(0)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 848
                self.match(CParser.STAR)
                self.state = 850
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                    self.state = 849
                    self.typeQualifierList(0)


                self.state = 852
                self.pointer()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 853
                self.match(CParser.CARET)
                self.state = 855
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
                if la_ == 1:
                    self.state = 854
                    self.typeQualifierList(0)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 857
                self.match(CParser.CARET)
                self.state = 859
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                    self.state = 858
                    self.typeQualifierList(0)


                self.state = 861
                self.pointer()
                pass


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


    class TypeQualifierListContext(ParserRuleContext):

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

        def typeQualifier(self):
            return self.getTypedRuleContext(CParser.TypeQualifierContext,0)


        def typeQualifierList(self):
            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_typeQualifierList

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

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

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



    def typeQualifierList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.TypeQualifierListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 110
        self.enterRecursionRule(localctx, 110, self.RULE_typeQualifierList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 865
            self.typeQualifier()
            self._ctx.stop = self._input.LT(-1)
            self.state = 871
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,81,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 = CParser.TypeQualifierListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeQualifierList)
                    self.state = 867
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 868
                    self.typeQualifier() 
                self.state = 873
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,81,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 ParameterTypeListContext(ParserRuleContext):

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

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


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def ELLIPSIS(self):
            return self.getToken(CParser.ELLIPSIS, 0)

        def getRuleIndex(self):
            return CParser.RULE_parameterTypeList

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

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

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




    def parameterTypeList(self):

        localctx = CParser.ParameterTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_parameterTypeList)
        try:
            self.state = 879
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 874
                self.parameterList(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 875
                self.parameterList(0)
                self.state = 876
                self.match(CParser.COMMA)
                self.state = 877
                self.match(CParser.ELLIPSIS)
                pass


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


    class ParameterListContext(ParserRuleContext):

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

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


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


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_parameterList

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

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

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



    def parameterList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.ParameterListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 114
        self.enterRecursionRule(localctx, 114, self.RULE_parameterList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 882
            self.parameterDeclaration()
            self._ctx.stop = self._input.LT(-1)
            self.state = 889
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,83,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 = CParser.ParameterListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_parameterList)
                    self.state = 884
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 885
                    self.match(CParser.COMMA)
                    self.state = 886
                    self.parameterDeclaration() 
                self.state = 891
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,83,self._ctx)

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


    class ParameterDeclarationContext(ParserRuleContext):

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

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


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


        def declarationSpecifiers2(self):
            return self.getTypedRuleContext(CParser.DeclarationSpecifiers2Context,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_parameterDeclaration)
        try:
            self.state = 899
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 892
                self.declarationSpecifiers()
                self.state = 893
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 895
                self.declarationSpecifiers2()
                self.state = 897
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
                if la_ == 1:
                    self.state = 896
                    self.abstractDeclarator()


                pass


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


    class IdentifierListContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def identifierList(self):
            return self.getTypedRuleContext(CParser.IdentifierListContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_identifierList

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

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

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



    def identifierList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.IdentifierListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 118
        self.enterRecursionRule(localctx, 118, self.RULE_identifierList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 902
            self.match(CParser.IDENTIFIER)
            self._ctx.stop = self._input.LT(-1)
            self.state = 909
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,86,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 = CParser.IdentifierListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_identifierList)
                    self.state = 904
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 905
                    self.match(CParser.COMMA)
                    self.state = 906
                    self.match(CParser.IDENTIFIER) 
                self.state = 911
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,86,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 TypeNameContext(ParserRuleContext):

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

        def specifierQualifierList(self):
            return self.getTypedRuleContext(CParser.SpecifierQualifierListContext,0)


        def abstractDeclarator(self):
            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CParser.RULE_typeName

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

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

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




    def typeName(self):

        localctx = CParser.TypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_typeName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 912
            self.specifierQualifierList()
            self.state = 914
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 50)) & ~0x3f) == 0 and ((1 << (_la - 50)) & ((1 << (CParser.LEFTPAREN - 50)) | (1 << (CParser.LEFTBRACKET - 50)) | (1 << (CParser.STAR - 50)) | (1 << (CParser.CARET - 50)))) != 0):
                self.state = 913
                self.abstractDeclarator()


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


    class AbstractDeclaratorContext(ParserRuleContext):

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

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


        def directAbstractDeclarator(self):
            return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0)


        def gccDeclaratorExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
            else:
                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)


        def getRuleIndex(self):
            return CParser.RULE_abstractDeclarator

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

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

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




    def abstractDeclarator(self):

        localctx = CParser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_abstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 927
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 916
                self.pointer()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 918
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CParser.STAR or _la==CParser.CARET:
                    self.state = 917
                    self.pointer()


                self.state = 920
                self.directAbstractDeclarator(0)
                self.state = 924
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,89,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 921
                        self.gccDeclaratorExtension() 
                    self.state = 926
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,89,self._ctx)

                pass


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


    class DirectAbstractDeclaratorContext(ParserRuleContext):

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

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def abstractDeclarator(self):
            return self.getTypedRuleContext(CParser.AbstractDeclaratorContext,0)


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def gccDeclaratorExtension(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.GccDeclaratorExtensionContext)
            else:
                return self.getTypedRuleContext(CParser.GccDeclaratorExtensionContext,i)


        def LEFTBRACKET(self):
            return self.getToken(CParser.LEFTBRACKET, 0)

        def RIGHTBRACKET(self):
            return self.getToken(CParser.RIGHTBRACKET, 0)

        def typeQualifierList(self):
            return self.getTypedRuleContext(CParser.TypeQualifierListContext,0)


        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def STATIC(self):
            return self.getToken(CParser.STATIC, 0)

        def STAR(self):
            return self.getToken(CParser.STAR, 0)

        def parameterTypeList(self):
            return self.getTypedRuleContext(CParser.ParameterTypeListContext,0)


        def directAbstractDeclarator(self):
            return self.getTypedRuleContext(CParser.DirectAbstractDeclaratorContext,0)


        def getRuleIndex(self):
            return CParser.RULE_directAbstractDeclarator

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

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

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



    def directAbstractDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.DirectAbstractDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 124
        self.enterRecursionRule(localctx, 124, self.RULE_directAbstractDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 975
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
            if la_ == 1:
                self.state = 930
                self.match(CParser.LEFTPAREN)
                self.state = 931
                self.abstractDeclarator()
                self.state = 932
                self.match(CParser.RIGHTPAREN)
                self.state = 936
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,91,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 933
                        self.gccDeclaratorExtension() 
                    self.state = 938
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,91,self._ctx)

                pass

            elif la_ == 2:
                self.state = 939
                self.match(CParser.LEFTBRACKET)
                self.state = 941
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                    self.state = 940
                    self.typeQualifierList(0)


                self.state = 944
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 943
                    self.assignmentExpression()


                self.state = 946
                self.match(CParser.RIGHTBRACKET)
                pass

            elif la_ == 3:
                self.state = 947
                self.match(CParser.LEFTBRACKET)
                self.state = 948
                self.match(CParser.STATIC)
                self.state = 950
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                    self.state = 949
                    self.typeQualifierList(0)


                self.state = 952
                self.assignmentExpression()
                self.state = 953
                self.match(CParser.RIGHTBRACKET)
                pass

            elif la_ == 4:
                self.state = 955
                self.match(CParser.LEFTBRACKET)
                self.state = 956
                self.typeQualifierList(0)
                self.state = 957
                self.match(CParser.STATIC)
                self.state = 958
                self.assignmentExpression()
                self.state = 959
                self.match(CParser.RIGHTBRACKET)
                pass

            elif la_ == 5:
                self.state = 961
                self.match(CParser.LEFTBRACKET)
                self.state = 962
                self.match(CParser.STAR)
                self.state = 963
                self.match(CParser.RIGHTBRACKET)
                pass

            elif la_ == 6:
                self.state = 964
                self.match(CParser.LEFTPAREN)
                self.state = 966
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.AUTO) | (1 << CParser.CHAR) | (1 << CParser.CONST) | (1 << CParser.DOUBLE) | (1 << CParser.ENUM) | (1 << CParser.EXTERN) | (1 << CParser.FLOAT) | (1 << CParser.INLINE) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.REGISTER) | (1 << CParser.RESTRICT) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.STATIC) | (1 << CParser.STRUCT) | (1 << CParser.TYPEDEF) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.VOLATILE) | (1 << CParser.ALIGNAS) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.NORETURN) | (1 << CParser.THREADLOCAL) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (CParser.EXTENSION - 96)) | (1 << (CParser.TYPEOF - 96)) | (1 << (CParser.DUNDER_INLINE - 96)) | (1 << (CParser.STDCALL - 96)) | (1 << (CParser.DECLSPEC - 96)) | (1 << (CParser.ATTRIBUTE - 96)) | (1 << (CParser.IDENTIFIER - 96)))) != 0):
                    self.state = 965
                    self.parameterTypeList()


                self.state = 968
                self.match(CParser.RIGHTPAREN)
                self.state = 972
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,96,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 969
                        self.gccDeclaratorExtension() 
                    self.state = 974
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,96,self._ctx)

                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1020
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,104,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 = 1018
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
                    if la_ == 1:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 977
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 978
                        self.match(CParser.LEFTBRACKET)
                        self.state = 980
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                            self.state = 979
                            self.typeQualifierList(0)


                        self.state = 983
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                            self.state = 982
                            self.assignmentExpression()


                        self.state = 985
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 2:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 986
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 987
                        self.match(CParser.LEFTBRACKET)
                        self.state = 988
                        self.match(CParser.STATIC)
                        self.state = 990
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.CONST) | (1 << CParser.RESTRICT) | (1 << CParser.VOLATILE) | (1 << CParser.ATOMIC))) != 0):
                            self.state = 989
                            self.typeQualifierList(0)


                        self.state = 992
                        self.assignmentExpression()
                        self.state = 993
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 3:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 995
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 996
                        self.match(CParser.LEFTBRACKET)
                        self.state = 997
                        self.typeQualifierList(0)
                        self.state = 998
                        self.match(CParser.STATIC)
                        self.state = 999
                        self.assignmentExpression()
                        self.state = 1000
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 4:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1002
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1003
                        self.match(CParser.LEFTBRACKET)
                        self.state = 1004
                        self.match(CParser.STAR)
                        self.state = 1005
                        self.match(CParser.RIGHTBRACKET)
                        pass

                    elif la_ == 5:
                        localctx = CParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1006
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1007
                        self.match(CParser.LEFTPAREN)
                        self.state = 1009
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.AUTO) | (1 << CParser.CHAR) | (1 << CParser.CONST) | (1 << CParser.DOUBLE) | (1 << CParser.ENUM) | (1 << CParser.EXTERN) | (1 << CParser.FLOAT) | (1 << CParser.INLINE) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.REGISTER) | (1 << CParser.RESTRICT) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.STATIC) | (1 << CParser.STRUCT) | (1 << CParser.TYPEDEF) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.VOLATILE) | (1 << CParser.ALIGNAS) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.NORETURN) | (1 << CParser.THREADLOCAL) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (CParser.EXTENSION - 96)) | (1 << (CParser.TYPEOF - 96)) | (1 << (CParser.DUNDER_INLINE - 96)) | (1 << (CParser.STDCALL - 96)) | (1 << (CParser.DECLSPEC - 96)) | (1 << (CParser.ATTRIBUTE - 96)) | (1 << (CParser.IDENTIFIER - 96)))) != 0):
                            self.state = 1008
                            self.parameterTypeList()


                        self.state = 1011
                        self.match(CParser.RIGHTPAREN)
                        self.state = 1015
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,102,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1012
                                self.gccDeclaratorExtension() 
                            self.state = 1017
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,102,self._ctx)

                        pass

             
                self.state = 1022
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,104,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 TypedefNameContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return CParser.RULE_typedefName

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

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

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




    def typedefName(self):

        localctx = CParser.TypedefNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1023
            self.match(CParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerContext(ParserRuleContext):

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

        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def LEFTBRACE(self):
            return self.getToken(CParser.LEFTBRACE, 0)

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


        def RIGHTBRACE(self):
            return self.getToken(CParser.RIGHTBRACE, 0)

        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_initializer

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

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

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




    def initializer(self):

        localctx = CParser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_initializer)
        try:
            self.state = 1035
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1025
                self.assignmentExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1026
                self.match(CParser.LEFTBRACE)
                self.state = 1027
                self.initializerList(0)
                self.state = 1028
                self.match(CParser.RIGHTBRACE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1030
                self.match(CParser.LEFTBRACE)
                self.state = 1031
                self.initializerList(0)
                self.state = 1032
                self.match(CParser.COMMA)
                self.state = 1033
                self.match(CParser.RIGHTBRACE)
                pass


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


    class InitializerListContext(ParserRuleContext):

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

        def initializer(self):
            return self.getTypedRuleContext(CParser.InitializerContext,0)


        def designation(self):
            return self.getTypedRuleContext(CParser.DesignationContext,0)


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


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_initializerList

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

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

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



    def initializerList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.InitializerListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 130
        self.enterRecursionRule(localctx, 130, self.RULE_initializerList, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1039
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CParser.LEFTBRACKET or _la==CParser.DOT:
                self.state = 1038
                self.designation()


            self.state = 1041
            self.initializer()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1051
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,108,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 = CParser.InitializerListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_initializerList)
                    self.state = 1043
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1044
                    self.match(CParser.COMMA)
                    self.state = 1046
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CParser.LEFTBRACKET or _la==CParser.DOT:
                        self.state = 1045
                        self.designation()


                    self.state = 1048
                    self.initializer() 
                self.state = 1053
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,108,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 DesignationContext(ParserRuleContext):

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

        def designatorList(self):
            return self.getTypedRuleContext(CParser.DesignatorListContext,0)


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

        def getRuleIndex(self):
            return CParser.RULE_designation

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

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

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




    def designation(self):

        localctx = CParser.DesignationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_designation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1054
            self.designatorList(0)
            self.state = 1055
            self.match(CParser.ASSIGN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DesignatorListContext(ParserRuleContext):

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

        def designator(self):
            return self.getTypedRuleContext(CParser.DesignatorContext,0)


        def designatorList(self):
            return self.getTypedRuleContext(CParser.DesignatorListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_designatorList

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

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

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



    def designatorList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.DesignatorListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 134
        self.enterRecursionRule(localctx, 134, self.RULE_designatorList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1058
            self.designator()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1064
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,109,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 = CParser.DesignatorListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_designatorList)
                    self.state = 1060
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1061
                    self.designator() 
                self.state = 1066
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,109,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 DesignatorContext(ParserRuleContext):

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

        def LEFTBRACKET(self):
            return self.getToken(CParser.LEFTBRACKET, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


        def RIGHTBRACKET(self):
            return self.getToken(CParser.RIGHTBRACKET, 0)

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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return CParser.RULE_designator

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

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

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




    def designator(self):

        localctx = CParser.DesignatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_designator)
        try:
            self.state = 1073
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.LEFTBRACKET]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1067
                self.match(CParser.LEFTBRACKET)
                self.state = 1068
                self.constantExpression()
                self.state = 1069
                self.match(CParser.RIGHTBRACKET)
                pass
            elif token in [CParser.DOT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1071
                self.match(CParser.DOT)
                self.state = 1072
                self.match(CParser.IDENTIFIER)
                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 StaticAssertDeclarationContext(ParserRuleContext):

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

        def STATICASSERT(self):
            return self.getToken(CParser.STATICASSERT, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

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

        def getRuleIndex(self):
            return CParser.RULE_staticAssertDeclaration

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

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

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




    def staticAssertDeclaration(self):

        localctx = CParser.StaticAssertDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_staticAssertDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1075
            self.match(CParser.STATICASSERT)
            self.state = 1076
            self.match(CParser.LEFTPAREN)
            self.state = 1077
            self.constantExpression()
            self.state = 1078
            self.match(CParser.COMMA)
            self.state = 1080 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1079
                self.match(CParser.STRING_LITERAL)
                self.state = 1082 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CParser.STRING_LITERAL):
                    break

            self.state = 1084
            self.match(CParser.RIGHTPAREN)
            self.state = 1085
            self.match(CParser.SEMI)
        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 labeledStatement(self):
            return self.getTypedRuleContext(CParser.LabeledStatementContext,0)


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


        def expressionStatement(self):
            return self.getTypedRuleContext(CParser.ExpressionStatementContext,0)


        def selectionStatement(self):
            return self.getTypedRuleContext(CParser.SelectionStatementContext,0)


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


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


        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

        def VOLATILE(self):
            return self.getToken(CParser.VOLATILE, 0)

        def DUNDER_VOLATILE(self):
            return self.getToken(CParser.DUNDER_VOLATILE, 0)

        def logicalOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.LogicalOrExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.LogicalOrExpressionContext,i)


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

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

        def getRuleIndex(self):
            return CParser.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 = CParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 1124
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1087
                self.labeledStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1088
                self.compoundStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1089
                self.expressionStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1090
                self.selectionStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1091
                self.iterationStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1092
                self.jumpStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1093
                _la = self._input.LA(1)
                if not(_la==CParser.T__0 or _la==CParser.T__1):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1094
                _la = self._input.LA(1)
                if not(_la==CParser.VOLATILE or _la==CParser.DUNDER_VOLATILE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1095
                self.match(CParser.LEFTPAREN)
                self.state = 1104
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1096
                    self.logicalOrExpression(0)
                    self.state = 1101
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==CParser.COMMA:
                        self.state = 1097
                        self.match(CParser.COMMA)
                        self.state = 1098
                        self.logicalOrExpression(0)
                        self.state = 1103
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1119
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CParser.COLON:
                    self.state = 1106
                    self.match(CParser.COLON)
                    self.state = 1115
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                        self.state = 1107
                        self.logicalOrExpression(0)
                        self.state = 1112
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==CParser.COMMA:
                            self.state = 1108
                            self.match(CParser.COMMA)
                            self.state = 1109
                            self.logicalOrExpression(0)
                            self.state = 1114
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



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

                self.state = 1122
                self.match(CParser.RIGHTPAREN)
                self.state = 1123
                self.match(CParser.SEMI)
                pass


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


    class LabeledStatementContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def COLON(self):
            return self.getToken(CParser.COLON, 0)

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


        def CASE(self):
            return self.getToken(CParser.CASE, 0)

        def constantExpression(self):
            return self.getTypedRuleContext(CParser.ConstantExpressionContext,0)


        def DEFAULT(self):
            return self.getToken(CParser.DEFAULT, 0)

        def getRuleIndex(self):
            return CParser.RULE_labeledStatement

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

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

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




    def labeledStatement(self):

        localctx = CParser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_labeledStatement)
        try:
            self.state = 1137
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1126
                self.match(CParser.IDENTIFIER)
                self.state = 1127
                self.match(CParser.COLON)
                self.state = 1128
                self.statement()
                pass
            elif token in [CParser.CASE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1129
                self.match(CParser.CASE)
                self.state = 1130
                self.constantExpression()
                self.state = 1131
                self.match(CParser.COLON)
                self.state = 1132
                self.statement()
                pass
            elif token in [CParser.DEFAULT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1134
                self.match(CParser.DEFAULT)
                self.state = 1135
                self.match(CParser.COLON)
                self.state = 1136
                self.statement()
                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 CompoundStatementContext(ParserRuleContext):

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

        def LEFTBRACE(self):
            return self.getToken(CParser.LEFTBRACE, 0)

        def RIGHTBRACE(self):
            return self.getToken(CParser.RIGHTBRACE, 0)

        def blockItemList(self):
            return self.getTypedRuleContext(CParser.BlockItemListContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1139
            self.match(CParser.LEFTBRACE)
            self.state = 1141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.AUTO) | (1 << CParser.BREAK) | (1 << CParser.CASE) | (1 << CParser.CHAR) | (1 << CParser.CONST) | (1 << CParser.CONTINUE) | (1 << CParser.DEFAULT) | (1 << CParser.DO) | (1 << CParser.DOUBLE) | (1 << CParser.ENUM) | (1 << CParser.EXTERN) | (1 << CParser.FLOAT) | (1 << CParser.FOR) | (1 << CParser.GOTO) | (1 << CParser.IF) | (1 << CParser.INLINE) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.REGISTER) | (1 << CParser.RESTRICT) | (1 << CParser.RETURN) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.SIZEOF) | (1 << CParser.STATIC) | (1 << CParser.STRUCT) | (1 << CParser.SWITCH) | (1 << CParser.TYPEDEF) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.VOLATILE) | (1 << CParser.WHILE) | (1 << CParser.ALIGNAS) | (1 << CParser.ALIGNOF) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.GENERIC) | (1 << CParser.NORETURN) | (1 << CParser.STATICASSERT) | (1 << CParser.THREADLOCAL) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I) | (1 << CParser.LEFTPAREN) | (1 << CParser.LEFTBRACE) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.SEMI - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.TYPEOF - 64)) | (1 << (CParser.DUNDER_INLINE - 64)) | (1 << (CParser.STDCALL - 64)) | (1 << (CParser.DECLSPEC - 64)) | (1 << (CParser.ATTRIBUTE - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                self.state = 1140
                self.blockItemList(0)


            self.state = 1143
            self.match(CParser.RIGHTBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockItemListContext(ParserRuleContext):

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

        def blockItem(self):
            return self.getTypedRuleContext(CParser.BlockItemContext,0)


        def blockItemList(self):
            return self.getTypedRuleContext(CParser.BlockItemListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_blockItemList

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

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

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



    def blockItemList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.BlockItemListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 146
        self.enterRecursionRule(localctx, 146, self.RULE_blockItemList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1146
            self.blockItem()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1152
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,120,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 = CParser.BlockItemListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_blockItemList)
                    self.state = 1148
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1149
                    self.blockItem() 
                self.state = 1154
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,120,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 BlockItemContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CParser.RULE_blockItem

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

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

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




    def blockItem(self):

        localctx = CParser.BlockItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_blockItem)
        try:
            self.state = 1157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1155
                self.statement()
                pass

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


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


    class ExpressionStatementContext(ParserRuleContext):

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

        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

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


        def getRuleIndex(self):
            return CParser.RULE_expressionStatement

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

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

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




    def expressionStatement(self):

        localctx = CParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_expressionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1160
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                self.state = 1159
                self.expression(0)


            self.state = 1162
            self.match(CParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectionStatementContext(ParserRuleContext):

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

        def IF(self):
            return self.getToken(CParser.IF, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

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


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

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


        def ELSE(self):
            return self.getToken(CParser.ELSE, 0)

        def SWITCH(self):
            return self.getToken(CParser.SWITCH, 0)

        def getRuleIndex(self):
            return CParser.RULE_selectionStatement

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

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

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




    def selectionStatement(self):

        localctx = CParser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_selectionStatement)
        try:
            self.state = 1179
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.IF]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1164
                self.match(CParser.IF)
                self.state = 1165
                self.match(CParser.LEFTPAREN)
                self.state = 1166
                self.expression(0)
                self.state = 1167
                self.match(CParser.RIGHTPAREN)
                self.state = 1168
                self.statement()
                self.state = 1171
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
                if la_ == 1:
                    self.state = 1169
                    self.match(CParser.ELSE)
                    self.state = 1170
                    self.statement()


                pass
            elif token in [CParser.SWITCH]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1173
                self.match(CParser.SWITCH)
                self.state = 1174
                self.match(CParser.LEFTPAREN)
                self.state = 1175
                self.expression(0)
                self.state = 1176
                self.match(CParser.RIGHTPAREN)
                self.state = 1177
                self.statement()
                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 IterationStatementContext(ParserRuleContext):

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

        def WHILE(self):
            return self.getToken(CParser.WHILE, 0)

        def LEFTPAREN(self):
            return self.getToken(CParser.LEFTPAREN, 0)

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


        def RIGHTPAREN(self):
            return self.getToken(CParser.RIGHTPAREN, 0)

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


        def DO(self):
            return self.getToken(CParser.DO, 0)

        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

        def FOR(self):
            return self.getToken(CParser.FOR, 0)

        def forCondition(self):
            return self.getTypedRuleContext(CParser.ForConditionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_iterationStatement

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

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

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




    def iterationStatement(self):

        localctx = CParser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_iterationStatement)
        try:
            self.state = 1201
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CParser.WHILE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1181
                self.match(CParser.WHILE)
                self.state = 1182
                self.match(CParser.LEFTPAREN)
                self.state = 1183
                self.expression(0)
                self.state = 1184
                self.match(CParser.RIGHTPAREN)
                self.state = 1185
                self.statement()
                pass
            elif token in [CParser.DO]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1187
                self.match(CParser.DO)
                self.state = 1188
                self.statement()
                self.state = 1189
                self.match(CParser.WHILE)
                self.state = 1190
                self.match(CParser.LEFTPAREN)
                self.state = 1191
                self.expression(0)
                self.state = 1192
                self.match(CParser.RIGHTPAREN)
                self.state = 1193
                self.match(CParser.SEMI)
                pass
            elif token in [CParser.FOR]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1195
                self.match(CParser.FOR)
                self.state = 1196
                self.match(CParser.LEFTPAREN)
                self.state = 1197
                self.forCondition()
                self.state = 1198
                self.match(CParser.RIGHTPAREN)
                self.state = 1199
                self.statement()
                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 ForConditionContext(ParserRuleContext):

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

        def forDeclaration(self):
            return self.getTypedRuleContext(CParser.ForDeclarationContext,0)


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

        def forExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CParser.ForExpressionContext)
            else:
                return self.getTypedRuleContext(CParser.ForExpressionContext,i)


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


        def getRuleIndex(self):
            return CParser.RULE_forCondition

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

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

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




    def forCondition(self):

        localctx = CParser.ForConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_forCondition)
        self._la = 0 # Token type
        try:
            self.state = 1223
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1203
                self.forDeclaration()
                self.state = 1204
                self.match(CParser.SEMI)
                self.state = 1206
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1205
                    self.forExpression(0)


                self.state = 1208
                self.match(CParser.SEMI)
                self.state = 1210
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1209
                    self.forExpression(0)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1213
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1212
                    self.expression(0)


                self.state = 1215
                self.match(CParser.SEMI)
                self.state = 1217
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1216
                    self.forExpression(0)


                self.state = 1219
                self.match(CParser.SEMI)
                self.state = 1221
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1220
                    self.forExpression(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 ForDeclarationContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CParser.RULE_forDeclaration

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

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

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




    def forDeclaration(self):

        localctx = CParser.ForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_forDeclaration)
        try:
            self.state = 1229
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1225
                self.declarationSpecifiers()
                self.state = 1226
                self.initDeclaratorList(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1228
                self.declarationSpecifiers()
                pass


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


    class ForExpressionContext(ParserRuleContext):

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

        def assignmentExpression(self):
            return self.getTypedRuleContext(CParser.AssignmentExpressionContext,0)


        def forExpression(self):
            return self.getTypedRuleContext(CParser.ForExpressionContext,0)


        def COMMA(self):
            return self.getToken(CParser.COMMA, 0)

        def getRuleIndex(self):
            return CParser.RULE_forExpression

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

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

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



    def forExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.ForExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 160
        self.enterRecursionRule(localctx, 160, self.RULE_forExpression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1232
            self.assignmentExpression()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1239
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,133,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 = CParser.ForExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_forExpression)
                    self.state = 1234
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1235
                    self.match(CParser.COMMA)
                    self.state = 1236
                    self.assignmentExpression() 
                self.state = 1241
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,133,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 JumpStatementContext(ParserRuleContext):

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

        def GOTO(self):
            return self.getToken(CParser.GOTO, 0)

        def IDENTIFIER(self):
            return self.getToken(CParser.IDENTIFIER, 0)

        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

        def CONTINUE(self):
            return self.getToken(CParser.CONTINUE, 0)

        def BREAK(self):
            return self.getToken(CParser.BREAK, 0)

        def RETURN(self):
            return self.getToken(CParser.RETURN, 0)

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


        def unaryExpression(self):
            return self.getTypedRuleContext(CParser.UnaryExpressionContext,0)


        def getRuleIndex(self):
            return CParser.RULE_jumpStatement

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

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

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




    def jumpStatement(self):

        localctx = CParser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_jumpStatement)
        self._la = 0 # Token type
        try:
            self.state = 1258
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1242
                self.match(CParser.GOTO)
                self.state = 1243
                self.match(CParser.IDENTIFIER)
                self.state = 1244
                self.match(CParser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1245
                self.match(CParser.CONTINUE)
                self.state = 1246
                self.match(CParser.SEMI)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1247
                self.match(CParser.BREAK)
                self.state = 1248
                self.match(CParser.SEMI)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1249
                self.match(CParser.RETURN)
                self.state = 1251
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.SIZEOF) | (1 << CParser.ALIGNOF) | (1 << CParser.GENERIC) | (1 << CParser.LEFTPAREN) | (1 << CParser.PLUS) | (1 << CParser.PLUSPLUS))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CParser.MINUS - 64)) | (1 << (CParser.MINUSMINUS - 64)) | (1 << (CParser.STAR - 64)) | (1 << (CParser.AND - 64)) | (1 << (CParser.ANDAND - 64)) | (1 << (CParser.NOT - 64)) | (1 << (CParser.TILDE - 64)) | (1 << (CParser.EXTENSION - 64)) | (1 << (CParser.BUILTIN_VA_ARG - 64)) | (1 << (CParser.BUILTIN_OFFSETOF - 64)) | (1 << (CParser.IDENTIFIER - 64)) | (1 << (CParser.CONSTANT - 64)) | (1 << (CParser.DIGIT_SEQUENCE - 64)) | (1 << (CParser.STRING_LITERAL - 64)))) != 0):
                    self.state = 1250
                    self.expression(0)


                self.state = 1253
                self.match(CParser.SEMI)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1254
                self.match(CParser.GOTO)
                self.state = 1255
                self.unaryExpression()
                self.state = 1256
                self.match(CParser.SEMI)
                pass


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


    class CompilationUnitContext(ParserRuleContext):

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

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

        def translationUnit(self):
            return self.getTypedRuleContext(CParser.TranslationUnitContext,0)


        def getRuleIndex(self):
            return CParser.RULE_compilationUnit

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

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

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




    def compilationUnit(self):

        localctx = CParser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_compilationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1261
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.AUTO) | (1 << CParser.CHAR) | (1 << CParser.CONST) | (1 << CParser.DOUBLE) | (1 << CParser.ENUM) | (1 << CParser.EXTERN) | (1 << CParser.FLOAT) | (1 << CParser.INLINE) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.REGISTER) | (1 << CParser.RESTRICT) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.STATIC) | (1 << CParser.STRUCT) | (1 << CParser.TYPEDEF) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.VOLATILE) | (1 << CParser.ALIGNAS) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.NORETURN) | (1 << CParser.STATICASSERT) | (1 << CParser.THREADLOCAL) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I) | (1 << CParser.LEFTPAREN))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (CParser.STAR - 66)) | (1 << (CParser.CARET - 66)) | (1 << (CParser.SEMI - 66)) | (1 << (CParser.EXTENSION - 66)) | (1 << (CParser.TYPEOF - 66)) | (1 << (CParser.DUNDER_INLINE - 66)) | (1 << (CParser.STDCALL - 66)) | (1 << (CParser.DECLSPEC - 66)) | (1 << (CParser.ATTRIBUTE - 66)) | (1 << (CParser.IDENTIFIER - 66)))) != 0):
                self.state = 1260
                self.translationUnit(0)


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


    class TranslationUnitContext(ParserRuleContext):

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

        def externalDeclaration(self):
            return self.getTypedRuleContext(CParser.ExternalDeclarationContext,0)


        def translationUnit(self):
            return self.getTypedRuleContext(CParser.TranslationUnitContext,0)


        def getRuleIndex(self):
            return CParser.RULE_translationUnit

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

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

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



    def translationUnit(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.TranslationUnitContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 166
        self.enterRecursionRule(localctx, 166, self.RULE_translationUnit, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1266
            self.externalDeclaration()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1272
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,137,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 = CParser.TranslationUnitContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_translationUnit)
                    self.state = 1268
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1269
                    self.externalDeclaration() 
                self.state = 1274
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,137,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 ExternalDeclarationContext(ParserRuleContext):

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

        def functionDefinition(self):
            return self.getTypedRuleContext(CParser.FunctionDefinitionContext,0)


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


        def SEMI(self):
            return self.getToken(CParser.SEMI, 0)

        def getRuleIndex(self):
            return CParser.RULE_externalDeclaration

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

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

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




    def externalDeclaration(self):

        localctx = CParser.ExternalDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_externalDeclaration)
        try:
            self.state = 1278
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1275
                self.functionDefinition()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1277
                self.match(CParser.SEMI)
                pass


        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 declarator(self):
            return self.getTypedRuleContext(CParser.DeclaratorContext,0)


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


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


        def declarationList(self):
            return self.getTypedRuleContext(CParser.DeclarationListContext,0)


        def getRuleIndex(self):
            return CParser.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 = CParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1281
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,139,self._ctx)
            if la_ == 1:
                self.state = 1280
                self.declarationSpecifiers()


            self.state = 1283
            self.declarator()
            self.state = 1285
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CParser.AUTO) | (1 << CParser.CHAR) | (1 << CParser.CONST) | (1 << CParser.DOUBLE) | (1 << CParser.ENUM) | (1 << CParser.EXTERN) | (1 << CParser.FLOAT) | (1 << CParser.INLINE) | (1 << CParser.INT) | (1 << CParser.LONG) | (1 << CParser.REGISTER) | (1 << CParser.RESTRICT) | (1 << CParser.SHORT) | (1 << CParser.SIGNED) | (1 << CParser.STATIC) | (1 << CParser.STRUCT) | (1 << CParser.TYPEDEF) | (1 << CParser.UNION) | (1 << CParser.UNSIGNED) | (1 << CParser.VOID) | (1 << CParser.VOLATILE) | (1 << CParser.ALIGNAS) | (1 << CParser.ATOMIC) | (1 << CParser.BOOL) | (1 << CParser.COMPLEX) | (1 << CParser.NORETURN) | (1 << CParser.STATICASSERT) | (1 << CParser.THREADLOCAL) | (1 << CParser.M128) | (1 << CParser.M128D) | (1 << CParser.M128I))) != 0) or ((((_la - 96)) & ~0x3f) == 0 and ((1 << (_la - 96)) & ((1 << (CParser.EXTENSION - 96)) | (1 << (CParser.TYPEOF - 96)) | (1 << (CParser.DUNDER_INLINE - 96)) | (1 << (CParser.STDCALL - 96)) | (1 << (CParser.DECLSPEC - 96)) | (1 << (CParser.ATTRIBUTE - 96)) | (1 << (CParser.IDENTIFIER - 96)))) != 0):
                self.state = 1284
                self.declarationList(0)


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

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

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


        def declarationList(self):
            return self.getTypedRuleContext(CParser.DeclarationListContext,0)


        def getRuleIndex(self):
            return CParser.RULE_declarationList

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

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

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



    def declarationList(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = CParser.DeclarationListContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 172
        self.enterRecursionRule(localctx, 172, self.RULE_declarationList, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1290
            self.declaration()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1296
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,141,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 = CParser.DeclarationListContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_declarationList)
                    self.state = 1292
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1293
                    self.declaration() 
                self.state = 1298
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,141,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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[2] = self.genericAssocList_sempred
        self._predicates[4] = self.postfixExpression_sempred
        self._predicates[5] = self.argumentExpressionList_sempred
        self._predicates[9] = self.multiplicativeExpression_sempred
        self._predicates[10] = self.additiveExpression_sempred
        self._predicates[11] = self.shiftExpression_sempred
        self._predicates[12] = self.relationalExpression_sempred
        self._predicates[13] = self.equalityExpression_sempred
        self._predicates[14] = self.andExpression_sempred
        self._predicates[15] = self.exclusiveOrExpression_sempred
        self._predicates[16] = self.inclusiveOrExpression_sempred
        self._predicates[17] = self.logicalAndExpression_sempred
        self._predicates[18] = self.logicalOrExpression_sempred
        self._predicates[22] = self.expression_sempred
        self._predicates[28] = self.initDeclaratorList_sempred
        self._predicates[31] = self.typeSpecifier_sempred
        self._predicates[34] = self.structDeclarationList_sempred
        self._predicates[37] = self.structDeclaratorList_sempred
        self._predicates[40] = self.enumeratorList_sempred
        self._predicates[48] = self.directDeclarator_sempred
        self._predicates[55] = self.typeQualifierList_sempred
        self._predicates[57] = self.parameterList_sempred
        self._predicates[59] = self.identifierList_sempred
        self._predicates[62] = self.directAbstractDeclarator_sempred
        self._predicates[65] = self.initializerList_sempred
        self._predicates[67] = self.designatorList_sempred
        self._predicates[73] = self.blockItemList_sempred
        self._predicates[80] = self.forExpression_sempred
        self._predicates[83] = self.translationUnit_sempred
        self._predicates[86] = self.declarationList_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 genericAssocList_sempred(self, localctx:GenericAssocListContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

    def postfixExpression_sempred(self, localctx:PostfixExpressionContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 10)
         

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

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

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

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

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

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

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

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

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

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

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

    def shiftExpression_sempred(self, localctx:ShiftExpressionContext, predIndex:int):
            if predIndex == 13:
                return self.precpred(self._ctx, 2)
         

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

    def relationalExpression_sempred(self, localctx:RelationalExpressionContext, predIndex:int):
            if predIndex == 15:
                return self.precpred(self._ctx, 4)
         

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

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

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

    def equalityExpression_sempred(self, localctx:EqualityExpressionContext, predIndex:int):
            if predIndex == 19:
                return self.precpred(self._ctx, 2)
         

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

    def andExpression_sempred(self, localctx:AndExpressionContext, predIndex:int):
            if predIndex == 21:
                return self.precpred(self._ctx, 1)
         

    def exclusiveOrExpression_sempred(self, localctx:ExclusiveOrExpressionContext, predIndex:int):
            if predIndex == 22:
                return self.precpred(self._ctx, 1)
         

    def inclusiveOrExpression_sempred(self, localctx:InclusiveOrExpressionContext, predIndex:int):
            if predIndex == 23:
                return self.precpred(self._ctx, 1)
         

    def logicalAndExpression_sempred(self, localctx:LogicalAndExpressionContext, predIndex:int):
            if predIndex == 24:
                return self.precpred(self._ctx, 1)
         

    def logicalOrExpression_sempred(self, localctx:LogicalOrExpressionContext, predIndex:int):
            if predIndex == 25:
                return self.precpred(self._ctx, 1)
         

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

    def initDeclaratorList_sempred(self, localctx:InitDeclaratorListContext, predIndex:int):
            if predIndex == 27:
                return self.precpred(self._ctx, 1)
         

    def typeSpecifier_sempred(self, localctx:TypeSpecifierContext, predIndex:int):
            if predIndex == 28:
                return self.precpred(self._ctx, 1)
         

    def structDeclarationList_sempred(self, localctx:StructDeclarationListContext, predIndex:int):
            if predIndex == 29:
                return self.precpred(self._ctx, 1)
         

    def structDeclaratorList_sempred(self, localctx:StructDeclaratorListContext, predIndex:int):
            if predIndex == 30:
                return self.precpred(self._ctx, 1)
         

    def enumeratorList_sempred(self, localctx:EnumeratorListContext, predIndex:int):
            if predIndex == 31:
                return self.precpred(self._ctx, 1)
         

    def directDeclarator_sempred(self, localctx:DirectDeclaratorContext, predIndex:int):
            if predIndex == 32:
                return self.precpred(self._ctx, 8)
         

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

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

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

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

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

    def typeQualifierList_sempred(self, localctx:TypeQualifierListContext, predIndex:int):
            if predIndex == 38:
                return self.precpred(self._ctx, 1)
         

    def parameterList_sempred(self, localctx:ParameterListContext, predIndex:int):
            if predIndex == 39:
                return self.precpred(self._ctx, 1)
         

    def identifierList_sempred(self, localctx:IdentifierListContext, predIndex:int):
            if predIndex == 40:
                return self.precpred(self._ctx, 1)
         

    def directAbstractDeclarator_sempred(self, localctx:DirectAbstractDeclaratorContext, predIndex:int):
            if predIndex == 41:
                return self.precpred(self._ctx, 5)
         

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

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

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

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

    def initializerList_sempred(self, localctx:InitializerListContext, predIndex:int):
            if predIndex == 46:
                return self.precpred(self._ctx, 1)
         

    def designatorList_sempred(self, localctx:DesignatorListContext, predIndex:int):
            if predIndex == 47:
                return self.precpred(self._ctx, 1)
         

    def blockItemList_sempred(self, localctx:BlockItemListContext, predIndex:int):
            if predIndex == 48:
                return self.precpred(self._ctx, 1)
         

    def forExpression_sempred(self, localctx:ForExpressionContext, predIndex:int):
            if predIndex == 49:
                return self.precpred(self._ctx, 1)
         

    def translationUnit_sempred(self, localctx:TranslationUnitContext, predIndex:int):
            if predIndex == 50:
                return self.precpred(self._ctx, 1)
         

    def declarationList_sempred(self, localctx:DeclarationListContext, predIndex:int):
            if predIndex == 51:
                return self.precpred(self._ctx, 1)
