# Generated from C11.g4 by ANTLR 4.9.3
# encoding: utf-8
from 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("\u044b\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\7\4\u00de\n\4\f\4\16\4\u00e1\13\4\3\5\3\5\5\5\u00e5")
        buf.write("\n\5\3\5\3\5\3\5\3\6\3\6\5\6\u00ec\n\6\3\6\3\6\3\6\3\6")
        buf.write("\3\6\3\6\5\6\u00f4\n\6\3\6\3\6\5\6\u00f8\n\6\3\6\3\6\3")
        buf.write("\6\3\6\3\6\3\6\5\6\u0100\n\6\3\6\3\6\3\6\3\6\7\6\u0106")
        buf.write("\n\6\f\6\16\6\u0109\13\6\3\7\3\7\3\7\7\7\u010e\n\7\f\7")
        buf.write("\16\7\u0111\13\7\3\b\7\b\u0114\n\b\f\b\16\b\u0117\13\b")
        buf.write("\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u0124")
        buf.write("\n\b\3\t\3\t\3\n\5\n\u0129\n\n\3\n\3\n\3\n\3\n\3\n\3\n")
        buf.write("\3\n\5\n\u0132\n\n\3\13\3\13\3\13\7\13\u0137\n\13\f\13")
        buf.write("\16\13\u013a\13\13\3\f\3\f\3\f\7\f\u013f\n\f\f\f\16\f")
        buf.write("\u0142\13\f\3\r\3\r\3\r\7\r\u0147\n\r\f\r\16\r\u014a\13")
        buf.write("\r\3\16\3\16\3\16\7\16\u014f\n\16\f\16\16\16\u0152\13")
        buf.write("\16\3\17\3\17\3\17\7\17\u0157\n\17\f\17\16\17\u015a\13")
        buf.write("\17\3\20\3\20\3\20\7\20\u015f\n\20\f\20\16\20\u0162\13")
        buf.write("\20\3\21\3\21\3\21\7\21\u0167\n\21\f\21\16\21\u016a\13")
        buf.write("\21\3\22\3\22\3\22\7\22\u016f\n\22\f\22\16\22\u0172\13")
        buf.write("\22\3\23\3\23\3\23\7\23\u0177\n\23\f\23\16\23\u017a\13")
        buf.write("\23\3\24\3\24\3\24\7\24\u017f\n\24\f\24\16\24\u0182\13")
        buf.write("\24\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u018a\n\25\3\26")
        buf.write("\3\26\3\26\3\26\3\26\3\26\5\26\u0192\n\26\3\27\3\27\3")
        buf.write("\30\3\30\3\30\7\30\u0199\n\30\f\30\16\30\u019c\13\30\3")
        buf.write("\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32")
        buf.write("\u01a8\n\32\3\33\6\33\u01ab\n\33\r\33\16\33\u01ac\3\34")
        buf.write("\6\34\u01b0\n\34\r\34\16\34\u01b1\3\35\3\35\3\35\3\35")
        buf.write("\3\35\5\35\u01b9\n\35\3\36\3\36\3\36\7\36\u01be\n\36\f")
        buf.write("\36\16\36\u01c1\13\36\3\37\3\37\3\37\5\37\u01c6\n\37\3")
        buf.write(" \3 \3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u01d9")
        buf.write("\n!\3!\3!\7!\u01dd\n!\f!\16!\u01e0\13!\3\"\3\"\5\"\u01e4")
        buf.write("\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u01ed\n\"\3#\3#\3")
        buf.write("$\6$\u01f2\n$\r$\16$\u01f3\3%\3%\5%\u01f8\n%\3%\3%\3%")
        buf.write("\5%\u01fd\n%\3&\3&\5&\u0201\n&\3&\5&\u0204\n&\3\'\3\'")
        buf.write("\3\'\7\'\u0209\n\'\f\'\16\'\u020c\13\'\3(\3(\5(\u0210")
        buf.write("\n(\3(\3(\5(\u0214\n(\3)\3)\5)\u0218\n)\3)\3)\3)\5)\u021d")
        buf.write("\n)\3)\3)\3)\3)\5)\u0223\n)\3*\3*\3*\7*\u0228\n*\f*\16")
        buf.write("*\u022b\13*\3+\3+\3+\5+\u0230\n+\3,\3,\3-\3-\3-\3-\3-")
        buf.write("\3.\3.\3/\3/\3/\3/\3/\3/\5/\u0241\n/\3\60\3\60\3\60\3")
        buf.write("\60\5\60\u0247\n\60\3\60\3\60\3\61\5\61\u024c\n\61\3\61")
        buf.write("\3\61\7\61\u0250\n\61\f\61\16\61\u0253\13\61\3\62\3\62")
        buf.write("\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\5\62\u0260")
        buf.write("\n\62\3\62\3\62\3\62\3\62\5\62\u0266\n\62\3\62\3\62\3")
        buf.write("\62\5\62\u026b\n\62\3\62\5\62\u026e\n\62\3\62\3\62\3\62")
        buf.write("\3\62\3\62\5\62\u0275\n\62\3\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\5\62\u0284\n\62")
        buf.write("\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\5\62")
        buf.write("\u0290\n\62\3\62\7\62\u0293\n\62\f\62\16\62\u0296\13\62")
        buf.write("\3\63\3\63\3\63\6\63\u029b\n\63\r\63\16\63\u029c\3\63")
        buf.write("\3\63\5\63\u02a1\n\63\3\64\3\64\3\64\3\64\3\64\3\64\3")
        buf.write("\64\3\65\5\65\u02ab\n\65\3\65\3\65\5\65\u02af\n\65\7\65")
        buf.write("\u02b1\n\65\f\65\16\65\u02b4\13\65\3\66\3\66\3\66\5\66")
        buf.write("\u02b9\n\66\3\66\5\66\u02bc\n\66\3\67\3\67\3\67\3\67\3")
        buf.write("\67\7\67\u02c3\n\67\f\67\16\67\u02c6\13\67\38\38\58\u02ca")
        buf.write("\n8\68\u02cc\n8\r8\168\u02cd\39\69\u02d1\n9\r9\169\u02d2")
        buf.write("\3:\3:\3:\5:\u02d8\n:\3;\3;\3;\7;\u02dd\n;\f;\16;\u02e0")
        buf.write("\13;\3<\3<\3<\3<\3<\5<\u02e7\n<\5<\u02e9\n<\3=\3=\3=\7")
        buf.write("=\u02ee\n=\f=\16=\u02f1\13=\3>\3>\5>\u02f5\n>\3?\3?\5")
        buf.write("?\u02f9\n?\3?\3?\7?\u02fd\n?\f?\16?\u0300\13?\5?\u0302")
        buf.write("\n?\3@\3@\3@\3@\3@\7@\u0309\n@\f@\16@\u030c\13@\3@\3@")
        buf.write("\5@\u0310\n@\3@\5@\u0313\n@\3@\3@\3@\3@\5@\u0319\n@\3")
        buf.write("@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u0329\n@\3")
        buf.write("@\3@\7@\u032d\n@\f@\16@\u0330\13@\5@\u0332\n@\3@\3@\3")
        buf.write("@\5@\u0337\n@\3@\5@\u033a\n@\3@\3@\3@\3@\3@\5@\u0341\n")
        buf.write("@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5")
        buf.write("@\u0354\n@\3@\3@\7@\u0358\n@\f@\16@\u035b\13@\7@\u035d")
        buf.write("\n@\f@\16@\u0360\13@\3A\3A\3B\3B\3B\3B\5B\u0368\nB\3B")
        buf.write("\3B\5B\u036c\nB\3C\5C\u036f\nC\3C\3C\3C\5C\u0374\nC\3")
        buf.write("C\7C\u0377\nC\fC\16C\u037a\13C\3D\3D\3D\3E\6E\u0380\n")
        buf.write("E\rE\16E\u0381\3F\3F\3F\3F\3F\3F\5F\u038a\nF\3G\3G\3G")
        buf.write("\3G\3G\6G\u0391\nG\rG\16G\u0392\3G\3G\3G\3H\3H\3H\3H\3")
        buf.write("H\3H\3H\3H\3H\3H\3H\3H\7H\u03a4\nH\fH\16H\u03a7\13H\5")
        buf.write("H\u03a9\nH\3H\3H\3H\3H\7H\u03af\nH\fH\16H\u03b2\13H\5")
        buf.write("H\u03b4\nH\7H\u03b6\nH\fH\16H\u03b9\13H\3H\3H\5H\u03bd")
        buf.write("\nH\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03ca\nI\3J\3")
        buf.write("J\5J\u03ce\nJ\3J\3J\3K\6K\u03d3\nK\rK\16K\u03d4\3L\3L")
        buf.write("\5L\u03d9\nL\3M\5M\u03dc\nM\3M\3M\3N\3N\3N\3N\3N\3N\3")
        buf.write("N\5N\u03e7\nN\3N\3N\3N\3N\3N\3N\5N\u03ef\nN\3O\3O\3O\3")
        buf.write("O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u0405")
        buf.write("\nO\3P\3P\5P\u0409\nP\5P\u040b\nP\3P\3P\5P\u040f\nP\3")
        buf.write("P\3P\5P\u0413\nP\3Q\3Q\5Q\u0417\nQ\3R\3R\3R\7R\u041c\n")
        buf.write("R\fR\16R\u041f\13R\3S\3S\3S\3S\3S\5S\u0426\nS\3S\3S\5")
        buf.write("S\u042a\nS\3S\3S\3T\5T\u042f\nT\3T\3T\3U\6U\u0434\nU\r")
        buf.write("U\16U\u0435\3V\3V\3V\5V\u043b\nV\3W\5W\u043e\nW\3W\3W")
        buf.write("\5W\u0442\nW\3W\3W\3X\6X\u0447\nX\rX\16X\u0448\3X\2\5")
        buf.write("@b~Y\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60")
        buf.write("\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082")
        buf.write("\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094")
        buf.write("\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6")
        buf.write("\u00a8\u00aa\u00ac\u00ae\2\31\3\2hi\4\2JJLL\5\2))JJLL")
        buf.write("\4\2))\64\64\7\2IIKKMMPPUV\3\2MO\4\2IIKK\3\2GH\3\2CF\3")
        buf.write("\2fg\3\2[e\b\2\21\21\34\34$$**--<<\n\2\6\b\24\24\31\31")
        buf.write("\35\35\"#\'(/\60\66\67\3\2\6\b\4\2++..\6\2\25\25%%\61")
        buf.write("\61\65\65\5\2\n\13!!::\4\2=>ZZ\3\2=>\4\2MMTT\4\2\r\r\17")
        buf.write("\17\4\2\20\20\61\61\4\2\22\22\26\26\2\u04a8\2\u00d1\3")
        buf.write("\2\2\2\4\u00d3\3\2\2\2\6\u00da\3\2\2\2\b\u00e4\3\2\2\2")
        buf.write("\n\u00f7\3\2\2\2\f\u010a\3\2\2\2\16\u0115\3\2\2\2\20\u0125")
        buf.write("\3\2\2\2\22\u0131\3\2\2\2\24\u0133\3\2\2\2\26\u013b\3")
        buf.write("\2\2\2\30\u0143\3\2\2\2\32\u014b\3\2\2\2\34\u0153\3\2")
        buf.write("\2\2\36\u015b\3\2\2\2 \u0163\3\2\2\2\"\u016b\3\2\2\2$")
        buf.write("\u0173\3\2\2\2&\u017b\3\2\2\2(\u0183\3\2\2\2*\u0191\3")
        buf.write("\2\2\2,\u0193\3\2\2\2.\u0195\3\2\2\2\60\u019d\3\2\2\2")
        buf.write("\62\u01a7\3\2\2\2\64\u01aa\3\2\2\2\66\u01af\3\2\2\28\u01b8")
        buf.write("\3\2\2\2:\u01ba\3\2\2\2<\u01c2\3\2\2\2>\u01c7\3\2\2\2")
        buf.write("@\u01d8\3\2\2\2B\u01ec\3\2\2\2D\u01ee\3\2\2\2F\u01f1\3")
        buf.write("\2\2\2H\u01fc\3\2\2\2J\u0200\3\2\2\2L\u0205\3\2\2\2N\u0213")
        buf.write("\3\2\2\2P\u0222\3\2\2\2R\u0224\3\2\2\2T\u022c\3\2\2\2")
        buf.write("V\u0231\3\2\2\2X\u0233\3\2\2\2Z\u0238\3\2\2\2\\\u0240")
        buf.write("\3\2\2\2^\u0242\3\2\2\2`\u024b\3\2\2\2b\u0265\3\2\2\2")
        buf.write("d\u02a0\3\2\2\2f\u02a2\3\2\2\2h\u02aa\3\2\2\2j\u02b5\3")
        buf.write("\2\2\2l\u02c4\3\2\2\2n\u02cb\3\2\2\2p\u02d0\3\2\2\2r\u02d4")
        buf.write("\3\2\2\2t\u02d9\3\2\2\2v\u02e8\3\2\2\2x\u02ea\3\2\2\2")
        buf.write("z\u02f2\3\2\2\2|\u0301\3\2\2\2~\u0331\3\2\2\2\u0080\u0361")
        buf.write("\3\2\2\2\u0082\u036b\3\2\2\2\u0084\u036e\3\2\2\2\u0086")
        buf.write("\u037b\3\2\2\2\u0088\u037f\3\2\2\2\u008a\u0389\3\2\2\2")
        buf.write("\u008c\u038b\3\2\2\2\u008e\u03bc\3\2\2\2\u0090\u03c9\3")
        buf.write("\2\2\2\u0092\u03cb\3\2\2\2\u0094\u03d2\3\2\2\2\u0096\u03d8")
        buf.write("\3\2\2\2\u0098\u03db\3\2\2\2\u009a\u03ee\3\2\2\2\u009c")
        buf.write("\u0404\3\2\2\2\u009e\u040a\3\2\2\2\u00a0\u0414\3\2\2\2")
        buf.write("\u00a2\u0418\3\2\2\2\u00a4\u0429\3\2\2\2\u00a6\u042e\3")
        buf.write("\2\2\2\u00a8\u0433\3\2\2\2\u00aa\u043a\3\2\2\2\u00ac\u043d")
        buf.write("\3\2\2\2\u00ae\u0446\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=\2\2\u00b8\u00b9\5")
        buf.write(".\30\2\u00b9\u00ba\7>\2\2\u00ba\u00d2\3\2\2\2\u00bb\u00d2")
        buf.write("\5\4\3\2\u00bc\u00be\7\3\2\2\u00bd\u00bc\3\2\2\2\u00bd")
        buf.write("\u00be\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c0\7=\2\2")
        buf.write("\u00c0\u00c1\5\u0092J\2\u00c1\u00c2\7>\2\2\u00c2\u00d2")
        buf.write("\3\2\2\2\u00c3\u00c4\7\4\2\2\u00c4\u00c5\7=\2\2\u00c5")
        buf.write("\u00c6\5\16\b\2\u00c6\u00c7\7Z\2\2\u00c7\u00c8\5z>\2\u00c8")
        buf.write("\u00c9\7>\2\2\u00c9\u00d2\3\2\2\2\u00ca\u00cb\7\5\2\2")
        buf.write("\u00cb\u00cc\7=\2\2\u00cc\u00cd\5z>\2\u00cd\u00ce\7Z\2")
        buf.write("\2\u00ce\u00cf\5\16\b\2\u00cf\u00d0\7>\2\2\u00d0\u00d2")
        buf.write("\3\2\2\2\u00d1\u00b0\3\2\2\2\u00d1\u00b1\3\2\2\2\u00d1")
        buf.write("\u00b3\3\2\2\2\u00d1\u00b7\3\2\2\2\u00d1\u00bb\3\2\2\2")
        buf.write("\u00d1\u00bd\3\2\2\2\u00d1\u00c3\3\2\2\2\u00d1\u00ca\3")
        buf.write("\2\2\2\u00d2\3\3\2\2\2\u00d3\u00d4\78\2\2\u00d4\u00d5")
        buf.write("\7=\2\2\u00d5\u00d6\5*\26\2\u00d6\u00d7\7Z\2\2\u00d7\u00d8")
        buf.write("\5\6\4\2\u00d8\u00d9\7>\2\2\u00d9\5\3\2\2\2\u00da\u00df")
        buf.write("\5\b\5\2\u00db\u00dc\7Z\2\2\u00dc\u00de\5\b\5\2\u00dd")
        buf.write("\u00db\3\2\2\2\u00de\u00e1\3\2\2\2\u00df\u00dd\3\2\2\2")
        buf.write("\u00df\u00e0\3\2\2\2\u00e0\7\3\2\2\2\u00e1\u00df\3\2\2")
        buf.write("\2\u00e2\u00e5\5z>\2\u00e3\u00e5\7\27\2\2\u00e4\u00e2")
        buf.write("\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6")
        buf.write("\u00e7\7X\2\2\u00e7\u00e8\5*\26\2\u00e8\t\3\2\2\2\u00e9")
        buf.write("\u00f8\5\2\2\2\u00ea\u00ec\7\3\2\2\u00eb\u00ea\3\2\2\2")
        buf.write("\u00eb\u00ec\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee\7")
        buf.write("=\2\2\u00ee\u00ef\5z>\2\u00ef\u00f0\7>\2\2\u00f0\u00f1")
        buf.write("\7A\2\2\u00f1\u00f3\5\u0084C\2\u00f2\u00f4\7Z\2\2\u00f3")
        buf.write("\u00f2\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f5\3\2\2\2")
        buf.write("\u00f5\u00f6\7B\2\2\u00f6\u00f8\3\2\2\2\u00f7\u00e9\3")
        buf.write("\2\2\2\u00f7\u00eb\3\2\2\2\u00f8\u0107\3\2\2\2\u00f9\u00fa")
        buf.write("\7?\2\2\u00fa\u00fb\5.\30\2\u00fb\u00fc\7@\2\2\u00fc\u0106")
        buf.write("\3\2\2\2\u00fd\u00ff\7=\2\2\u00fe\u0100\5\f\7\2\u00ff")
        buf.write("\u00fe\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2")
        buf.write("\u0101\u0106\7>\2\2\u0102\u0103\t\2\2\2\u0103\u0106\7")
        buf.write("k\2\2\u0104\u0106\t\3\2\2\u0105\u00f9\3\2\2\2\u0105\u00fd")
        buf.write("\3\2\2\2\u0105\u0102\3\2\2\2\u0105\u0104\3\2\2\2\u0106")
        buf.write("\u0109\3\2\2\2\u0107\u0105\3\2\2\2\u0107\u0108\3\2\2\2")
        buf.write("\u0108\13\3\2\2\2\u0109\u0107\3\2\2\2\u010a\u010f\5*\26")
        buf.write("\2\u010b\u010c\7Z\2\2\u010c\u010e\5*\26\2\u010d\u010b")
        buf.write("\3\2\2\2\u010e\u0111\3\2\2\2\u010f\u010d\3\2\2\2\u010f")
        buf.write("\u0110\3\2\2\2\u0110\r\3\2\2\2\u0111\u010f\3\2\2\2\u0112")
        buf.write("\u0114\t\4\2\2\u0113\u0112\3\2\2\2\u0114\u0117\3\2\2\2")
        buf.write("\u0115\u0113\3\2\2\2\u0115\u0116\3\2\2\2\u0116\u0123\3")
        buf.write("\2\2\2\u0117\u0115\3\2\2\2\u0118\u0124\5\n\6\2\u0119\u011a")
        buf.write("\5\20\t\2\u011a\u011b\5\22\n\2\u011b\u0124\3\2\2\2\u011c")
        buf.write("\u011d\t\5\2\2\u011d\u011e\7=\2\2\u011e\u011f\5z>\2\u011f")
        buf.write("\u0120\7>\2\2\u0120\u0124\3\2\2\2\u0121\u0122\7R\2\2\u0122")
        buf.write("\u0124\7k\2\2\u0123\u0118\3\2\2\2\u0123\u0119\3\2\2\2")
        buf.write("\u0123\u011c\3\2\2\2\u0123\u0121\3\2\2\2\u0124\17\3\2")
        buf.write("\2\2\u0125\u0126\t\6\2\2\u0126\21\3\2\2\2\u0127\u0129")
        buf.write("\7\3\2\2\u0128\u0127\3\2\2\2\u0128\u0129\3\2\2\2\u0129")
        buf.write("\u012a\3\2\2\2\u012a\u012b\7=\2\2\u012b\u012c\5z>\2\u012c")
        buf.write("\u012d\7>\2\2\u012d\u012e\5\22\n\2\u012e\u0132\3\2\2\2")
        buf.write("\u012f\u0132\5\16\b\2\u0130\u0132\7m\2\2\u0131\u0128\3")
        buf.write("\2\2\2\u0131\u012f\3\2\2\2\u0131\u0130\3\2\2\2\u0132\23")
        buf.write("\3\2\2\2\u0133\u0138\5\22\n\2\u0134\u0135\t\7\2\2\u0135")
        buf.write("\u0137\5\22\n\2\u0136\u0134\3\2\2\2\u0137\u013a\3\2\2")
        buf.write("\2\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\25\3")
        buf.write("\2\2\2\u013a\u0138\3\2\2\2\u013b\u0140\5\24\13\2\u013c")
        buf.write("\u013d\t\b\2\2\u013d\u013f\5\24\13\2\u013e\u013c\3\2\2")
        buf.write("\2\u013f\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0140\u0141")
        buf.write("\3\2\2\2\u0141\27\3\2\2\2\u0142\u0140\3\2\2\2\u0143\u0148")
        buf.write("\5\26\f\2\u0144\u0145\t\t\2\2\u0145\u0147\5\26\f\2\u0146")
        buf.write("\u0144\3\2\2\2\u0147\u014a\3\2\2\2\u0148\u0146\3\2\2\2")
        buf.write("\u0148\u0149\3\2\2\2\u0149\31\3\2\2\2\u014a\u0148\3\2")
        buf.write("\2\2\u014b\u0150\5\30\r\2\u014c\u014d\t\n\2\2\u014d\u014f")
        buf.write("\5\30\r\2\u014e\u014c\3\2\2\2\u014f\u0152\3\2\2\2\u0150")
        buf.write("\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151\33\3\2\2\2\u0152")
        buf.write("\u0150\3\2\2\2\u0153\u0158\5\32\16\2\u0154\u0155\t\13")
        buf.write("\2\2\u0155\u0157\5\32\16\2\u0156\u0154\3\2\2\2\u0157\u015a")
        buf.write("\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0159\3\2\2\2\u0159")
        buf.write("\35\3\2\2\2\u015a\u0158\3\2\2\2\u015b\u0160\5\34\17\2")
        buf.write("\u015c\u015d\7P\2\2\u015d\u015f\5\34\17\2\u015e\u015c")
        buf.write("\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e\3\2\2\2\u0160")
        buf.write("\u0161\3\2\2\2\u0161\37\3\2\2\2\u0162\u0160\3\2\2\2\u0163")
        buf.write("\u0168\5\36\20\2\u0164\u0165\7T\2\2\u0165\u0167\5\36\20")
        buf.write("\2\u0166\u0164\3\2\2\2\u0167\u016a\3\2\2\2\u0168\u0166")
        buf.write("\3\2\2\2\u0168\u0169\3\2\2\2\u0169!\3\2\2\2\u016a\u0168")
        buf.write("\3\2\2\2\u016b\u0170\5 \21\2\u016c\u016d\7Q\2\2\u016d")
        buf.write("\u016f\5 \21\2\u016e\u016c\3\2\2\2\u016f\u0172\3\2\2\2")
        buf.write("\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171#\3\2\2")
        buf.write("\2\u0172\u0170\3\2\2\2\u0173\u0178\5\"\22\2\u0174\u0175")
        buf.write("\7R\2\2\u0175\u0177\5\"\22\2\u0176\u0174\3\2\2\2\u0177")
        buf.write("\u017a\3\2\2\2\u0178\u0176\3\2\2\2\u0178\u0179\3\2\2\2")
        buf.write("\u0179%\3\2\2\2\u017a\u0178\3\2\2\2\u017b\u0180\5$\23")
        buf.write("\2\u017c\u017d\7S\2\2\u017d\u017f\5$\23\2\u017e\u017c")
        buf.write("\3\2\2\2\u017f\u0182\3\2\2\2\u0180\u017e\3\2\2\2\u0180")
        buf.write("\u0181\3\2\2\2\u0181\'\3\2\2\2\u0182\u0180\3\2\2\2\u0183")
        buf.write("\u0189\5&\24\2\u0184\u0185\7W\2\2\u0185\u0186\5.\30\2")
        buf.write("\u0186\u0187\7X\2\2\u0187\u0188\5(\25\2\u0188\u018a\3")
        buf.write("\2\2\2\u0189\u0184\3\2\2\2\u0189\u018a\3\2\2\2\u018a)")
        buf.write("\3\2\2\2\u018b\u0192\5(\25\2\u018c\u018d\5\16\b\2\u018d")
        buf.write("\u018e\5,\27\2\u018e\u018f\5*\26\2\u018f\u0192\3\2\2\2")
        buf.write("\u0190\u0192\7m\2\2\u0191\u018b\3\2\2\2\u0191\u018c\3")
        buf.write("\2\2\2\u0191\u0190\3\2\2\2\u0192+\3\2\2\2\u0193\u0194")
        buf.write("\t\f\2\2\u0194-\3\2\2\2\u0195\u019a\5*\26\2\u0196\u0197")
        buf.write("\7Z\2\2\u0197\u0199\5*\26\2\u0198\u0196\3\2\2\2\u0199")
        buf.write("\u019c\3\2\2\2\u019a\u0198\3\2\2\2\u019a\u019b\3\2\2\2")
        buf.write("\u019b/\3\2\2\2\u019c\u019a\3\2\2\2\u019d\u019e\5(\25")
        buf.write("\2\u019e\61\3\2\2\2\u019f\u01a0\5\64\33\2\u01a0\u01a1")
        buf.write("\5:\36\2\u01a1\u01a2\7Y\2\2\u01a2\u01a8\3\2\2\2\u01a3")
        buf.write("\u01a4\5\64\33\2\u01a4\u01a5\7Y\2\2\u01a5\u01a8\3\2\2")
        buf.write("\2\u01a6\u01a8\5\u008cG\2\u01a7\u019f\3\2\2\2\u01a7\u01a3")
        buf.write("\3\2\2\2\u01a7\u01a6\3\2\2\2\u01a8\63\3\2\2\2\u01a9\u01ab")
        buf.write("\58\35\2\u01aa\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac")
        buf.write("\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\65\3\2\2\2\u01ae")
        buf.write("\u01b0\58\35\2\u01af\u01ae\3\2\2\2\u01b0\u01b1\3\2\2\2")
        buf.write("\u01b1\u01af\3\2\2\2\u01b1\u01b2\3\2\2\2\u01b2\67\3\2")
        buf.write("\2\2\u01b3\u01b9\5> \2\u01b4\u01b9\5@!\2\u01b5\u01b9\5")
        buf.write("Z.\2\u01b6\u01b9\5\\/\2\u01b7\u01b9\5^\60\2\u01b8\u01b3")
        buf.write("\3\2\2\2\u01b8\u01b4\3\2\2\2\u01b8\u01b5\3\2\2\2\u01b8")
        buf.write("\u01b6\3\2\2\2\u01b8\u01b7\3\2\2\2\u01b99\3\2\2\2\u01ba")
        buf.write("\u01bf\5<\37\2\u01bb\u01bc\7Z\2\2\u01bc\u01be\5<\37\2")
        buf.write("\u01bd\u01bb\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3")
        buf.write("\2\2\2\u01bf\u01c0\3\2\2\2\u01c0;\3\2\2\2\u01c1\u01bf")
        buf.write("\3\2\2\2\u01c2\u01c5\5`\61\2\u01c3\u01c4\7[\2\2\u01c4")
        buf.write("\u01c6\5\u0082B\2\u01c5\u01c3\3\2\2\2\u01c5\u01c6\3\2")
        buf.write("\2\2\u01c6=\3\2\2\2\u01c7\u01c8\t\r\2\2\u01c8?\3\2\2\2")
        buf.write("\u01c9\u01ca\b!\1\2\u01ca\u01d9\t\16\2\2\u01cb\u01cc\7")
        buf.write("\3\2\2\u01cc\u01cd\7=\2\2\u01cd\u01ce\t\17\2\2\u01ce\u01d9")
        buf.write("\7>\2\2\u01cf\u01d9\5X-\2\u01d0\u01d9\5B\"\2\u01d1\u01d9")
        buf.write("\5P)\2\u01d2\u01d9\5\u0080A\2\u01d3\u01d4\7\t\2\2\u01d4")
        buf.write("\u01d5\7=\2\2\u01d5\u01d6\5\60\31\2\u01d6\u01d7\7>\2\2")
        buf.write("\u01d7\u01d9\3\2\2\2\u01d8\u01c9\3\2\2\2\u01d8\u01cb\3")
        buf.write("\2\2\2\u01d8\u01cf\3\2\2\2\u01d8\u01d0\3\2\2\2\u01d8\u01d1")
        buf.write("\3\2\2\2\u01d8\u01d2\3\2\2\2\u01d8\u01d3\3\2\2\2\u01d9")
        buf.write("\u01de\3\2\2\2\u01da\u01db\f\3\2\2\u01db\u01dd\5n8\2\u01dc")
        buf.write("\u01da\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3\2\2\2")
        buf.write("\u01de\u01df\3\2\2\2\u01dfA\3\2\2\2\u01e0\u01de\3\2\2")
        buf.write("\2\u01e1\u01e3\5D#\2\u01e2\u01e4\7k\2\2\u01e3\u01e2\3")
        buf.write("\2\2\2\u01e3\u01e4\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6")
        buf.write("\7A\2\2\u01e6\u01e7\5F$\2\u01e7\u01e8\7B\2\2\u01e8\u01ed")
        buf.write("\3\2\2\2\u01e9\u01ea\5D#\2\u01ea\u01eb\7k\2\2\u01eb\u01ed")
        buf.write("\3\2\2\2\u01ec\u01e1\3\2\2\2\u01ec\u01e9\3\2\2\2\u01ed")
        buf.write("C\3\2\2\2\u01ee\u01ef\t\20\2\2\u01efE\3\2\2\2\u01f0\u01f2")
        buf.write("\5H%\2\u01f1\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f1")
        buf.write("\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4G\3\2\2\2\u01f5\u01f7")
        buf.write("\5J&\2\u01f6\u01f8\5L\'\2\u01f7\u01f6\3\2\2\2\u01f7\u01f8")
        buf.write("\3\2\2\2\u01f8\u01f9\3\2\2\2\u01f9\u01fa\7Y\2\2\u01fa")
        buf.write("\u01fd\3\2\2\2\u01fb\u01fd\5\u008cG\2\u01fc\u01f5\3\2")
        buf.write("\2\2\u01fc\u01fb\3\2\2\2\u01fdI\3\2\2\2\u01fe\u0201\5")
        buf.write("@!\2\u01ff\u0201\5Z.\2\u0200\u01fe\3\2\2\2\u0200\u01ff")
        buf.write("\3\2\2\2\u0201\u0203\3\2\2\2\u0202\u0204\5J&\2\u0203\u0202")
        buf.write("\3\2\2\2\u0203\u0204\3\2\2\2\u0204K\3\2\2\2\u0205\u020a")
        buf.write("\5N(\2\u0206\u0207\7Z\2\2\u0207\u0209\5N(\2\u0208\u0206")
        buf.write("\3\2\2\2\u0209\u020c\3\2\2\2\u020a\u0208\3\2\2\2\u020a")
        buf.write("\u020b\3\2\2\2\u020bM\3\2\2\2\u020c\u020a\3\2\2\2\u020d")
        buf.write("\u0214\5`\61\2\u020e\u0210\5`\61\2\u020f\u020e\3\2\2\2")
        buf.write("\u020f\u0210\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u0212\7")
        buf.write("X\2\2\u0212\u0214\5\60\31\2\u0213\u020d\3\2\2\2\u0213")
        buf.write("\u020f\3\2\2\2\u0214O\3\2\2\2\u0215\u0217\7\33\2\2\u0216")
        buf.write("\u0218\7k\2\2\u0217\u0216\3\2\2\2\u0217\u0218\3\2\2\2")
        buf.write("\u0218\u0219\3\2\2\2\u0219\u021a\7A\2\2\u021a\u021c\5")
        buf.write("R*\2\u021b\u021d\7Z\2\2\u021c\u021b\3\2\2\2\u021c\u021d")
        buf.write("\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u021f\7B\2\2\u021f")
        buf.write("\u0223\3\2\2\2\u0220\u0221\7\33\2\2\u0221\u0223\7k\2\2")
        buf.write("\u0222\u0215\3\2\2\2\u0222\u0220\3\2\2\2\u0223Q\3\2\2")
        buf.write("\2\u0224\u0229\5T+\2\u0225\u0226\7Z\2\2\u0226\u0228\5")
        buf.write("T+\2\u0227\u0225\3\2\2\2\u0228\u022b\3\2\2\2\u0229\u0227")
        buf.write("\3\2\2\2\u0229\u022a\3\2\2\2\u022aS\3\2\2\2\u022b\u0229")
        buf.write("\3\2\2\2\u022c\u022f\5V,\2\u022d\u022e\7[\2\2\u022e\u0230")
        buf.write("\5\60\31\2\u022f\u022d\3\2\2\2\u022f\u0230\3\2\2\2\u0230")
        buf.write("U\3\2\2\2\u0231\u0232\7k\2\2\u0232W\3\2\2\2\u0233\u0234")
        buf.write("\7\65\2\2\u0234\u0235\7=\2\2\u0235\u0236\5z>\2\u0236\u0237")
        buf.write("\7>\2\2\u0237Y\3\2\2\2\u0238\u0239\t\21\2\2\u0239[\3\2")
        buf.write("\2\2\u023a\u0241\t\22\2\2\u023b\u0241\5f\64\2\u023c\u023d")
        buf.write("\7\f\2\2\u023d\u023e\7=\2\2\u023e\u023f\7k\2\2\u023f\u0241")
        buf.write("\7>\2\2\u0240\u023a\3\2\2\2\u0240\u023b\3\2\2\2\u0240")
        buf.write("\u023c\3\2\2\2\u0241]\3\2\2\2\u0242\u0243\7\63\2\2\u0243")
        buf.write("\u0246\7=\2\2\u0244\u0247\5z>\2\u0245\u0247\5\60\31\2")
        buf.write("\u0246\u0244\3\2\2\2\u0246\u0245\3\2\2\2\u0247\u0248\3")
        buf.write("\2\2\2\u0248\u0249\7>\2\2\u0249_\3\2\2\2\u024a\u024c\5")
        buf.write("n8\2\u024b\u024a\3\2\2\2\u024b\u024c\3\2\2\2\u024c\u024d")
        buf.write("\3\2\2\2\u024d\u0251\5b\62\2\u024e\u0250\5d\63\2\u024f")
        buf.write("\u024e\3\2\2\2\u0250\u0253\3\2\2\2\u0251\u024f\3\2\2\2")
        buf.write("\u0251\u0252\3\2\2\2\u0252a\3\2\2\2\u0253\u0251\3\2\2")
        buf.write("\2\u0254\u0255\b\62\1\2\u0255\u0266\7k\2\2\u0256\u0257")
        buf.write("\7=\2\2\u0257\u0258\5`\61\2\u0258\u0259\7>\2\2\u0259\u0266")
        buf.write("\3\2\2\2\u025a\u025b\7k\2\2\u025b\u025c\7X\2\2\u025c\u0266")
        buf.write("\7m\2\2\u025d\u025f\7=\2\2\u025e\u0260\5@!\2\u025f\u025e")
        buf.write("\3\2\2\2\u025f\u0260\3\2\2\2\u0260\u0261\3\2\2\2\u0261")
        buf.write("\u0262\5n8\2\u0262\u0263\5b\62\2\u0263\u0264\7>\2\2\u0264")
        buf.write("\u0266\3\2\2\2\u0265\u0254\3\2\2\2\u0265\u0256\3\2\2\2")
        buf.write("\u0265\u025a\3\2\2\2\u0265\u025d\3\2\2\2\u0266\u0294\3")
        buf.write("\2\2\2\u0267\u0268\f\n\2\2\u0268\u026a\7?\2\2\u0269\u026b")
        buf.write("\5p9\2\u026a\u0269\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026d")
        buf.write("\3\2\2\2\u026c\u026e\5*\26\2\u026d\u026c\3\2\2\2\u026d")
        buf.write("\u026e\3\2\2\2\u026e\u026f\3\2\2\2\u026f\u0293\7@\2\2")
        buf.write("\u0270\u0271\f\t\2\2\u0271\u0272\7?\2\2\u0272\u0274\7")
        buf.write("*\2\2\u0273\u0275\5p9\2\u0274\u0273\3\2\2\2\u0274\u0275")
        buf.write("\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0277\5*\26\2\u0277")
        buf.write("\u0278\7@\2\2\u0278\u0293\3\2\2\2\u0279\u027a\f\b\2\2")
        buf.write("\u027a\u027b\7?\2\2\u027b\u027c\5p9\2\u027c\u027d\7*\2")
        buf.write("\2\u027d\u027e\5*\26\2\u027e\u027f\7@\2\2\u027f\u0293")
        buf.write("\3\2\2\2\u0280\u0281\f\7\2\2\u0281\u0283\7?\2\2\u0282")
        buf.write("\u0284\5p9\2\u0283\u0282\3\2\2\2\u0283\u0284\3\2\2\2\u0284")
        buf.write("\u0285\3\2\2\2\u0285\u0286\7M\2\2\u0286\u0293\7@\2\2\u0287")
        buf.write("\u0288\f\6\2\2\u0288\u0289\7=\2\2\u0289\u028a\5r:\2\u028a")
        buf.write("\u028b\7>\2\2\u028b\u0293\3\2\2\2\u028c\u028d\f\5\2\2")
        buf.write("\u028d\u028f\7=\2\2\u028e\u0290\5x=\2\u028f\u028e\3\2")
        buf.write("\2\2\u028f\u0290\3\2\2\2\u0290\u0291\3\2\2\2\u0291\u0293")
        buf.write("\7>\2\2\u0292\u0267\3\2\2\2\u0292\u0270\3\2\2\2\u0292")
        buf.write("\u0279\3\2\2\2\u0292\u0280\3\2\2\2\u0292\u0287\3\2\2\2")
        buf.write("\u0292\u028c\3\2\2\2\u0293\u0296\3\2\2\2\u0294\u0292\3")
        buf.write("\2\2\2\u0294\u0295\3\2\2\2\u0295c\3\2\2\2\u0296\u0294")
        buf.write("\3\2\2\2\u0297\u0298\7\r\2\2\u0298\u029a\7=\2\2\u0299")
        buf.write("\u029b\7n\2\2\u029a\u0299\3\2\2\2\u029b\u029c\3\2\2\2")
        buf.write("\u029c\u029a\3\2\2\2\u029c\u029d\3\2\2\2\u029d\u029e\3")
        buf.write("\2\2\2\u029e\u02a1\7>\2\2\u029f\u02a1\5f\64\2\u02a0\u0297")
        buf.write("\3\2\2\2\u02a0\u029f\3\2\2\2\u02a1e\3\2\2\2\u02a2\u02a3")
        buf.write("\7\16\2\2\u02a3\u02a4\7=\2\2\u02a4\u02a5\7=\2\2\u02a5")
        buf.write("\u02a6\5h\65\2\u02a6\u02a7\7>\2\2\u02a7\u02a8\7>\2\2\u02a8")
        buf.write("g\3\2\2\2\u02a9\u02ab\5j\66\2\u02aa\u02a9\3\2\2\2\u02aa")
        buf.write("\u02ab\3\2\2\2\u02ab\u02b2\3\2\2\2\u02ac\u02ae\7Z\2\2")
        buf.write("\u02ad\u02af\5j\66\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3")
        buf.write("\2\2\2\u02af\u02b1\3\2\2\2\u02b0\u02ac\3\2\2\2\u02b1\u02b4")
        buf.write("\3\2\2\2\u02b2\u02b0\3\2\2\2\u02b2\u02b3\3\2\2\2\u02b3")
        buf.write("i\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b5\u02bb\n\23\2\2\u02b6")
        buf.write("\u02b8\7=\2\2\u02b7\u02b9\5\f\7\2\u02b8\u02b7\3\2\2\2")
        buf.write("\u02b8\u02b9\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bc\7")
        buf.write(">\2\2\u02bb\u02b6\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bck\3")
        buf.write("\2\2\2\u02bd\u02c3\n\24\2\2\u02be\u02bf\7=\2\2\u02bf\u02c0")
        buf.write("\5l\67\2\u02c0\u02c1\7>\2\2\u02c1\u02c3\3\2\2\2\u02c2")
        buf.write("\u02bd\3\2\2\2\u02c2\u02be\3\2\2\2\u02c3\u02c6\3\2\2\2")
        buf.write("\u02c4\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5m\3\2\2")
        buf.write("\2\u02c6\u02c4\3\2\2\2\u02c7\u02c9\t\25\2\2\u02c8\u02ca")
        buf.write("\5p9\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca\u02cc")
        buf.write("\3\2\2\2\u02cb\u02c7\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd")
        buf.write("\u02cb\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ceo\3\2\2\2\u02cf")
        buf.write("\u02d1\5Z.\2\u02d0\u02cf\3\2\2\2\u02d1\u02d2\3\2\2\2\u02d2")
        buf.write("\u02d0\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3q\3\2\2\2\u02d4")
        buf.write("\u02d7\5t;\2\u02d5\u02d6\7Z\2\2\u02d6\u02d8\7j\2\2\u02d7")
        buf.write("\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8s\3\2\2\2\u02d9")
        buf.write("\u02de\5v<\2\u02da\u02db\7Z\2\2\u02db\u02dd\5v<\2\u02dc")
        buf.write("\u02da\3\2\2\2\u02dd\u02e0\3\2\2\2\u02de\u02dc\3\2\2\2")
        buf.write("\u02de\u02df\3\2\2\2\u02dfu\3\2\2\2\u02e0\u02de\3\2\2")
        buf.write("\2\u02e1\u02e2\5\64\33\2\u02e2\u02e3\5`\61\2\u02e3\u02e9")
        buf.write("\3\2\2\2\u02e4\u02e6\5\66\34\2\u02e5\u02e7\5|?\2\u02e6")
        buf.write("\u02e5\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\3\2\2\2")
        buf.write("\u02e8\u02e1\3\2\2\2\u02e8\u02e4\3\2\2\2\u02e9w\3\2\2")
        buf.write("\2\u02ea\u02ef\7k\2\2\u02eb\u02ec\7Z\2\2\u02ec\u02ee\7")
        buf.write("k\2\2\u02ed\u02eb\3\2\2\2\u02ee\u02f1\3\2\2\2\u02ef\u02ed")
        buf.write("\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0y\3\2\2\2\u02f1\u02ef")
        buf.write("\3\2\2\2\u02f2\u02f4\5J&\2\u02f3\u02f5\5|?\2\u02f4\u02f3")
        buf.write("\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5{\3\2\2\2\u02f6\u0302")
        buf.write("\5n8\2\u02f7\u02f9\5n8\2\u02f8\u02f7\3\2\2\2\u02f8\u02f9")
        buf.write("\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fe\5~@\2\u02fb\u02fd")
        buf.write("\5d\63\2\u02fc\u02fb\3\2\2\2\u02fd\u0300\3\2\2\2\u02fe")
        buf.write("\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0302\3\2\2\2")
        buf.write("\u0300\u02fe\3\2\2\2\u0301\u02f6\3\2\2\2\u0301\u02f8\3")
        buf.write("\2\2\2\u0302}\3\2\2\2\u0303\u0304\b@\1\2\u0304\u0305\7")
        buf.write("=\2\2\u0305\u0306\5|?\2\u0306\u030a\7>\2\2\u0307\u0309")
        buf.write("\5d\63\2\u0308\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a")
        buf.write("\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u0332\3\2\2\2")
        buf.write("\u030c\u030a\3\2\2\2\u030d\u030f\7?\2\2\u030e\u0310\5")
        buf.write("p9\2\u030f\u030e\3\2\2\2\u030f\u0310\3\2\2\2\u0310\u0312")
        buf.write("\3\2\2\2\u0311\u0313\5*\26\2\u0312\u0311\3\2\2\2\u0312")
        buf.write("\u0313\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u0332\7@\2\2")
        buf.write("\u0315\u0316\7?\2\2\u0316\u0318\7*\2\2\u0317\u0319\5p")
        buf.write("9\2\u0318\u0317\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u031a")
        buf.write("\3\2\2\2\u031a\u031b\5*\26\2\u031b\u031c\7@\2\2\u031c")
        buf.write("\u0332\3\2\2\2\u031d\u031e\7?\2\2\u031e\u031f\5p9\2\u031f")
        buf.write("\u0320\7*\2\2\u0320\u0321\5*\26\2\u0321\u0322\7@\2\2\u0322")
        buf.write("\u0332\3\2\2\2\u0323\u0324\7?\2\2\u0324\u0325\7M\2\2\u0325")
        buf.write("\u0332\7@\2\2\u0326\u0328\7=\2\2\u0327\u0329\5r:\2\u0328")
        buf.write("\u0327\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u032a\3\2\2\2")
        buf.write("\u032a\u032e\7>\2\2\u032b\u032d\5d\63\2\u032c\u032b\3")
        buf.write("\2\2\2\u032d\u0330\3\2\2\2\u032e\u032c\3\2\2\2\u032e\u032f")
        buf.write("\3\2\2\2\u032f\u0332\3\2\2\2\u0330\u032e\3\2\2\2\u0331")
        buf.write("\u0303\3\2\2\2\u0331\u030d\3\2\2\2\u0331\u0315\3\2\2\2")
        buf.write("\u0331\u031d\3\2\2\2\u0331\u0323\3\2\2\2\u0331\u0326\3")
        buf.write("\2\2\2\u0332\u035e\3\2\2\2\u0333\u0334\f\7\2\2\u0334\u0336")
        buf.write("\7?\2\2\u0335\u0337\5p9\2\u0336\u0335\3\2\2\2\u0336\u0337")
        buf.write("\3\2\2\2\u0337\u0339\3\2\2\2\u0338\u033a\5*\26\2\u0339")
        buf.write("\u0338\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u033b\3\2\2\2")
        buf.write("\u033b\u035d\7@\2\2\u033c\u033d\f\6\2\2\u033d\u033e\7")
        buf.write("?\2\2\u033e\u0340\7*\2\2\u033f\u0341\5p9\2\u0340\u033f")
        buf.write("\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0342\3\2\2\2\u0342")
        buf.write("\u0343\5*\26\2\u0343\u0344\7@\2\2\u0344\u035d\3\2\2\2")
        buf.write("\u0345\u0346\f\5\2\2\u0346\u0347\7?\2\2\u0347\u0348\5")
        buf.write("p9\2\u0348\u0349\7*\2\2\u0349\u034a\5*\26\2\u034a\u034b")
        buf.write("\7@\2\2\u034b\u035d\3\2\2\2\u034c\u034d\f\4\2\2\u034d")
        buf.write("\u034e\7?\2\2\u034e\u034f\7M\2\2\u034f\u035d\7@\2\2\u0350")
        buf.write("\u0351\f\3\2\2\u0351\u0353\7=\2\2\u0352\u0354\5r:\2\u0353")
        buf.write("\u0352\3\2\2\2\u0353\u0354\3\2\2\2\u0354\u0355\3\2\2\2")
        buf.write("\u0355\u0359\7>\2\2\u0356\u0358\5d\63\2\u0357\u0356\3")
        buf.write("\2\2\2\u0358\u035b\3\2\2\2\u0359\u0357\3\2\2\2\u0359\u035a")
        buf.write("\3\2\2\2\u035a\u035d\3\2\2\2\u035b\u0359\3\2\2\2\u035c")
        buf.write("\u0333\3\2\2\2\u035c\u033c\3\2\2\2\u035c\u0345\3\2\2\2")
        buf.write("\u035c\u034c\3\2\2\2\u035c\u0350\3\2\2\2\u035d\u0360\3")
        buf.write("\2\2\2\u035e\u035c\3\2\2\2\u035e\u035f\3\2\2\2\u035f\177")
        buf.write("\3\2\2\2\u0360\u035e\3\2\2\2\u0361\u0362\7k\2\2\u0362")
        buf.write("\u0081\3\2\2\2\u0363\u036c\5*\26\2\u0364\u0365\7A\2\2")
        buf.write("\u0365\u0367\5\u0084C\2\u0366\u0368\7Z\2\2\u0367\u0366")
        buf.write("\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u0369\3\2\2\2\u0369")
        buf.write("\u036a\7B\2\2\u036a\u036c\3\2\2\2\u036b\u0363\3\2\2\2")
        buf.write("\u036b\u0364\3\2\2\2\u036c\u0083\3\2\2\2\u036d\u036f\5")
        buf.write("\u0086D\2\u036e\u036d\3\2\2\2\u036e\u036f\3\2\2\2\u036f")
        buf.write("\u0370\3\2\2\2\u0370\u0378\5\u0082B\2\u0371\u0373\7Z\2")
        buf.write("\2\u0372\u0374\5\u0086D\2\u0373\u0372\3\2\2\2\u0373\u0374")
        buf.write("\3\2\2\2\u0374\u0375\3\2\2\2\u0375\u0377\5\u0082B\2\u0376")
        buf.write("\u0371\3\2\2\2\u0377\u037a\3\2\2\2\u0378\u0376\3\2\2\2")
        buf.write("\u0378\u0379\3\2\2\2\u0379\u0085\3\2\2\2\u037a\u0378\3")
        buf.write("\2\2\2\u037b\u037c\5\u0088E\2\u037c\u037d\7[\2\2\u037d")
        buf.write("\u0087\3\2\2\2\u037e\u0380\5\u008aF\2\u037f\u037e\3\2")
        buf.write("\2\2\u0380\u0381\3\2\2\2\u0381\u037f\3\2\2\2\u0381\u0382")
        buf.write("\3\2\2\2\u0382\u0089\3\2\2\2\u0383\u0384\7?\2\2\u0384")
        buf.write("\u0385\5\60\31\2\u0385\u0386\7@\2\2\u0386\u038a\3\2\2")
        buf.write("\2\u0387\u0388\7i\2\2\u0388\u038a\7k\2\2\u0389\u0383\3")
        buf.write("\2\2\2\u0389\u0387\3\2\2\2\u038a\u008b\3\2\2\2\u038b\u038c")
        buf.write("\7;\2\2\u038c\u038d\7=\2\2\u038d\u038e\5\60\31\2\u038e")
        buf.write("\u0390\7Z\2\2\u038f\u0391\7n\2\2\u0390\u038f\3\2\2\2\u0391")
        buf.write("\u0392\3\2\2\2\u0392\u0390\3\2\2\2\u0392\u0393\3\2\2\2")
        buf.write("\u0393\u0394\3\2\2\2\u0394\u0395\7>\2\2\u0395\u0396\7")
        buf.write("Y\2\2\u0396\u008d\3\2\2\2\u0397\u03bd\5\u0090I\2\u0398")
        buf.write("\u03bd\5\u0092J\2\u0399\u03bd\5\u0098M\2\u039a\u03bd\5")
        buf.write("\u009aN\2\u039b\u03bd\5\u009cO\2\u039c\u03bd\5\u00a4S")
        buf.write("\2\u039d\u039e\t\26\2\2\u039e\u039f\t\27\2\2\u039f\u03a8")
        buf.write("\7=\2\2\u03a0\u03a5\5&\24\2\u03a1\u03a2\7Z\2\2\u03a2\u03a4")
        buf.write("\5&\24\2\u03a3\u03a1\3\2\2\2\u03a4\u03a7\3\2\2\2\u03a5")
        buf.write("\u03a3\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a9\3\2\2\2")
        buf.write("\u03a7\u03a5\3\2\2\2\u03a8\u03a0\3\2\2\2\u03a8\u03a9\3")
        buf.write("\2\2\2\u03a9\u03b7\3\2\2\2\u03aa\u03b3\7X\2\2\u03ab\u03b0")
        buf.write("\5&\24\2\u03ac\u03ad\7Z\2\2\u03ad\u03af\5&\24\2\u03ae")
        buf.write("\u03ac\3\2\2\2\u03af\u03b2\3\2\2\2\u03b0\u03ae\3\2\2\2")
        buf.write("\u03b0\u03b1\3\2\2\2\u03b1\u03b4\3\2\2\2\u03b2\u03b0\3")
        buf.write("\2\2\2\u03b3\u03ab\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b6")
        buf.write("\3\2\2\2\u03b5\u03aa\3\2\2\2\u03b6\u03b9\3\2\2\2\u03b7")
        buf.write("\u03b5\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03ba\3\2\2\2")
        buf.write("\u03b9\u03b7\3\2\2\2\u03ba\u03bb\7>\2\2\u03bb\u03bd\7")
        buf.write("Y\2\2\u03bc\u0397\3\2\2\2\u03bc\u0398\3\2\2\2\u03bc\u0399")
        buf.write("\3\2\2\2\u03bc\u039a\3\2\2\2\u03bc\u039b\3\2\2\2\u03bc")
        buf.write("\u039c\3\2\2\2\u03bc\u039d\3\2\2\2\u03bd\u008f\3\2\2\2")
        buf.write("\u03be\u03bf\7k\2\2\u03bf\u03c0\7X\2\2\u03c0\u03ca\5\u008e")
        buf.write("H\2\u03c1\u03c2\7\23\2\2\u03c2\u03c3\5\60\31\2\u03c3\u03c4")
        buf.write("\7X\2\2\u03c4\u03c5\5\u008eH\2\u03c5\u03ca\3\2\2\2\u03c6")
        buf.write("\u03c7\7\27\2\2\u03c7\u03c8\7X\2\2\u03c8\u03ca\5\u008e")
        buf.write("H\2\u03c9\u03be\3\2\2\2\u03c9\u03c1\3\2\2\2\u03c9\u03c6")
        buf.write("\3\2\2\2\u03ca\u0091\3\2\2\2\u03cb\u03cd\7A\2\2\u03cc")
        buf.write("\u03ce\5\u0094K\2\u03cd\u03cc\3\2\2\2\u03cd\u03ce\3\2")
        buf.write("\2\2\u03ce\u03cf\3\2\2\2\u03cf\u03d0\7B\2\2\u03d0\u0093")
        buf.write("\3\2\2\2\u03d1\u03d3\5\u0096L\2\u03d2\u03d1\3\2\2\2\u03d3")
        buf.write("\u03d4\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d4\u03d5\3\2\2\2")
        buf.write("\u03d5\u0095\3\2\2\2\u03d6\u03d9\5\u008eH\2\u03d7\u03d9")
        buf.write("\5\62\32\2\u03d8\u03d6\3\2\2\2\u03d8\u03d7\3\2\2\2\u03d9")
        buf.write("\u0097\3\2\2\2\u03da\u03dc\5.\30\2\u03db\u03da\3\2\2\2")
        buf.write("\u03db\u03dc\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03de\7")
        buf.write("Y\2\2\u03de\u0099\3\2\2\2\u03df\u03e0\7 \2\2\u03e0\u03e1")
        buf.write("\7=\2\2\u03e1\u03e2\5.\30\2\u03e2\u03e3\7>\2\2\u03e3\u03e6")
        buf.write("\5\u008eH\2\u03e4\u03e5\7\32\2\2\u03e5\u03e7\5\u008eH")
        buf.write("\2\u03e6\u03e4\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03ef")
        buf.write("\3\2\2\2\u03e8\u03e9\7,\2\2\u03e9\u03ea\7=\2\2\u03ea\u03eb")
        buf.write("\5.\30\2\u03eb\u03ec\7>\2\2\u03ec\u03ed\5\u008eH\2\u03ed")
        buf.write("\u03ef\3\2\2\2\u03ee\u03df\3\2\2\2\u03ee\u03e8\3\2\2\2")
        buf.write("\u03ef\u009b\3\2\2\2\u03f0\u03f1\7\62\2\2\u03f1\u03f2")
        buf.write("\7=\2\2\u03f2\u03f3\5.\30\2\u03f3\u03f4\7>\2\2\u03f4\u03f5")
        buf.write("\5\u008eH\2\u03f5\u0405\3\2\2\2\u03f6\u03f7\7\30\2\2\u03f7")
        buf.write("\u03f8\5\u008eH\2\u03f8\u03f9\7\62\2\2\u03f9\u03fa\7=")
        buf.write("\2\2\u03fa\u03fb\5.\30\2\u03fb\u03fc\7>\2\2\u03fc\u03fd")
        buf.write("\7Y\2\2\u03fd\u0405\3\2\2\2\u03fe\u03ff\7\36\2\2\u03ff")
        buf.write("\u0400\7=\2\2\u0400\u0401\5\u009eP\2\u0401\u0402\7>\2")
        buf.write("\2\u0402\u0403\5\u008eH\2\u0403\u0405\3\2\2\2\u0404\u03f0")
        buf.write("\3\2\2\2\u0404\u03f6\3\2\2\2\u0404\u03fe\3\2\2\2\u0405")
        buf.write("\u009d\3\2\2\2\u0406\u040b\5\u00a0Q\2\u0407\u0409\5.\30")
        buf.write("\2\u0408\u0407\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u040b")
        buf.write("\3\2\2\2\u040a\u0406\3\2\2\2\u040a\u0408\3\2\2\2\u040b")
        buf.write("\u040c\3\2\2\2\u040c\u040e\7Y\2\2\u040d\u040f\5\u00a2")
        buf.write("R\2\u040e\u040d\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0410")
        buf.write("\3\2\2\2\u0410\u0412\7Y\2\2\u0411\u0413\5\u00a2R\2\u0412")
        buf.write("\u0411\3\2\2\2\u0412\u0413\3\2\2\2\u0413\u009f\3\2\2\2")
        buf.write("\u0414\u0416\5\64\33\2\u0415\u0417\5:\36\2\u0416\u0415")
        buf.write("\3\2\2\2\u0416\u0417\3\2\2\2\u0417\u00a1\3\2\2\2\u0418")
        buf.write("\u041d\5*\26\2\u0419\u041a\7Z\2\2\u041a\u041c\5*\26\2")
        buf.write("\u041b\u0419\3\2\2\2\u041c\u041f\3\2\2\2\u041d\u041b\3")
        buf.write("\2\2\2\u041d\u041e\3\2\2\2\u041e\u00a3\3\2\2\2\u041f\u041d")
        buf.write("\3\2\2\2\u0420\u0421\7\37\2\2\u0421\u042a\7k\2\2\u0422")
        buf.write("\u042a\t\30\2\2\u0423\u0425\7&\2\2\u0424\u0426\5.\30\2")
        buf.write("\u0425\u0424\3\2\2\2\u0425\u0426\3\2\2\2\u0426\u042a\3")
        buf.write("\2\2\2\u0427\u0428\7\37\2\2\u0428\u042a\5\16\b\2\u0429")
        buf.write("\u0420\3\2\2\2\u0429\u0422\3\2\2\2\u0429\u0423\3\2\2\2")
        buf.write("\u0429\u0427\3\2\2\2\u042a\u042b\3\2\2\2\u042b\u042c\7")
        buf.write("Y\2\2\u042c\u00a5\3\2\2\2\u042d\u042f\5\u00a8U\2\u042e")
        buf.write("\u042d\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0430\3\2\2\2")
        buf.write("\u0430\u0431\7\2\2\3\u0431\u00a7\3\2\2\2\u0432\u0434\5")
        buf.write("\u00aaV\2\u0433\u0432\3\2\2\2\u0434\u0435\3\2\2\2\u0435")
        buf.write("\u0433\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u00a9\3\2\2\2")
        buf.write("\u0437\u043b\5\u00acW\2\u0438\u043b\5\62\32\2\u0439\u043b")
        buf.write("\7Y\2\2\u043a\u0437\3\2\2\2\u043a\u0438\3\2\2\2\u043a")
        buf.write("\u0439\3\2\2\2\u043b\u00ab\3\2\2\2\u043c\u043e\5\64\33")
        buf.write("\2\u043d\u043c\3\2\2\2\u043d\u043e\3\2\2\2\u043e\u043f")
        buf.write("\3\2\2\2\u043f\u0441\5`\61\2\u0440\u0442\5\u00aeX\2\u0441")
        buf.write("\u0440\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0443\3\2\2\2")
        buf.write("\u0443\u0444\5\u0092J\2\u0444\u00ad\3\2\2\2\u0445\u0447")
        buf.write("\5\62\32\2\u0446\u0445\3\2\2\2\u0447\u0448\3\2\2\2\u0448")
        buf.write("\u0446\3\2\2\2\u0448\u0449\3\2\2\2\u0449\u00af\3\2\2\2")
        buf.write("\u008a\u00b5\u00bd\u00d1\u00df\u00e4\u00eb\u00f3\u00f7")
        buf.write("\u00ff\u0105\u0107\u010f\u0115\u0123\u0128\u0131\u0138")
        buf.write("\u0140\u0148\u0150\u0158\u0160\u0168\u0170\u0178\u0180")
        buf.write("\u0189\u0191\u019a\u01a7\u01ac\u01b1\u01b8\u01bf\u01c5")
        buf.write("\u01d8\u01de\u01e3\u01ec\u01f3\u01f7\u01fc\u0200\u0203")
        buf.write("\u020a\u020f\u0213\u0217\u021c\u0222\u0229\u022f\u0240")
        buf.write("\u0246\u024b\u0251\u025f\u0265\u026a\u026d\u0274\u0283")
        buf.write("\u028f\u0292\u0294\u029c\u02a0\u02aa\u02ae\u02b2\u02b8")
        buf.write("\u02bb\u02c2\u02c4\u02c9\u02cd\u02d2\u02d7\u02de\u02e6")
        buf.write("\u02e8\u02ef\u02f4\u02f8\u02fe\u0301\u030a\u030f\u0312")
        buf.write("\u0318\u0328\u032e\u0331\u0336\u0339\u0340\u0353\u0359")
        buf.write("\u035c\u035e\u0367\u036b\u036e\u0373\u0378\u0381\u0389")
        buf.write("\u0392\u03a5\u03a8\u03b0\u03b3\u03b7\u03bc\u03c9\u03cd")
        buf.write("\u03d4\u03d8\u03db\u03e6\u03ee\u0404\u0408\u040a\u040e")
        buf.write("\u0412\u0416\u041d\u0425\u0429\u042e\u0435\u043a\u043d")
        buf.write("\u0441\u0448")
        return buf.getvalue()


class C11Parser ( Parser ):

    grammarFileName = "C11.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'__extension__'", "'__builtin_va_arg'", 
                     "'__builtin_offsetof'", "'__m128'", "'__m128d'", "'__m128i'", 
                     "'__typeof__'", "'__inline__'", "'__stdcall'", "'__declspec'", 
                     "'__asm'", "'__attribute__'", "'__asm__'", "'__volatile__'", 
                     "'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'", "'('", "')'", "'['", "']'", "'{'", 
                     "'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", 
                     "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", 
                     "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", 
                     "'?'", "':'", "';'", "','", "'='", "'*='", "'/='", 
                     "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", 
                     "'|='", "'=='", "'!='", "'->'", "'.'", "'...'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<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", 
                      "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", "Identifier", "Constant", 
                      "DigitSequence", "StringLiteral", "ComplexDefine", 
                      "IncludeDirective", "AsmBlock", "LineAfterPreprocessing", 
                      "LineDirective", "PragmaDirective", "Whitespace", 
                      "Newline", "BlockComment", "LineComment" ]

    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
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    Auto=15
    Break=16
    Case=17
    Char=18
    Const=19
    Continue=20
    Default=21
    Do=22
    Double=23
    Else=24
    Enum=25
    Extern=26
    Float=27
    For=28
    Goto=29
    If=30
    Inline=31
    Int=32
    Long=33
    Register=34
    Restrict=35
    Return=36
    Short=37
    Signed=38
    Sizeof=39
    Static=40
    Struct=41
    Switch=42
    Typedef=43
    Union=44
    Unsigned=45
    Void=46
    Volatile=47
    While=48
    Alignas=49
    Alignof=50
    Atomic=51
    Bool=52
    Complex=53
    Generic=54
    Imaginary=55
    Noreturn=56
    StaticAssert=57
    ThreadLocal=58
    LeftParen=59
    RightParen=60
    LeftBracket=61
    RightBracket=62
    LeftBrace=63
    RightBrace=64
    Less=65
    LessEqual=66
    Greater=67
    GreaterEqual=68
    LeftShift=69
    RightShift=70
    Plus=71
    PlusPlus=72
    Minus=73
    MinusMinus=74
    Star=75
    Div=76
    Mod=77
    And=78
    Or=79
    AndAnd=80
    OrOr=81
    Caret=82
    Not=83
    Tilde=84
    Question=85
    Colon=86
    Semi=87
    Comma=88
    Assign=89
    StarAssign=90
    DivAssign=91
    ModAssign=92
    PlusAssign=93
    MinusAssign=94
    LeftShiftAssign=95
    RightShiftAssign=96
    AndAssign=97
    XorAssign=98
    OrAssign=99
    Equal=100
    NotEqual=101
    Arrow=102
    Dot=103
    Ellipsis=104
    Identifier=105
    Constant=106
    DigitSequence=107
    StringLiteral=108
    ComplexDefine=109
    IncludeDirective=110
    AsmBlock=111
    LineAfterPreprocessing=112
    LineDirective=113
    PragmaDirective=114
    Whitespace=115
    Newline=116
    BlockComment=117
    LineComment=118

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




    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def Constant(self):
            return self.getToken(C11Parser.Constant, 0)

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

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

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


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

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


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


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


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

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


        def getRuleIndex(self):
            return C11Parser.RULE_primaryExpression

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




    def primaryExpression(self):

        localctx = C11Parser.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(C11Parser.Identifier)
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 177 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 176
                    self.match(C11Parser.StringLiteral)
                    self.state = 179 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==C11Parser.StringLiteral):
                        break

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 181
                self.match(C11Parser.LeftParen)
                self.state = 182
                self.expression()
                self.state = 183
                self.match(C11Parser.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==C11Parser.T__0:
                    self.state = 186
                    self.match(C11Parser.T__0)


                self.state = 189
                self.match(C11Parser.LeftParen)
                self.state = 190
                self.compoundStatement()
                self.state = 191
                self.match(C11Parser.RightParen)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 193
                self.match(C11Parser.T__1)
                self.state = 194
                self.match(C11Parser.LeftParen)
                self.state = 195
                self.unaryExpression()
                self.state = 196
                self.match(C11Parser.Comma)
                self.state = 197
                self.typeName()
                self.state = 198
                self.match(C11Parser.RightParen)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 200
                self.match(C11Parser.T__2)
                self.state = 201
                self.match(C11Parser.LeftParen)
                self.state = 202
                self.typeName()
                self.state = 203
                self.match(C11Parser.Comma)
                self.state = 204
                self.unaryExpression()
                self.state = 205
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def Generic(self):
            return self.getToken(C11Parser.Generic, 0)

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

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


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

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_genericSelection

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




    def genericSelection(self):

        localctx = C11Parser.GenericSelectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_genericSelection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self.match(C11Parser.Generic)
            self.state = 210
            self.match(C11Parser.LeftParen)
            self.state = 211
            self.assignmentExpression()
            self.state = 212
            self.match(C11Parser.Comma)
            self.state = 213
            self.genericAssocList()
            self.state = 214
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def genericAssociation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.GenericAssociationContext)
            else:
                return self.getTypedRuleContext(C11Parser.GenericAssociationContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_genericAssocList

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




    def genericAssocList(self):

        localctx = C11Parser.GenericAssocListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_genericAssocList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 216
            self.genericAssociation()
            self.state = 221
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 217
                self.match(C11Parser.Comma)
                self.state = 218
                self.genericAssociation()
                self.state = 223
                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 GenericAssociationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Colon(self):
            return self.getToken(C11Parser.Colon, 0)

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


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


        def Default(self):
            return self.getToken(C11Parser.Default, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_genericAssociation

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




    def genericAssociation(self):

        localctx = C11Parser.GenericAssociationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_genericAssociation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 226
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__0, C11Parser.T__3, C11Parser.T__4, C11Parser.T__5, C11Parser.T__6, C11Parser.Char, C11Parser.Const, C11Parser.Double, C11Parser.Enum, C11Parser.Float, C11Parser.Int, C11Parser.Long, C11Parser.Restrict, C11Parser.Short, C11Parser.Signed, C11Parser.Struct, C11Parser.Union, C11Parser.Unsigned, C11Parser.Void, C11Parser.Volatile, C11Parser.Atomic, C11Parser.Bool, C11Parser.Complex, C11Parser.Identifier]:
                self.state = 224
                self.typeName()
                pass
            elif token in [C11Parser.Default]:
                self.state = 225
                self.match(C11Parser.Default)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 228
            self.match(C11Parser.Colon)
            self.state = 229
            self.assignmentExpression()
        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):
        __slots__ = 'parser'

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

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


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

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


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

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

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


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

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

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


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

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

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

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

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

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

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

        def argumentExpressionList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.ArgumentExpressionListContext)
            else:
                return self.getTypedRuleContext(C11Parser.ArgumentExpressionListContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_postfixExpression

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




    def postfixExpression(self):

        localctx = C11Parser.PostfixExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_postfixExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 245
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 231
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.state = 233
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.T__0:
                    self.state = 232
                    self.match(C11Parser.T__0)


                self.state = 235
                self.match(C11Parser.LeftParen)
                self.state = 236
                self.typeName()
                self.state = 237
                self.match(C11Parser.RightParen)
                self.state = 238
                self.match(C11Parser.LeftBrace)
                self.state = 239
                self.initializerList()
                self.state = 241
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.Comma:
                    self.state = 240
                    self.match(C11Parser.Comma)


                self.state = 243
                self.match(C11Parser.RightBrace)
                pass


            self.state = 261
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.LeftBracket - 59)) | (1 << (C11Parser.PlusPlus - 59)) | (1 << (C11Parser.MinusMinus - 59)) | (1 << (C11Parser.Arrow - 59)) | (1 << (C11Parser.Dot - 59)))) != 0):
                self.state = 259
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [C11Parser.LeftBracket]:
                    self.state = 247
                    self.match(C11Parser.LeftBracket)
                    self.state = 248
                    self.expression()
                    self.state = 249
                    self.match(C11Parser.RightBracket)
                    pass
                elif token in [C11Parser.LeftParen]:
                    self.state = 251
                    self.match(C11Parser.LeftParen)
                    self.state = 253
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                        self.state = 252
                        self.argumentExpressionList()


                    self.state = 255
                    self.match(C11Parser.RightParen)
                    pass
                elif token in [C11Parser.Arrow, C11Parser.Dot]:
                    self.state = 256
                    _la = self._input.LA(1)
                    if not(_la==C11Parser.Arrow or _la==C11Parser.Dot):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 257
                    self.match(C11Parser.Identifier)
                    pass
                elif token in [C11Parser.PlusPlus, C11Parser.MinusMinus]:
                    self.state = 258
                    _la = self._input.LA(1)
                    if not(_la==C11Parser.PlusPlus or _la==C11Parser.MinusMinus):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 263
                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 ArgumentExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assignmentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.AssignmentExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_argumentExpressionList

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




    def argumentExpressionList(self):

        localctx = C11Parser.ArgumentExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_argumentExpressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 264
            self.assignmentExpression()
            self.state = 269
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 265
                self.match(C11Parser.Comma)
                self.state = 266
                self.assignmentExpression()
                self.state = 271
                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 UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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

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


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

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

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

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

        def Alignof(self):
            return self.getToken(C11Parser.Alignof, 0)

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_unaryExpression

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




    def unaryExpression(self):

        localctx = C11Parser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_unaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 275
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 272
                    _la = self._input.LA(1)
                    if not(((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (C11Parser.Sizeof - 39)) | (1 << (C11Parser.PlusPlus - 39)) | (1 << (C11Parser.MinusMinus - 39)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 277
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

            self.state = 289
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__0, C11Parser.T__1, C11Parser.T__2, C11Parser.Generic, C11Parser.LeftParen, C11Parser.Identifier, C11Parser.Constant, C11Parser.StringLiteral]:
                self.state = 278
                self.postfixExpression()
                pass
            elif token in [C11Parser.Plus, C11Parser.Minus, C11Parser.Star, C11Parser.And, C11Parser.Not, C11Parser.Tilde]:
                self.state = 279
                self.unaryOperator()
                self.state = 280
                self.castExpression()
                pass
            elif token in [C11Parser.Sizeof, C11Parser.Alignof]:
                self.state = 282
                _la = self._input.LA(1)
                if not(_la==C11Parser.Sizeof or _la==C11Parser.Alignof):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 283
                self.match(C11Parser.LeftParen)
                self.state = 284
                self.typeName()
                self.state = 285
                self.match(C11Parser.RightParen)
                pass
            elif token in [C11Parser.AndAnd]:
                self.state = 287
                self.match(C11Parser.AndAnd)
                self.state = 288
                self.match(C11Parser.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 UnaryOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def Tilde(self):
            return self.getToken(C11Parser.Tilde, 0)

        def Not(self):
            return self.getToken(C11Parser.Not, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_unaryOperator

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




    def unaryOperator(self):

        localctx = C11Parser.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 = 291
            _la = self._input.LA(1)
            if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)))) != 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):
        __slots__ = 'parser'

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

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

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


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

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


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


        def DigitSequence(self):
            return self.getToken(C11Parser.DigitSequence, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_castExpression

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




    def castExpression(self):

        localctx = C11Parser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_castExpression)
        self._la = 0 # Token type
        try:
            self.state = 303
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 294
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.T__0:
                    self.state = 293
                    self.match(C11Parser.T__0)


                self.state = 296
                self.match(C11Parser.LeftParen)
                self.state = 297
                self.typeName()
                self.state = 298
                self.match(C11Parser.RightParen)
                self.state = 299
                self.castExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 301
                self.unaryExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 302
                self.match(C11Parser.DigitSequence)
                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):
        __slots__ = 'parser'

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

        def castExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.CastExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.CastExpressionContext,i)


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

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_multiplicativeExpression

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




    def multiplicativeExpression(self):

        localctx = C11Parser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 305
            self.castExpression()
            self.state = 310
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (C11Parser.Star - 75)) | (1 << (C11Parser.Div - 75)) | (1 << (C11Parser.Mod - 75)))) != 0):
                self.state = 306
                _la = self._input.LA(1)
                if not(((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (C11Parser.Star - 75)) | (1 << (C11Parser.Div - 75)) | (1 << (C11Parser.Mod - 75)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 307
                self.castExpression()
                self.state = 312
                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 AdditiveExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def multiplicativeExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.MultiplicativeExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.MultiplicativeExpressionContext,i)


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

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

        def getRuleIndex(self):
            return C11Parser.RULE_additiveExpression

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




    def additiveExpression(self):

        localctx = C11Parser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 313
            self.multiplicativeExpression()
            self.state = 318
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Plus or _la==C11Parser.Minus:
                self.state = 314
                _la = self._input.LA(1)
                if not(_la==C11Parser.Plus or _la==C11Parser.Minus):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 315
                self.multiplicativeExpression()
                self.state = 320
                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 ShiftExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def additiveExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.AdditiveExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.AdditiveExpressionContext,i)


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

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

        def getRuleIndex(self):
            return C11Parser.RULE_shiftExpression

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




    def shiftExpression(self):

        localctx = C11Parser.ShiftExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_shiftExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 321
            self.additiveExpression()
            self.state = 326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.LeftShift or _la==C11Parser.RightShift:
                self.state = 322
                _la = self._input.LA(1)
                if not(_la==C11Parser.LeftShift or _la==C11Parser.RightShift):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 323
                self.additiveExpression()
                self.state = 328
                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 RelationalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def shiftExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.ShiftExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.ShiftExpressionContext,i)


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

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

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_relationalExpression

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




    def relationalExpression(self):

        localctx = C11Parser.RelationalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 329
            self.shiftExpression()
            self.state = 334
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (C11Parser.Less - 65)) | (1 << (C11Parser.LessEqual - 65)) | (1 << (C11Parser.Greater - 65)) | (1 << (C11Parser.GreaterEqual - 65)))) != 0):
                self.state = 330
                _la = self._input.LA(1)
                if not(((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (C11Parser.Less - 65)) | (1 << (C11Parser.LessEqual - 65)) | (1 << (C11Parser.Greater - 65)) | (1 << (C11Parser.GreaterEqual - 65)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 331
                self.shiftExpression()
                self.state = 336
                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 EqualityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relationalExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.RelationalExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.RelationalExpressionContext,i)


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

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

        def getRuleIndex(self):
            return C11Parser.RULE_equalityExpression

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




    def equalityExpression(self):

        localctx = C11Parser.EqualityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337
            self.relationalExpression()
            self.state = 342
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Equal or _la==C11Parser.NotEqual:
                self.state = 338
                _la = self._input.LA(1)
                if not(_la==C11Parser.Equal or _la==C11Parser.NotEqual):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 339
                self.relationalExpression()
                self.state = 344
                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 AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def equalityExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.EqualityExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.EqualityExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_andExpression

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




    def andExpression(self):

        localctx = C11Parser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_andExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 345
            self.equalityExpression()
            self.state = 350
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.And:
                self.state = 346
                self.match(C11Parser.And)
                self.state = 347
                self.equalityExpression()
                self.state = 352
                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 ExclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def andExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.AndExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.AndExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_exclusiveOrExpression

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




    def exclusiveOrExpression(self):

        localctx = C11Parser.ExclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_exclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 353
            self.andExpression()
            self.state = 358
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Caret:
                self.state = 354
                self.match(C11Parser.Caret)
                self.state = 355
                self.andExpression()
                self.state = 360
                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 InclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def exclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.ExclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.ExclusiveOrExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_inclusiveOrExpression

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




    def inclusiveOrExpression(self):

        localctx = C11Parser.InclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_inclusiveOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.exclusiveOrExpression()
            self.state = 366
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Or:
                self.state = 362
                self.match(C11Parser.Or)
                self.state = 363
                self.exclusiveOrExpression()
                self.state = 368
                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 LogicalAndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def inclusiveOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.InclusiveOrExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.InclusiveOrExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_logicalAndExpression

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




    def logicalAndExpression(self):

        localctx = C11Parser.LogicalAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_logicalAndExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 369
            self.inclusiveOrExpression()
            self.state = 374
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.AndAnd:
                self.state = 370
                self.match(C11Parser.AndAnd)
                self.state = 371
                self.inclusiveOrExpression()
                self.state = 376
                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 LogicalOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def logicalAndExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.LogicalAndExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.LogicalAndExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_logicalOrExpression

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




    def logicalOrExpression(self):

        localctx = C11Parser.LogicalOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_logicalOrExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 377
            self.logicalAndExpression()
            self.state = 382
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.OrOr:
                self.state = 378
                self.match(C11Parser.OrOr)
                self.state = 379
                self.logicalAndExpression()
                self.state = 384
                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 ConditionalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def Question(self):
            return self.getToken(C11Parser.Question, 0)

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


        def Colon(self):
            return self.getToken(C11Parser.Colon, 0)

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


        def getRuleIndex(self):
            return C11Parser.RULE_conditionalExpression

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




    def conditionalExpression(self):

        localctx = C11Parser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 385
            self.logicalOrExpression()
            self.state = 391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.Question:
                self.state = 386
                self.match(C11Parser.Question)
                self.state = 387
                self.expression()
                self.state = 388
                self.match(C11Parser.Colon)
                self.state = 389
                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):
        __slots__ = 'parser'

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

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


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


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


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


        def DigitSequence(self):
            return self.getToken(C11Parser.DigitSequence, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_assignmentExpression

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




    def assignmentExpression(self):

        localctx = C11Parser.AssignmentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_assignmentExpression)
        try:
            self.state = 399
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 393
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 394
                self.unaryExpression()
                self.state = 395
                self.assignmentOperator()
                self.state = 396
                self.assignmentExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 398
                self.match(C11Parser.DigitSequence)
                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):
        __slots__ = 'parser'

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

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

        def StarAssign(self):
            return self.getToken(C11Parser.StarAssign, 0)

        def DivAssign(self):
            return self.getToken(C11Parser.DivAssign, 0)

        def ModAssign(self):
            return self.getToken(C11Parser.ModAssign, 0)

        def PlusAssign(self):
            return self.getToken(C11Parser.PlusAssign, 0)

        def MinusAssign(self):
            return self.getToken(C11Parser.MinusAssign, 0)

        def LeftShiftAssign(self):
            return self.getToken(C11Parser.LeftShiftAssign, 0)

        def RightShiftAssign(self):
            return self.getToken(C11Parser.RightShiftAssign, 0)

        def AndAssign(self):
            return self.getToken(C11Parser.AndAssign, 0)

        def XorAssign(self):
            return self.getToken(C11Parser.XorAssign, 0)

        def OrAssign(self):
            return self.getToken(C11Parser.OrAssign, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_assignmentOperator

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




    def assignmentOperator(self):

        localctx = C11Parser.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 = 401
            _la = self._input.LA(1)
            if not(((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & ((1 << (C11Parser.Assign - 89)) | (1 << (C11Parser.StarAssign - 89)) | (1 << (C11Parser.DivAssign - 89)) | (1 << (C11Parser.ModAssign - 89)) | (1 << (C11Parser.PlusAssign - 89)) | (1 << (C11Parser.MinusAssign - 89)) | (1 << (C11Parser.LeftShiftAssign - 89)) | (1 << (C11Parser.RightShiftAssign - 89)) | (1 << (C11Parser.AndAssign - 89)) | (1 << (C11Parser.XorAssign - 89)) | (1 << (C11Parser.OrAssign - 89)))) != 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):
        __slots__ = 'parser'

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

        def assignmentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.AssignmentExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_expression

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




    def expression(self):

        localctx = C11Parser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 403
            self.assignmentExpression()
            self.state = 408
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 404
                self.match(C11Parser.Comma)
                self.state = 405
                self.assignmentExpression()
                self.state = 410
                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 ConstantExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return C11Parser.RULE_constantExpression

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




    def constantExpression(self):

        localctx = C11Parser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 411
            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):
        __slots__ = 'parser'

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

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


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


        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

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


        def getRuleIndex(self):
            return C11Parser.RULE_declaration

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




    def declaration(self):

        localctx = C11Parser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_declaration)
        try:
            self.state = 421
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 413
                self.declarationSpecifiers()
                self.state = 414
                self.initDeclaratorList()
                self.state = 415
                self.match(C11Parser.Semi)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 417
                self.declarationSpecifiers()
                self.state = 418
                self.match(C11Parser.Semi)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 420
                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):
        __slots__ = 'parser'

        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(C11Parser.DeclarationSpecifierContext)
            else:
                return self.getTypedRuleContext(C11Parser.DeclarationSpecifierContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_declarationSpecifiers

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




    def declarationSpecifiers(self):

        localctx = C11Parser.DeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_declarationSpecifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 423
                    self.declarationSpecifier()

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

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


    class DeclarationSpecifiers2Context(ParserRuleContext):
        __slots__ = 'parser'

        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(C11Parser.DeclarationSpecifierContext)
            else:
                return self.getTypedRuleContext(C11Parser.DeclarationSpecifierContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_declarationSpecifiers2

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




    def declarationSpecifiers2(self):

        localctx = C11Parser.DeclarationSpecifiers2Context(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_declarationSpecifiers2)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 429 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 428
                self.declarationSpecifier()
                self.state = 431 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.ThreadLocal))) != 0) or _la==C11Parser.Identifier):
                    break

        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):
        __slots__ = 'parser'

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

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


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


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


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


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


        def getRuleIndex(self):
            return C11Parser.RULE_declarationSpecifier

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




    def declarationSpecifier(self):

        localctx = C11Parser.DeclarationSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_declarationSpecifier)
        try:
            self.state = 438
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 433
                self.storageClassSpecifier()
                pass

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

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

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

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 437
                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):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_initDeclaratorList

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




    def initDeclaratorList(self):

        localctx = C11Parser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 440
            self.initDeclarator()
            self.state = 445
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 441
                self.match(C11Parser.Comma)
                self.state = 442
                self.initDeclarator()
                self.state = 447
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class InitDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return C11Parser.RULE_initDeclarator

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




    def initDeclarator(self):

        localctx = C11Parser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 448
            self.declarator()
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.Assign:
                self.state = 449
                self.match(C11Parser.Assign)
                self.state = 450
                self.initializer()


        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):
        __slots__ = 'parser'

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

        def Typedef(self):
            return self.getToken(C11Parser.Typedef, 0)

        def Extern(self):
            return self.getToken(C11Parser.Extern, 0)

        def Static(self):
            return self.getToken(C11Parser.Static, 0)

        def ThreadLocal(self):
            return self.getToken(C11Parser.ThreadLocal, 0)

        def Auto(self):
            return self.getToken(C11Parser.Auto, 0)

        def Register(self):
            return self.getToken(C11Parser.Register, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_storageClassSpecifier

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




    def storageClassSpecifier(self):

        localctx = C11Parser.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 = 453
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Auto) | (1 << C11Parser.Extern) | (1 << C11Parser.Register) | (1 << C11Parser.Static) | (1 << C11Parser.Typedef) | (1 << C11Parser.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):
        __slots__ = 'parser'

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

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

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

        def Short(self):
            return self.getToken(C11Parser.Short, 0)

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

        def Long(self):
            return self.getToken(C11Parser.Long, 0)

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

        def Double(self):
            return self.getToken(C11Parser.Double, 0)

        def Signed(self):
            return self.getToken(C11Parser.Signed, 0)

        def Unsigned(self):
            return self.getToken(C11Parser.Unsigned, 0)

        def Bool(self):
            return self.getToken(C11Parser.Bool, 0)

        def Complex(self):
            return self.getToken(C11Parser.Complex, 0)

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

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

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


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


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


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


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


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


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


        def getRuleIndex(self):
            return C11Parser.RULE_typeSpecifier

        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 = C11Parser.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 = 470
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__3, C11Parser.T__4, C11Parser.T__5, C11Parser.Char, C11Parser.Double, C11Parser.Float, C11Parser.Int, C11Parser.Long, C11Parser.Short, C11Parser.Signed, C11Parser.Unsigned, C11Parser.Void, C11Parser.Bool, C11Parser.Complex]:
                self.state = 456
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.Char) | (1 << C11Parser.Double) | (1 << C11Parser.Float) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [C11Parser.T__0]:
                self.state = 457
                self.match(C11Parser.T__0)
                self.state = 458
                self.match(C11Parser.LeftParen)
                self.state = 459
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 460
                self.match(C11Parser.RightParen)
                pass
            elif token in [C11Parser.Atomic]:
                self.state = 461
                self.atomicTypeSpecifier()
                pass
            elif token in [C11Parser.Struct, C11Parser.Union]:
                self.state = 462
                self.structOrUnionSpecifier()
                pass
            elif token in [C11Parser.Enum]:
                self.state = 463
                self.enumSpecifier()
                pass
            elif token in [C11Parser.Identifier]:
                self.state = 464
                self.typedefName()
                pass
            elif token in [C11Parser.T__6]:
                self.state = 465
                self.match(C11Parser.T__6)
                self.state = 466
                self.match(C11Parser.LeftParen)
                self.state = 467
                self.constantExpression()
                self.state = 468
                self.match(C11Parser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 476
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,36,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 = C11Parser.TypeSpecifierContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeSpecifier)
                    self.state = 472
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 473
                    self.pointer() 
                self.state = 478
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,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):
        __slots__ = 'parser'

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

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


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

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


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

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

        def getRuleIndex(self):
            return C11Parser.RULE_structOrUnionSpecifier

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




    def structOrUnionSpecifier(self):

        localctx = C11Parser.StructOrUnionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_structOrUnionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 479
                self.structOrUnion()
                self.state = 481
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.Identifier:
                    self.state = 480
                    self.match(C11Parser.Identifier)


                self.state = 483
                self.match(C11Parser.LeftBrace)
                self.state = 484
                self.structDeclarationList()
                self.state = 485
                self.match(C11Parser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 487
                self.structOrUnion()
                self.state = 488
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def Struct(self):
            return self.getToken(C11Parser.Struct, 0)

        def Union(self):
            return self.getToken(C11Parser.Union, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_structOrUnion

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




    def structOrUnion(self):

        localctx = C11Parser.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 = 492
            _la = self._input.LA(1)
            if not(_la==C11Parser.Struct or _la==C11Parser.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):
        __slots__ = 'parser'

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

        def structDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.StructDeclarationContext)
            else:
                return self.getTypedRuleContext(C11Parser.StructDeclarationContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_structDeclarationList

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




    def structDeclarationList(self):

        localctx = C11Parser.StructDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_structDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 495 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 494
                self.structDeclaration()
                self.state = 497 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Float) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Struct) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.StaticAssert))) != 0) or _la==C11Parser.Identifier):
                    break

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


    class StructDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_structDeclaration

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




    def structDeclaration(self):

        localctx = C11Parser.StructDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_structDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 506
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__0, C11Parser.T__3, C11Parser.T__4, C11Parser.T__5, C11Parser.T__6, C11Parser.Char, C11Parser.Const, C11Parser.Double, C11Parser.Enum, C11Parser.Float, C11Parser.Int, C11Parser.Long, C11Parser.Restrict, C11Parser.Short, C11Parser.Signed, C11Parser.Struct, C11Parser.Union, C11Parser.Unsigned, C11Parser.Void, C11Parser.Volatile, C11Parser.Atomic, C11Parser.Bool, C11Parser.Complex, C11Parser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 499
                self.specifierQualifierList()
                self.state = 501
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.Star - 59)) | (1 << (C11Parser.Caret - 59)) | (1 << (C11Parser.Colon - 59)) | (1 << (C11Parser.Identifier - 59)))) != 0):
                    self.state = 500
                    self.structDeclaratorList()


                self.state = 503
                self.match(C11Parser.Semi)
                pass
            elif token in [C11Parser.StaticAssert]:
                self.enterOuterAlt(localctx, 2)
                self.state = 505
                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):
        __slots__ = 'parser'

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

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


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


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


        def getRuleIndex(self):
            return C11Parser.RULE_specifierQualifierList

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




    def specifierQualifierList(self):

        localctx = C11Parser.SpecifierQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_specifierQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 510
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 508
                self.typeSpecifier(0)
                pass

            elif la_ == 2:
                self.state = 509
                self.typeQualifier()
                pass


            self.state = 513
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 512
                self.specifierQualifierList()


        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):
        __slots__ = 'parser'

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

        def structDeclarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.StructDeclaratorContext)
            else:
                return self.getTypedRuleContext(C11Parser.StructDeclaratorContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_structDeclaratorList

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




    def structDeclaratorList(self):

        localctx = C11Parser.StructDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_structDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 515
            self.structDeclarator()
            self.state = 520
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 516
                self.match(C11Parser.Comma)
                self.state = 517
                self.structDeclarator()
                self.state = 522
                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 StructDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def Colon(self):
            return self.getToken(C11Parser.Colon, 0)

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


        def getRuleIndex(self):
            return C11Parser.RULE_structDeclarator

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




    def structDeclarator(self):

        localctx = C11Parser.StructDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_structDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 529
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 523
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 525
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.Star - 59)) | (1 << (C11Parser.Caret - 59)) | (1 << (C11Parser.Identifier - 59)))) != 0):
                    self.state = 524
                    self.declarator()


                self.state = 527
                self.match(C11Parser.Colon)
                self.state = 528
                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):
        __slots__ = 'parser'

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

        def Enum(self):
            return self.getToken(C11Parser.Enum, 0)

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

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


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

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_enumSpecifier

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




    def enumSpecifier(self):

        localctx = C11Parser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 531
                self.match(C11Parser.Enum)
                self.state = 533
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.Identifier:
                    self.state = 532
                    self.match(C11Parser.Identifier)


                self.state = 535
                self.match(C11Parser.LeftBrace)
                self.state = 536
                self.enumeratorList()
                self.state = 538
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.Comma:
                    self.state = 537
                    self.match(C11Parser.Comma)


                self.state = 540
                self.match(C11Parser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 542
                self.match(C11Parser.Enum)
                self.state = 543
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def enumerator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.EnumeratorContext)
            else:
                return self.getTypedRuleContext(C11Parser.EnumeratorContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_enumeratorList

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




    def enumeratorList(self):

        localctx = C11Parser.EnumeratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_enumeratorList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.enumerator()
            self.state = 551
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,50,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 547
                    self.match(C11Parser.Comma)
                    self.state = 548
                    self.enumerator() 
                self.state = 553
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,50,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 EnumeratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return C11Parser.RULE_enumerator

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




    def enumerator(self):

        localctx = C11Parser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_enumerator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 554
            self.enumerationConstant()
            self.state = 557
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.Assign:
                self.state = 555
                self.match(C11Parser.Assign)
                self.state = 556
                self.constantExpression()


        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):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_enumerationConstant

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




    def enumerationConstant(self):

        localctx = C11Parser.EnumerationConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_enumerationConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 559
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def Atomic(self):
            return self.getToken(C11Parser.Atomic, 0)

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

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_atomicTypeSpecifier

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




    def atomicTypeSpecifier(self):

        localctx = C11Parser.AtomicTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_atomicTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 561
            self.match(C11Parser.Atomic)
            self.state = 562
            self.match(C11Parser.LeftParen)
            self.state = 563
            self.typeName()
            self.state = 564
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def Const(self):
            return self.getToken(C11Parser.Const, 0)

        def Restrict(self):
            return self.getToken(C11Parser.Restrict, 0)

        def Volatile(self):
            return self.getToken(C11Parser.Volatile, 0)

        def Atomic(self):
            return self.getToken(C11Parser.Atomic, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_typeQualifier

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




    def typeQualifier(self):

        localctx = C11Parser.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 = 566
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.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):
        __slots__ = 'parser'

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

        def Inline(self):
            return self.getToken(C11Parser.Inline, 0)

        def Noreturn(self):
            return self.getToken(C11Parser.Noreturn, 0)

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


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

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_functionSpecifier

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




    def functionSpecifier(self):

        localctx = C11Parser.FunctionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_functionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 574
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__7, C11Parser.T__8, C11Parser.Inline, C11Parser.Noreturn]:
                self.enterOuterAlt(localctx, 1)
                self.state = 568
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.Inline) | (1 << C11Parser.Noreturn))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [C11Parser.T__11]:
                self.enterOuterAlt(localctx, 2)
                self.state = 569
                self.gccAttributeSpecifier()
                pass
            elif token in [C11Parser.T__9]:
                self.enterOuterAlt(localctx, 3)
                self.state = 570
                self.match(C11Parser.T__9)
                self.state = 571
                self.match(C11Parser.LeftParen)
                self.state = 572
                self.match(C11Parser.Identifier)
                self.state = 573
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def Alignas(self):
            return self.getToken(C11Parser.Alignas, 0)

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

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

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_alignmentSpecifier

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




    def alignmentSpecifier(self):

        localctx = C11Parser.AlignmentSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_alignmentSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(C11Parser.Alignas)
            self.state = 577
            self.match(C11Parser.LeftParen)
            self.state = 580
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.state = 578
                self.typeName()
                pass

            elif la_ == 2:
                self.state = 579
                self.constantExpression()
                pass


            self.state = 582
            self.match(C11Parser.RightParen)
        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):
        __slots__ = 'parser'

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

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


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


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


        def getRuleIndex(self):
            return C11Parser.RULE_declarator

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




    def declarator(self):

        localctx = C11Parser.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 = 585
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.Star or _la==C11Parser.Caret:
                self.state = 584
                self.pointer()


            self.state = 587
            self.directDeclarator(0)
            self.state = 591
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,55,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 588
                    self.gccDeclaratorExtension() 
                self.state = 593
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,55,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):
        __slots__ = 'parser'

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

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

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

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


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

        def Colon(self):
            return self.getToken(C11Parser.Colon, 0)

        def DigitSequence(self):
            return self.getToken(C11Parser.DigitSequence, 0)

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


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


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


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

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

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


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


        def Static(self):
            return self.getToken(C11Parser.Static, 0)

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

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_directDeclarator

        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 = C11Parser.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 = 611
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 595
                self.match(C11Parser.Identifier)
                pass

            elif la_ == 2:
                self.state = 596
                self.match(C11Parser.LeftParen)
                self.state = 597
                self.declarator()
                self.state = 598
                self.match(C11Parser.RightParen)
                pass

            elif la_ == 3:
                self.state = 600
                self.match(C11Parser.Identifier)
                self.state = 601
                self.match(C11Parser.Colon)
                self.state = 602
                self.match(C11Parser.DigitSequence)
                pass

            elif la_ == 4:
                self.state = 603
                self.match(C11Parser.LeftParen)
                self.state = 605
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.Char) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Float) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Struct) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex))) != 0) or _la==C11Parser.Identifier:
                    self.state = 604
                    self.typeSpecifier(0)


                self.state = 607
                self.pointer()
                self.state = 608
                self.directDeclarator(0)
                self.state = 609
                self.match(C11Parser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 658
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,64,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 = 656
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
                    if la_ == 1:
                        localctx = C11Parser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 613
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 614
                        self.match(C11Parser.LeftBracket)
                        self.state = 616
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                            self.state = 615
                            self.typeQualifierList()


                        self.state = 619
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                            self.state = 618
                            self.assignmentExpression()


                        self.state = 621
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = C11Parser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 622
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 623
                        self.match(C11Parser.LeftBracket)
                        self.state = 624
                        self.match(C11Parser.Static)
                        self.state = 626
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                            self.state = 625
                            self.typeQualifierList()


                        self.state = 628
                        self.assignmentExpression()
                        self.state = 629
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 3:
                        localctx = C11Parser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 631
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 632
                        self.match(C11Parser.LeftBracket)
                        self.state = 633
                        self.typeQualifierList()
                        self.state = 634
                        self.match(C11Parser.Static)
                        self.state = 635
                        self.assignmentExpression()
                        self.state = 636
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 4:
                        localctx = C11Parser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 638
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 639
                        self.match(C11Parser.LeftBracket)
                        self.state = 641
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                            self.state = 640
                            self.typeQualifierList()


                        self.state = 643
                        self.match(C11Parser.Star)
                        self.state = 644
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 5:
                        localctx = C11Parser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 645
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 646
                        self.match(C11Parser.LeftParen)
                        self.state = 647
                        self.parameterTypeList()
                        self.state = 648
                        self.match(C11Parser.RightParen)
                        pass

                    elif la_ == 6:
                        localctx = C11Parser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 650
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 651
                        self.match(C11Parser.LeftParen)
                        self.state = 653
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==C11Parser.Identifier:
                            self.state = 652
                            self.identifierList()


                        self.state = 655
                        self.match(C11Parser.RightParen)
                        pass

             
                self.state = 660
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,64,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):
        __slots__ = 'parser'

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

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

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

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

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


        def getRuleIndex(self):
            return C11Parser.RULE_gccDeclaratorExtension

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




    def gccDeclaratorExtension(self):

        localctx = C11Parser.GccDeclaratorExtensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_gccDeclaratorExtension)
        self._la = 0 # Token type
        try:
            self.state = 670
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__10]:
                self.enterOuterAlt(localctx, 1)
                self.state = 661
                self.match(C11Parser.T__10)
                self.state = 662
                self.match(C11Parser.LeftParen)
                self.state = 664 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 663
                    self.match(C11Parser.StringLiteral)
                    self.state = 666 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==C11Parser.StringLiteral):
                        break

                self.state = 668
                self.match(C11Parser.RightParen)
                pass
            elif token in [C11Parser.T__11]:
                self.enterOuterAlt(localctx, 2)
                self.state = 669
                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):
        __slots__ = 'parser'

        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(C11Parser.LeftParen)
            else:
                return self.getToken(C11Parser.LeftParen, i)

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_gccAttributeSpecifier

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




    def gccAttributeSpecifier(self):

        localctx = C11Parser.GccAttributeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_gccAttributeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 672
            self.match(C11Parser.T__11)
            self.state = 673
            self.match(C11Parser.LeftParen)
            self.state = 674
            self.match(C11Parser.LeftParen)
            self.state = 675
            self.gccAttributeList()
            self.state = 676
            self.match(C11Parser.RightParen)
            self.state = 677
            self.match(C11Parser.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):
        __slots__ = 'parser'

        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(C11Parser.GccAttributeContext)
            else:
                return self.getTypedRuleContext(C11Parser.GccAttributeContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_gccAttributeList

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




    def gccAttributeList(self):

        localctx = C11Parser.GccAttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_gccAttributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 680
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__10) | (1 << C11Parser.T__11) | (1 << C11Parser.T__12) | (1 << C11Parser.T__13) | (1 << C11Parser.Auto) | (1 << C11Parser.Break) | (1 << C11Parser.Case) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Continue) | (1 << C11Parser.Default) | (1 << C11Parser.Do) | (1 << C11Parser.Double) | (1 << C11Parser.Else) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.For) | (1 << C11Parser.Goto) | (1 << C11Parser.If) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Return) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Switch) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.While) | (1 << C11Parser.Alignas) | (1 << C11Parser.Alignof) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Generic) | (1 << C11Parser.Imaginary) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftBracket) | (1 << C11Parser.RightBracket) | (1 << C11Parser.LeftBrace))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (C11Parser.RightBrace - 64)) | (1 << (C11Parser.Less - 64)) | (1 << (C11Parser.LessEqual - 64)) | (1 << (C11Parser.Greater - 64)) | (1 << (C11Parser.GreaterEqual - 64)) | (1 << (C11Parser.LeftShift - 64)) | (1 << (C11Parser.RightShift - 64)) | (1 << (C11Parser.Plus - 64)) | (1 << (C11Parser.PlusPlus - 64)) | (1 << (C11Parser.Minus - 64)) | (1 << (C11Parser.MinusMinus - 64)) | (1 << (C11Parser.Star - 64)) | (1 << (C11Parser.Div - 64)) | (1 << (C11Parser.Mod - 64)) | (1 << (C11Parser.And - 64)) | (1 << (C11Parser.Or - 64)) | (1 << (C11Parser.AndAnd - 64)) | (1 << (C11Parser.OrOr - 64)) | (1 << (C11Parser.Caret - 64)) | (1 << (C11Parser.Not - 64)) | (1 << (C11Parser.Tilde - 64)) | (1 << (C11Parser.Question - 64)) | (1 << (C11Parser.Colon - 64)) | (1 << (C11Parser.Semi - 64)) | (1 << (C11Parser.Assign - 64)) | (1 << (C11Parser.StarAssign - 64)) | (1 << (C11Parser.DivAssign - 64)) | (1 << (C11Parser.ModAssign - 64)) | (1 << (C11Parser.PlusAssign - 64)) | (1 << (C11Parser.MinusAssign - 64)) | (1 << (C11Parser.LeftShiftAssign - 64)) | (1 << (C11Parser.RightShiftAssign - 64)) | (1 << (C11Parser.AndAssign - 64)) | (1 << (C11Parser.XorAssign - 64)) | (1 << (C11Parser.OrAssign - 64)) | (1 << (C11Parser.Equal - 64)) | (1 << (C11Parser.NotEqual - 64)) | (1 << (C11Parser.Arrow - 64)) | (1 << (C11Parser.Dot - 64)) | (1 << (C11Parser.Ellipsis - 64)) | (1 << (C11Parser.Identifier - 64)) | (1 << (C11Parser.Constant - 64)) | (1 << (C11Parser.DigitSequence - 64)) | (1 << (C11Parser.StringLiteral - 64)) | (1 << (C11Parser.ComplexDefine - 64)) | (1 << (C11Parser.IncludeDirective - 64)) | (1 << (C11Parser.AsmBlock - 64)) | (1 << (C11Parser.LineAfterPreprocessing - 64)) | (1 << (C11Parser.LineDirective - 64)) | (1 << (C11Parser.PragmaDirective - 64)) | (1 << (C11Parser.Whitespace - 64)) | (1 << (C11Parser.Newline - 64)) | (1 << (C11Parser.BlockComment - 64)) | (1 << (C11Parser.LineComment - 64)))) != 0):
                self.state = 679
                self.gccAttribute()


            self.state = 688
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 682
                self.match(C11Parser.Comma)
                self.state = 684
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__10) | (1 << C11Parser.T__11) | (1 << C11Parser.T__12) | (1 << C11Parser.T__13) | (1 << C11Parser.Auto) | (1 << C11Parser.Break) | (1 << C11Parser.Case) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Continue) | (1 << C11Parser.Default) | (1 << C11Parser.Do) | (1 << C11Parser.Double) | (1 << C11Parser.Else) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.For) | (1 << C11Parser.Goto) | (1 << C11Parser.If) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Return) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Switch) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.While) | (1 << C11Parser.Alignas) | (1 << C11Parser.Alignof) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Generic) | (1 << C11Parser.Imaginary) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftBracket) | (1 << C11Parser.RightBracket) | (1 << C11Parser.LeftBrace))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (C11Parser.RightBrace - 64)) | (1 << (C11Parser.Less - 64)) | (1 << (C11Parser.LessEqual - 64)) | (1 << (C11Parser.Greater - 64)) | (1 << (C11Parser.GreaterEqual - 64)) | (1 << (C11Parser.LeftShift - 64)) | (1 << (C11Parser.RightShift - 64)) | (1 << (C11Parser.Plus - 64)) | (1 << (C11Parser.PlusPlus - 64)) | (1 << (C11Parser.Minus - 64)) | (1 << (C11Parser.MinusMinus - 64)) | (1 << (C11Parser.Star - 64)) | (1 << (C11Parser.Div - 64)) | (1 << (C11Parser.Mod - 64)) | (1 << (C11Parser.And - 64)) | (1 << (C11Parser.Or - 64)) | (1 << (C11Parser.AndAnd - 64)) | (1 << (C11Parser.OrOr - 64)) | (1 << (C11Parser.Caret - 64)) | (1 << (C11Parser.Not - 64)) | (1 << (C11Parser.Tilde - 64)) | (1 << (C11Parser.Question - 64)) | (1 << (C11Parser.Colon - 64)) | (1 << (C11Parser.Semi - 64)) | (1 << (C11Parser.Assign - 64)) | (1 << (C11Parser.StarAssign - 64)) | (1 << (C11Parser.DivAssign - 64)) | (1 << (C11Parser.ModAssign - 64)) | (1 << (C11Parser.PlusAssign - 64)) | (1 << (C11Parser.MinusAssign - 64)) | (1 << (C11Parser.LeftShiftAssign - 64)) | (1 << (C11Parser.RightShiftAssign - 64)) | (1 << (C11Parser.AndAssign - 64)) | (1 << (C11Parser.XorAssign - 64)) | (1 << (C11Parser.OrAssign - 64)) | (1 << (C11Parser.Equal - 64)) | (1 << (C11Parser.NotEqual - 64)) | (1 << (C11Parser.Arrow - 64)) | (1 << (C11Parser.Dot - 64)) | (1 << (C11Parser.Ellipsis - 64)) | (1 << (C11Parser.Identifier - 64)) | (1 << (C11Parser.Constant - 64)) | (1 << (C11Parser.DigitSequence - 64)) | (1 << (C11Parser.StringLiteral - 64)) | (1 << (C11Parser.ComplexDefine - 64)) | (1 << (C11Parser.IncludeDirective - 64)) | (1 << (C11Parser.AsmBlock - 64)) | (1 << (C11Parser.LineAfterPreprocessing - 64)) | (1 << (C11Parser.LineDirective - 64)) | (1 << (C11Parser.PragmaDirective - 64)) | (1 << (C11Parser.Whitespace - 64)) | (1 << (C11Parser.Newline - 64)) | (1 << (C11Parser.BlockComment - 64)) | (1 << (C11Parser.LineComment - 64)))) != 0):
                    self.state = 683
                    self.gccAttribute()


                self.state = 690
                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 GccAttributeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


        def getRuleIndex(self):
            return C11Parser.RULE_gccAttribute

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




    def gccAttribute(self):

        localctx = C11Parser.GccAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_gccAttribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 691
            _la = self._input.LA(1)
            if _la <= 0 or ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.RightParen - 59)) | (1 << (C11Parser.Comma - 59)))) != 0):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 697
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.LeftParen:
                self.state = 692
                self.match(C11Parser.LeftParen)
                self.state = 694
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                    self.state = 693
                    self.argumentExpressionList()


                self.state = 696
                self.match(C11Parser.RightParen)


        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):
        __slots__ = 'parser'

        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(C11Parser.LeftParen)
            else:
                return self.getToken(C11Parser.LeftParen, i)

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_nestedParenthesesBlock

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




    def nestedParenthesesBlock(self):

        localctx = C11Parser.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 = 706
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__10) | (1 << C11Parser.T__11) | (1 << C11Parser.T__12) | (1 << C11Parser.T__13) | (1 << C11Parser.Auto) | (1 << C11Parser.Break) | (1 << C11Parser.Case) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Continue) | (1 << C11Parser.Default) | (1 << C11Parser.Do) | (1 << C11Parser.Double) | (1 << C11Parser.Else) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.For) | (1 << C11Parser.Goto) | (1 << C11Parser.If) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Return) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Switch) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.While) | (1 << C11Parser.Alignas) | (1 << C11Parser.Alignof) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Generic) | (1 << C11Parser.Imaginary) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftParen) | (1 << C11Parser.LeftBracket) | (1 << C11Parser.RightBracket) | (1 << C11Parser.LeftBrace))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (C11Parser.RightBrace - 64)) | (1 << (C11Parser.Less - 64)) | (1 << (C11Parser.LessEqual - 64)) | (1 << (C11Parser.Greater - 64)) | (1 << (C11Parser.GreaterEqual - 64)) | (1 << (C11Parser.LeftShift - 64)) | (1 << (C11Parser.RightShift - 64)) | (1 << (C11Parser.Plus - 64)) | (1 << (C11Parser.PlusPlus - 64)) | (1 << (C11Parser.Minus - 64)) | (1 << (C11Parser.MinusMinus - 64)) | (1 << (C11Parser.Star - 64)) | (1 << (C11Parser.Div - 64)) | (1 << (C11Parser.Mod - 64)) | (1 << (C11Parser.And - 64)) | (1 << (C11Parser.Or - 64)) | (1 << (C11Parser.AndAnd - 64)) | (1 << (C11Parser.OrOr - 64)) | (1 << (C11Parser.Caret - 64)) | (1 << (C11Parser.Not - 64)) | (1 << (C11Parser.Tilde - 64)) | (1 << (C11Parser.Question - 64)) | (1 << (C11Parser.Colon - 64)) | (1 << (C11Parser.Semi - 64)) | (1 << (C11Parser.Comma - 64)) | (1 << (C11Parser.Assign - 64)) | (1 << (C11Parser.StarAssign - 64)) | (1 << (C11Parser.DivAssign - 64)) | (1 << (C11Parser.ModAssign - 64)) | (1 << (C11Parser.PlusAssign - 64)) | (1 << (C11Parser.MinusAssign - 64)) | (1 << (C11Parser.LeftShiftAssign - 64)) | (1 << (C11Parser.RightShiftAssign - 64)) | (1 << (C11Parser.AndAssign - 64)) | (1 << (C11Parser.XorAssign - 64)) | (1 << (C11Parser.OrAssign - 64)) | (1 << (C11Parser.Equal - 64)) | (1 << (C11Parser.NotEqual - 64)) | (1 << (C11Parser.Arrow - 64)) | (1 << (C11Parser.Dot - 64)) | (1 << (C11Parser.Ellipsis - 64)) | (1 << (C11Parser.Identifier - 64)) | (1 << (C11Parser.Constant - 64)) | (1 << (C11Parser.DigitSequence - 64)) | (1 << (C11Parser.StringLiteral - 64)) | (1 << (C11Parser.ComplexDefine - 64)) | (1 << (C11Parser.IncludeDirective - 64)) | (1 << (C11Parser.AsmBlock - 64)) | (1 << (C11Parser.LineAfterPreprocessing - 64)) | (1 << (C11Parser.LineDirective - 64)) | (1 << (C11Parser.PragmaDirective - 64)) | (1 << (C11Parser.Whitespace - 64)) | (1 << (C11Parser.Newline - 64)) | (1 << (C11Parser.BlockComment - 64)) | (1 << (C11Parser.LineComment - 64)))) != 0):
                self.state = 704
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [C11Parser.T__0, C11Parser.T__1, C11Parser.T__2, C11Parser.T__3, C11Parser.T__4, C11Parser.T__5, C11Parser.T__6, C11Parser.T__7, C11Parser.T__8, C11Parser.T__9, C11Parser.T__10, C11Parser.T__11, C11Parser.T__12, C11Parser.T__13, C11Parser.Auto, C11Parser.Break, C11Parser.Case, C11Parser.Char, C11Parser.Const, C11Parser.Continue, C11Parser.Default, C11Parser.Do, C11Parser.Double, C11Parser.Else, C11Parser.Enum, C11Parser.Extern, C11Parser.Float, C11Parser.For, C11Parser.Goto, C11Parser.If, C11Parser.Inline, C11Parser.Int, C11Parser.Long, C11Parser.Register, C11Parser.Restrict, C11Parser.Return, C11Parser.Short, C11Parser.Signed, C11Parser.Sizeof, C11Parser.Static, C11Parser.Struct, C11Parser.Switch, C11Parser.Typedef, C11Parser.Union, C11Parser.Unsigned, C11Parser.Void, C11Parser.Volatile, C11Parser.While, C11Parser.Alignas, C11Parser.Alignof, C11Parser.Atomic, C11Parser.Bool, C11Parser.Complex, C11Parser.Generic, C11Parser.Imaginary, C11Parser.Noreturn, C11Parser.StaticAssert, C11Parser.ThreadLocal, C11Parser.LeftBracket, C11Parser.RightBracket, C11Parser.LeftBrace, C11Parser.RightBrace, C11Parser.Less, C11Parser.LessEqual, C11Parser.Greater, C11Parser.GreaterEqual, C11Parser.LeftShift, C11Parser.RightShift, C11Parser.Plus, C11Parser.PlusPlus, C11Parser.Minus, C11Parser.MinusMinus, C11Parser.Star, C11Parser.Div, C11Parser.Mod, C11Parser.And, C11Parser.Or, C11Parser.AndAnd, C11Parser.OrOr, C11Parser.Caret, C11Parser.Not, C11Parser.Tilde, C11Parser.Question, C11Parser.Colon, C11Parser.Semi, C11Parser.Comma, C11Parser.Assign, C11Parser.StarAssign, C11Parser.DivAssign, C11Parser.ModAssign, C11Parser.PlusAssign, C11Parser.MinusAssign, C11Parser.LeftShiftAssign, C11Parser.RightShiftAssign, C11Parser.AndAssign, C11Parser.XorAssign, C11Parser.OrAssign, C11Parser.Equal, C11Parser.NotEqual, C11Parser.Arrow, C11Parser.Dot, C11Parser.Ellipsis, C11Parser.Identifier, C11Parser.Constant, C11Parser.DigitSequence, C11Parser.StringLiteral, C11Parser.ComplexDefine, C11Parser.IncludeDirective, C11Parser.AsmBlock, C11Parser.LineAfterPreprocessing, C11Parser.LineDirective, C11Parser.PragmaDirective, C11Parser.Whitespace, C11Parser.Newline, C11Parser.BlockComment, C11Parser.LineComment]:
                    self.state = 699
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==C11Parser.LeftParen or _la==C11Parser.RightParen:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    pass
                elif token in [C11Parser.LeftParen]:
                    self.state = 700
                    self.match(C11Parser.LeftParen)
                    self.state = 701
                    self.nestedParenthesesBlock()
                    self.state = 702
                    self.match(C11Parser.RightParen)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 708
                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):
        __slots__ = 'parser'

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

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

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

        def typeQualifierList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.TypeQualifierListContext)
            else:
                return self.getTypedRuleContext(C11Parser.TypeQualifierListContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_pointer

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




    def pointer(self):

        localctx = C11Parser.PointerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_pointer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 713 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 709
                    _la = self._input.LA(1)
                    if not(_la==C11Parser.Star or _la==C11Parser.Caret):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 711
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
                    if la_ == 1:
                        self.state = 710
                        self.typeQualifierList()



                else:
                    raise NoViableAltException(self)
                self.state = 715 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,75,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 TypeQualifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def typeQualifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.TypeQualifierContext)
            else:
                return self.getTypedRuleContext(C11Parser.TypeQualifierContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_typeQualifierList

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




    def typeQualifierList(self):

        localctx = C11Parser.TypeQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_typeQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 718 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 717
                    self.typeQualifier()

                else:
                    raise NoViableAltException(self)
                self.state = 720 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,76,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 ParameterTypeListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def Ellipsis(self):
            return self.getToken(C11Parser.Ellipsis, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_parameterTypeList

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




    def parameterTypeList(self):

        localctx = C11Parser.ParameterTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_parameterTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 722
            self.parameterList()
            self.state = 725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.Comma:
                self.state = 723
                self.match(C11Parser.Comma)
                self.state = 724
                self.match(C11Parser.Ellipsis)


        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):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_parameterList

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




    def parameterList(self):

        localctx = C11Parser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_parameterList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 727
            self.parameterDeclaration()
            self.state = 732
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 728
                    self.match(C11Parser.Comma)
                    self.state = 729
                    self.parameterDeclaration() 
                self.state = 734
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,78,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 ParameterDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


        def getRuleIndex(self):
            return C11Parser.RULE_parameterDeclaration

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




    def parameterDeclaration(self):

        localctx = C11Parser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_parameterDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 742
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 735
                self.declarationSpecifiers()
                self.state = 736
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 738
                self.declarationSpecifiers2()
                self.state = 740
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.LeftBracket - 59)) | (1 << (C11Parser.Star - 59)) | (1 << (C11Parser.Caret - 59)))) != 0):
                    self.state = 739
                    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):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_identifierList

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




    def identifierList(self):

        localctx = C11Parser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.match(C11Parser.Identifier)
            self.state = 749
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 745
                self.match(C11Parser.Comma)
                self.state = 746
                self.match(C11Parser.Identifier)
                self.state = 751
                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 TypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_typeName

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




    def typeName(self):

        localctx = C11Parser.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 = 752
            self.specifierQualifierList()
            self.state = 754
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.LeftBracket - 59)) | (1 << (C11Parser.Star - 59)) | (1 << (C11Parser.Caret - 59)))) != 0):
                self.state = 753
                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):
        __slots__ = 'parser'

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

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


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


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


        def getRuleIndex(self):
            return C11Parser.RULE_abstractDeclarator

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




    def abstractDeclarator(self):

        localctx = C11Parser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_abstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 767
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 756
                self.pointer()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 758
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.Star or _la==C11Parser.Caret:
                    self.state = 757
                    self.pointer()


                self.state = 760
                self.directAbstractDeclarator(0)
                self.state = 764
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==C11Parser.T__10 or _la==C11Parser.T__11:
                    self.state = 761
                    self.gccDeclaratorExtension()
                    self.state = 766
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                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):
        __slots__ = 'parser'

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

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

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


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

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


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

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

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


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


        def Static(self):
            return self.getToken(C11Parser.Static, 0)

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

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_directAbstractDeclarator

        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 = C11Parser.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 = 815
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.state = 770
                self.match(C11Parser.LeftParen)
                self.state = 771
                self.abstractDeclarator()
                self.state = 772
                self.match(C11Parser.RightParen)
                self.state = 776
                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:
                        self.state = 773
                        self.gccDeclaratorExtension() 
                    self.state = 778
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,86,self._ctx)

                pass

            elif la_ == 2:
                self.state = 779
                self.match(C11Parser.LeftBracket)
                self.state = 781
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                    self.state = 780
                    self.typeQualifierList()


                self.state = 784
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                    self.state = 783
                    self.assignmentExpression()


                self.state = 786
                self.match(C11Parser.RightBracket)
                pass

            elif la_ == 3:
                self.state = 787
                self.match(C11Parser.LeftBracket)
                self.state = 788
                self.match(C11Parser.Static)
                self.state = 790
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                    self.state = 789
                    self.typeQualifierList()


                self.state = 792
                self.assignmentExpression()
                self.state = 793
                self.match(C11Parser.RightBracket)
                pass

            elif la_ == 4:
                self.state = 795
                self.match(C11Parser.LeftBracket)
                self.state = 796
                self.typeQualifierList()
                self.state = 797
                self.match(C11Parser.Static)
                self.state = 798
                self.assignmentExpression()
                self.state = 799
                self.match(C11Parser.RightBracket)
                pass

            elif la_ == 5:
                self.state = 801
                self.match(C11Parser.LeftBracket)
                self.state = 802
                self.match(C11Parser.Star)
                self.state = 803
                self.match(C11Parser.RightBracket)
                pass

            elif la_ == 6:
                self.state = 804
                self.match(C11Parser.LeftParen)
                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.ThreadLocal))) != 0) or _la==C11Parser.Identifier:
                    self.state = 805
                    self.parameterTypeList()


                self.state = 808
                self.match(C11Parser.RightParen)
                self.state = 812
                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 = 809
                        self.gccDeclaratorExtension() 
                    self.state = 814
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,91,self._ctx)

                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 860
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,99,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 = 858
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
                    if la_ == 1:
                        localctx = C11Parser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 817
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 818
                        self.match(C11Parser.LeftBracket)
                        self.state = 820
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                            self.state = 819
                            self.typeQualifierList()


                        self.state = 823
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                            self.state = 822
                            self.assignmentExpression()


                        self.state = 825
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = C11Parser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 826
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 827
                        self.match(C11Parser.LeftBracket)
                        self.state = 828
                        self.match(C11Parser.Static)
                        self.state = 830
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.Const) | (1 << C11Parser.Restrict) | (1 << C11Parser.Volatile) | (1 << C11Parser.Atomic))) != 0):
                            self.state = 829
                            self.typeQualifierList()


                        self.state = 832
                        self.assignmentExpression()
                        self.state = 833
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 3:
                        localctx = C11Parser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 835
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 836
                        self.match(C11Parser.LeftBracket)
                        self.state = 837
                        self.typeQualifierList()
                        self.state = 838
                        self.match(C11Parser.Static)
                        self.state = 839
                        self.assignmentExpression()
                        self.state = 840
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 4:
                        localctx = C11Parser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 842
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 843
                        self.match(C11Parser.LeftBracket)
                        self.state = 844
                        self.match(C11Parser.Star)
                        self.state = 845
                        self.match(C11Parser.RightBracket)
                        pass

                    elif la_ == 5:
                        localctx = C11Parser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 846
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 847
                        self.match(C11Parser.LeftParen)
                        self.state = 849
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.ThreadLocal))) != 0) or _la==C11Parser.Identifier:
                            self.state = 848
                            self.parameterTypeList()


                        self.state = 851
                        self.match(C11Parser.RightParen)
                        self.state = 855
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 852
                                self.gccDeclaratorExtension() 
                            self.state = 857
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,97,self._ctx)

                        pass

             
                self.state = 862
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,99,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):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_typedefName

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




    def typedefName(self):

        localctx = C11Parser.TypedefNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 863
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

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


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

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


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

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

        def getRuleIndex(self):
            return C11Parser.RULE_initializer

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




    def initializer(self):

        localctx = C11Parser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_initializer)
        self._la = 0 # Token type
        try:
            self.state = 873
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.T__0, C11Parser.T__1, C11Parser.T__2, C11Parser.Sizeof, C11Parser.Alignof, C11Parser.Generic, C11Parser.LeftParen, C11Parser.Plus, C11Parser.PlusPlus, C11Parser.Minus, C11Parser.MinusMinus, C11Parser.Star, C11Parser.And, C11Parser.AndAnd, C11Parser.Not, C11Parser.Tilde, C11Parser.Identifier, C11Parser.Constant, C11Parser.DigitSequence, C11Parser.StringLiteral]:
                self.enterOuterAlt(localctx, 1)
                self.state = 865
                self.assignmentExpression()
                pass
            elif token in [C11Parser.LeftBrace]:
                self.enterOuterAlt(localctx, 2)
                self.state = 866
                self.match(C11Parser.LeftBrace)
                self.state = 867
                self.initializerList()
                self.state = 869
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==C11Parser.Comma:
                    self.state = 868
                    self.match(C11Parser.Comma)


                self.state = 871
                self.match(C11Parser.RightBrace)
                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 InitializerListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def initializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.InitializerContext)
            else:
                return self.getTypedRuleContext(C11Parser.InitializerContext,i)


        def designation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.DesignationContext)
            else:
                return self.getTypedRuleContext(C11Parser.DesignationContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_initializerList

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




    def initializerList(self):

        localctx = C11Parser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 876
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==C11Parser.LeftBracket or _la==C11Parser.Dot:
                self.state = 875
                self.designation()


            self.state = 878
            self.initializer()
            self.state = 886
            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:
                    self.state = 879
                    self.match(C11Parser.Comma)
                    self.state = 881
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==C11Parser.LeftBracket or _la==C11Parser.Dot:
                        self.state = 880
                        self.designation()


                    self.state = 883
                    self.initializer() 
                self.state = 888
                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.exitRule()
        return localctx


    class DesignationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return C11Parser.RULE_designation

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




    def designation(self):

        localctx = C11Parser.DesignationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_designation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self.designatorList()
            self.state = 890
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def designator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.DesignatorContext)
            else:
                return self.getTypedRuleContext(C11Parser.DesignatorContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_designatorList

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




    def designatorList(self):

        localctx = C11Parser.DesignatorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_designatorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 893 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 892
                self.designator()
                self.state = 895 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==C11Parser.LeftBracket or _la==C11Parser.Dot):
                    break

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


    class DesignatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

        def getRuleIndex(self):
            return C11Parser.RULE_designator

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




    def designator(self):

        localctx = C11Parser.DesignatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_designator)
        try:
            self.state = 903
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.LeftBracket]:
                self.enterOuterAlt(localctx, 1)
                self.state = 897
                self.match(C11Parser.LeftBracket)
                self.state = 898
                self.constantExpression()
                self.state = 899
                self.match(C11Parser.RightBracket)
                pass
            elif token in [C11Parser.Dot]:
                self.enterOuterAlt(localctx, 2)
                self.state = 901
                self.match(C11Parser.Dot)
                self.state = 902
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def StaticAssert(self):
            return self.getToken(C11Parser.StaticAssert, 0)

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

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


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

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

        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

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

        def getRuleIndex(self):
            return C11Parser.RULE_staticAssertDeclaration

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




    def staticAssertDeclaration(self):

        localctx = C11Parser.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 = 905
            self.match(C11Parser.StaticAssert)
            self.state = 906
            self.match(C11Parser.LeftParen)
            self.state = 907
            self.constantExpression()
            self.state = 908
            self.match(C11Parser.Comma)
            self.state = 910 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 909
                self.match(C11Parser.StringLiteral)
                self.state = 912 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==C11Parser.StringLiteral):
                    break

            self.state = 914
            self.match(C11Parser.RightParen)
            self.state = 915
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def labeledStatement(self):
            return self.getTypedRuleContext(C11Parser.LabeledStatementContext,0)


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


        def expressionStatement(self):
            return self.getTypedRuleContext(C11Parser.ExpressionStatementContext,0)


        def selectionStatement(self):
            return self.getTypedRuleContext(C11Parser.SelectionStatementContext,0)


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


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


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

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

        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

        def Volatile(self):
            return self.getToken(C11Parser.Volatile, 0)

        def logicalOrExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.LogicalOrExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.LogicalOrExpressionContext,i)


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

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

        def getRuleIndex(self):
            return C11Parser.RULE_statement

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




    def statement(self):

        localctx = C11Parser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 954
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 917
                self.labeledStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 918
                self.compoundStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 919
                self.expressionStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 920
                self.selectionStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 921
                self.iterationStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 922
                self.jumpStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 923
                _la = self._input.LA(1)
                if not(_la==C11Parser.T__10 or _la==C11Parser.T__12):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 924
                _la = self._input.LA(1)
                if not(_la==C11Parser.T__13 or _la==C11Parser.Volatile):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 925
                self.match(C11Parser.LeftParen)
                self.state = 934
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                    self.state = 926
                    self.logicalOrExpression()
                    self.state = 931
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==C11Parser.Comma:
                        self.state = 927
                        self.match(C11Parser.Comma)
                        self.state = 928
                        self.logicalOrExpression()
                        self.state = 933
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 949
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==C11Parser.Colon:
                    self.state = 936
                    self.match(C11Parser.Colon)
                    self.state = 945
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                        self.state = 937
                        self.logicalOrExpression()
                        self.state = 942
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==C11Parser.Comma:
                            self.state = 938
                            self.match(C11Parser.Comma)
                            self.state = 939
                            self.logicalOrExpression()
                            self.state = 944
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



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

                self.state = 952
                self.match(C11Parser.RightParen)
                self.state = 953
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

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

        def Colon(self):
            return self.getToken(C11Parser.Colon, 0)

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


        def Case(self):
            return self.getToken(C11Parser.Case, 0)

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


        def Default(self):
            return self.getToken(C11Parser.Default, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_labeledStatement

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




    def labeledStatement(self):

        localctx = C11Parser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_labeledStatement)
        try:
            self.state = 967
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 956
                self.match(C11Parser.Identifier)
                self.state = 957
                self.match(C11Parser.Colon)
                self.state = 958
                self.statement()
                pass
            elif token in [C11Parser.Case]:
                self.enterOuterAlt(localctx, 2)
                self.state = 959
                self.match(C11Parser.Case)
                self.state = 960
                self.constantExpression()
                self.state = 961
                self.match(C11Parser.Colon)
                self.state = 962
                self.statement()
                pass
            elif token in [C11Parser.Default]:
                self.enterOuterAlt(localctx, 3)
                self.state = 964
                self.match(C11Parser.Default)
                self.state = 965
                self.match(C11Parser.Colon)
                self.state = 966
                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):
        __slots__ = 'parser'

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

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

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

        def blockItemList(self):
            return self.getTypedRuleContext(C11Parser.BlockItemListContext,0)


        def getRuleIndex(self):
            return C11Parser.RULE_compoundStatement

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




    def compoundStatement(self):

        localctx = C11Parser.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 = 969
            self.match(C11Parser.LeftBrace)
            self.state = 971
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__10) | (1 << C11Parser.T__11) | (1 << C11Parser.T__12) | (1 << C11Parser.Auto) | (1 << C11Parser.Break) | (1 << C11Parser.Case) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Continue) | (1 << C11Parser.Default) | (1 << C11Parser.Do) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.For) | (1 << C11Parser.Goto) | (1 << C11Parser.If) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Return) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Switch) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.While) | (1 << C11Parser.Alignas) | (1 << C11Parser.Alignof) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Generic) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftParen) | (1 << C11Parser.LeftBrace))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Semi - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                self.state = 970
                self.blockItemList()


            self.state = 973
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

        def blockItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.BlockItemContext)
            else:
                return self.getTypedRuleContext(C11Parser.BlockItemContext,i)


        def getRuleIndex(self):
            return C11Parser.RULE_blockItemList

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




    def blockItemList(self):

        localctx = C11Parser.BlockItemListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_blockItemList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 976 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 975
                self.blockItem()
                self.state = 978 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__10) | (1 << C11Parser.T__11) | (1 << C11Parser.T__12) | (1 << C11Parser.Auto) | (1 << C11Parser.Break) | (1 << C11Parser.Case) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Continue) | (1 << C11Parser.Default) | (1 << C11Parser.Do) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.For) | (1 << C11Parser.Goto) | (1 << C11Parser.If) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Return) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Switch) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.While) | (1 << C11Parser.Alignas) | (1 << C11Parser.Alignof) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Generic) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftParen) | (1 << C11Parser.LeftBrace))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Semi - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0)):
                    break

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


    class BlockItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_blockItem

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




    def blockItem(self):

        localctx = C11Parser.BlockItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_blockItem)
        try:
            self.state = 982
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,117,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 980
                self.statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 981
                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):
        __slots__ = 'parser'

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

        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

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


        def getRuleIndex(self):
            return C11Parser.RULE_expressionStatement

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




    def expressionStatement(self):

        localctx = C11Parser.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 = 985
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                self.state = 984
                self.expression()


            self.state = 987
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

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

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

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


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

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


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

        def Switch(self):
            return self.getToken(C11Parser.Switch, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_selectionStatement

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




    def selectionStatement(self):

        localctx = C11Parser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_selectionStatement)
        try:
            self.state = 1004
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.If]:
                self.enterOuterAlt(localctx, 1)
                self.state = 989
                self.match(C11Parser.If)
                self.state = 990
                self.match(C11Parser.LeftParen)
                self.state = 991
                self.expression()
                self.state = 992
                self.match(C11Parser.RightParen)
                self.state = 993
                self.statement()
                self.state = 996
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
                if la_ == 1:
                    self.state = 994
                    self.match(C11Parser.Else)
                    self.state = 995
                    self.statement()


                pass
            elif token in [C11Parser.Switch]:
                self.enterOuterAlt(localctx, 2)
                self.state = 998
                self.match(C11Parser.Switch)
                self.state = 999
                self.match(C11Parser.LeftParen)
                self.state = 1000
                self.expression()
                self.state = 1001
                self.match(C11Parser.RightParen)
                self.state = 1002
                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):
        __slots__ = 'parser'

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

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

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

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


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

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


        def Do(self):
            return self.getToken(C11Parser.Do, 0)

        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

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

        def forCondition(self):
            return self.getTypedRuleContext(C11Parser.ForConditionContext,0)


        def getRuleIndex(self):
            return C11Parser.RULE_iterationStatement

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




    def iterationStatement(self):

        localctx = C11Parser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_iterationStatement)
        try:
            self.state = 1026
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [C11Parser.While]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1006
                self.match(C11Parser.While)
                self.state = 1007
                self.match(C11Parser.LeftParen)
                self.state = 1008
                self.expression()
                self.state = 1009
                self.match(C11Parser.RightParen)
                self.state = 1010
                self.statement()
                pass
            elif token in [C11Parser.Do]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1012
                self.match(C11Parser.Do)
                self.state = 1013
                self.statement()
                self.state = 1014
                self.match(C11Parser.While)
                self.state = 1015
                self.match(C11Parser.LeftParen)
                self.state = 1016
                self.expression()
                self.state = 1017
                self.match(C11Parser.RightParen)
                self.state = 1018
                self.match(C11Parser.Semi)
                pass
            elif token in [C11Parser.For]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1020
                self.match(C11Parser.For)
                self.state = 1021
                self.match(C11Parser.LeftParen)
                self.state = 1022
                self.forCondition()
                self.state = 1023
                self.match(C11Parser.RightParen)
                self.state = 1024
                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):
        __slots__ = 'parser'

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

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

        def forDeclaration(self):
            return self.getTypedRuleContext(C11Parser.ForDeclarationContext,0)


        def forExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.ForExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.ForExpressionContext,i)


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


        def getRuleIndex(self):
            return C11Parser.RULE_forCondition

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




    def forCondition(self):

        localctx = C11Parser.ForConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_forCondition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1032
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.state = 1028
                self.forDeclaration()
                pass

            elif la_ == 2:
                self.state = 1030
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                    self.state = 1029
                    self.expression()


                pass


            self.state = 1034
            self.match(C11Parser.Semi)
            self.state = 1036
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                self.state = 1035
                self.forExpression()


            self.state = 1038
            self.match(C11Parser.Semi)
            self.state = 1040
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                self.state = 1039
                self.forExpression()


        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):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return C11Parser.RULE_forDeclaration

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




    def forDeclaration(self):

        localctx = C11Parser.ForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_forDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1042
            self.declarationSpecifiers()
            self.state = 1044
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 59)) & ~0x3f) == 0 and ((1 << (_la - 59)) & ((1 << (C11Parser.LeftParen - 59)) | (1 << (C11Parser.Star - 59)) | (1 << (C11Parser.Caret - 59)) | (1 << (C11Parser.Identifier - 59)))) != 0):
                self.state = 1043
                self.initDeclaratorList()


        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):
        __slots__ = 'parser'

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

        def assignmentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(C11Parser.AssignmentExpressionContext)
            else:
                return self.getTypedRuleContext(C11Parser.AssignmentExpressionContext,i)


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

        def getRuleIndex(self):
            return C11Parser.RULE_forExpression

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




    def forExpression(self):

        localctx = C11Parser.ForExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_forExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1046
            self.assignmentExpression()
            self.state = 1051
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==C11Parser.Comma:
                self.state = 1047
                self.match(C11Parser.Comma)
                self.state = 1048
                self.assignmentExpression()
                self.state = 1053
                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 JumpStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

        def Goto(self):
            return self.getToken(C11Parser.Goto, 0)

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

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

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


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

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

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


        def getRuleIndex(self):
            return C11Parser.RULE_jumpStatement

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




    def jumpStatement(self):

        localctx = C11Parser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_jumpStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1063
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
            if la_ == 1:
                self.state = 1054
                self.match(C11Parser.Goto)
                self.state = 1055
                self.match(C11Parser.Identifier)
                pass

            elif la_ == 2:
                self.state = 1056
                _la = self._input.LA(1)
                if not(_la==C11Parser.Break or _la==C11Parser.Continue):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 3:
                self.state = 1057
                self.match(C11Parser.Return)
                self.state = 1059
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__1) | (1 << C11Parser.T__2) | (1 << C11Parser.Sizeof) | (1 << C11Parser.Alignof) | (1 << C11Parser.Generic) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (C11Parser.Plus - 71)) | (1 << (C11Parser.PlusPlus - 71)) | (1 << (C11Parser.Minus - 71)) | (1 << (C11Parser.MinusMinus - 71)) | (1 << (C11Parser.Star - 71)) | (1 << (C11Parser.And - 71)) | (1 << (C11Parser.AndAnd - 71)) | (1 << (C11Parser.Not - 71)) | (1 << (C11Parser.Tilde - 71)) | (1 << (C11Parser.Identifier - 71)) | (1 << (C11Parser.Constant - 71)) | (1 << (C11Parser.DigitSequence - 71)) | (1 << (C11Parser.StringLiteral - 71)))) != 0):
                    self.state = 1058
                    self.expression()


                pass

            elif la_ == 4:
                self.state = 1061
                self.match(C11Parser.Goto)
                self.state = 1062
                self.unaryExpression()
                pass


            self.state = 1065
            self.match(C11Parser.Semi)
        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):
        __slots__ = 'parser'

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

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

        def translationUnit(self):
            return self.getTypedRuleContext(C11Parser.TranslationUnitContext,0)


        def getRuleIndex(self):
            return C11Parser.RULE_compilationUnit

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




    def compilationUnit(self):

        localctx = C11Parser.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 = 1068
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (C11Parser.Star - 75)) | (1 << (C11Parser.Caret - 75)) | (1 << (C11Parser.Semi - 75)) | (1 << (C11Parser.Identifier - 75)))) != 0):
                self.state = 1067
                self.translationUnit()


            self.state = 1070
            self.match(C11Parser.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):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return C11Parser.RULE_translationUnit

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




    def translationUnit(self):

        localctx = C11Parser.TranslationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1073 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1072
                self.externalDeclaration()
                self.state = 1075 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal) | (1 << C11Parser.LeftParen))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (C11Parser.Star - 75)) | (1 << (C11Parser.Caret - 75)) | (1 << (C11Parser.Semi - 75)) | (1 << (C11Parser.Identifier - 75)))) != 0)):
                    break

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


    class ExternalDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def functionDefinition(self):
            return self.getTypedRuleContext(C11Parser.FunctionDefinitionContext,0)


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


        def Semi(self):
            return self.getToken(C11Parser.Semi, 0)

        def getRuleIndex(self):
            return C11Parser.RULE_externalDeclaration

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




    def externalDeclaration(self):

        localctx = C11Parser.ExternalDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_externalDeclaration)
        try:
            self.state = 1080
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1077
                self.functionDefinition()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1079
                self.match(C11Parser.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):
        __slots__ = 'parser'

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

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


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


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


        def declarationList(self):
            return self.getTypedRuleContext(C11Parser.DeclarationListContext,0)


        def getRuleIndex(self):
            return C11Parser.RULE_functionDefinition

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




    def functionDefinition(self):

        localctx = C11Parser.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 = 1083
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
            if la_ == 1:
                self.state = 1082
                self.declarationSpecifiers()


            self.state = 1085
            self.declarator()
            self.state = 1087
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal))) != 0) or _la==C11Parser.Identifier:
                self.state = 1086
                self.declarationList()


            self.state = 1089
            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):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return C11Parser.RULE_declarationList

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




    def declarationList(self):

        localctx = C11Parser.DeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_declarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1092 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1091
                self.declaration()
                self.state = 1094 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << C11Parser.T__0) | (1 << C11Parser.T__3) | (1 << C11Parser.T__4) | (1 << C11Parser.T__5) | (1 << C11Parser.T__6) | (1 << C11Parser.T__7) | (1 << C11Parser.T__8) | (1 << C11Parser.T__9) | (1 << C11Parser.T__11) | (1 << C11Parser.Auto) | (1 << C11Parser.Char) | (1 << C11Parser.Const) | (1 << C11Parser.Double) | (1 << C11Parser.Enum) | (1 << C11Parser.Extern) | (1 << C11Parser.Float) | (1 << C11Parser.Inline) | (1 << C11Parser.Int) | (1 << C11Parser.Long) | (1 << C11Parser.Register) | (1 << C11Parser.Restrict) | (1 << C11Parser.Short) | (1 << C11Parser.Signed) | (1 << C11Parser.Static) | (1 << C11Parser.Struct) | (1 << C11Parser.Typedef) | (1 << C11Parser.Union) | (1 << C11Parser.Unsigned) | (1 << C11Parser.Void) | (1 << C11Parser.Volatile) | (1 << C11Parser.Alignas) | (1 << C11Parser.Atomic) | (1 << C11Parser.Bool) | (1 << C11Parser.Complex) | (1 << C11Parser.Noreturn) | (1 << C11Parser.StaticAssert) | (1 << C11Parser.ThreadLocal))) != 0) or _la==C11Parser.Identifier):
                    break

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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[31] = self.typeSpecifier_sempred
        self._predicates[48] = self.directDeclarator_sempred
        self._predicates[62] = self.directAbstractDeclarator_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 typeSpecifier_sempred(self, localctx:TypeSpecifierContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         

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

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

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

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

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

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

    def directAbstractDeclarator_sempred(self, localctx:DirectAbstractDeclaratorContext, predIndex:int):
            if predIndex == 7:
                return self.precpred(self._ctx, 5)
         

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

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

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

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




