# Generated from ObjectiveCParser.g4 by ANTLR 4.7.1
# encoding: utf-8
from __future__ import print_function
from QBCodeSpecs.antlr4 import *
from io import StringIO
import sys

def serializedATN():
    with StringIO() as buf:
        buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
        buf.write(u"\u00e0\u06a1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6")
        buf.write(u"\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4")
        buf.write(u"\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t")
        buf.write(u"\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27")
        buf.write(u"\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4")
        buf.write(u"\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t")
        buf.write(u"#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4")
        buf.write(u",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62")
        buf.write(u"\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\4")
        buf.write(u"8\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@")
        buf.write(u"\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\t")
        buf.write(u"I\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R")
        buf.write(u"\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4")
        buf.write(u"[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\t")
        buf.write(u"c\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l")
        buf.write(u"\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4")
        buf.write(u"u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}")
        buf.write(u"\4~\t~\4\177\t\177\4\u0080\t\u0080\4\u0081\t\u0081\4")
        buf.write(u"\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085")
        buf.write(u"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088")
        buf.write(u"\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c")
        buf.write(u"\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e\4\u008f\t\u008f")
        buf.write(u"\4\u0090\t\u0090\4\u0091\t\u0091\3\2\7\2\u0124\n\2\f")
        buf.write(u"\2\16\2\u0127\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3")
        buf.write(u"\3\3\3\3\3\3\3\3\3\5\3\u0136\n\3\3\4\3\4\3\4\3\4\3\5")
        buf.write(u"\5\5\u013d\n\5\3\5\3\5\3\5\3\5\5\5\u0143\n\5\3\5\3\5")
        buf.write(u"\3\5\3\5\5\5\u0149\n\5\3\5\5\5\u014c\n\5\3\5\5\5\u014f")
        buf.write(u"\n\5\3\5\3\5\3\6\3\6\3\6\3\6\5\6\u0157\n\6\3\6\3\6\3")
        buf.write(u"\6\3\6\3\6\5\6\u015e\n\6\3\6\5\6\u0161\n\6\3\6\5\6\u0164")
        buf.write(u"\n\6\3\6\3\6\3\7\3\7\3\7\3\7\5\7\u016c\n\7\3\7\5\7\u016f")
        buf.write(u"\n\7\3\7\5\7\u0172\n\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3")
        buf.write(u"\b\5\b\u017c\n\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\5\t")
        buf.write(u"\u0186\n\t\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u018e\n\n\3\n")
        buf.write(u"\7\n\u0191\n\n\f\n\16\n\u0194\13\n\3\n\3\n\3\13\3\13")
        buf.write(u"\7\13\u019a\n\13\f\13\16\13\u019d\13\13\3\13\6\13\u01a0")
        buf.write(u"\n\13\r\13\16\13\u01a1\5\13\u01a4\n\13\3\f\3\f\3\f\3")
        buf.write(u"\f\3\r\3\r\3\r\3\r\7\r\u01ae\n\r\f\r\16\r\u01b1\13\r")
        buf.write(u"\3\r\3\r\3\16\3\16\3\16\7\16\u01b8\n\16\f\16\16\16\u01bb")
        buf.write(u"\13\16\3\17\3\17\3\17\3\17\3\17\5\17\u01c2\n\17\3\17")
        buf.write(u"\5\17\u01c5\n\17\3\17\5\17\u01c8\n\17\3\17\3\17\3\20")
        buf.write(u"\3\20\3\20\7\20\u01cf\n\20\f\20\16\20\u01d2\13\20\3\21")
        buf.write(u"\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3")
        buf.write(u"\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u01e8")
        buf.write(u"\n\21\3\22\3\22\3\22\3\22\3\22\5\22\u01ef\n\22\3\22\5")
        buf.write(u"\22\u01f2\n\22\3\23\3\23\7\23\u01f6\n\23\f\23\16\23\u01f9")
        buf.write(u"\13\23\3\23\3\23\3\24\3\24\7\24\u01ff\n\24\f\24\16\24")
        buf.write(u"\u0202\13\24\3\24\6\24\u0205\n\24\r\24\16\24\u0206\5")
        buf.write(u"\24\u0209\n\24\3\25\3\25\3\26\3\26\3\26\3\26\3\26\6\26")
        buf.write(u"\u0212\n\26\r\26\16\26\u0213\3\27\3\27\3\27\3\30\3\30")
        buf.write(u"\3\30\3\31\5\31\u021d\n\31\3\31\3\31\5\31\u0221\n\31")
        buf.write(u"\3\31\3\31\3\32\3\32\3\32\3\32\3\32\6\32\u022a\n\32\r")
        buf.write(u"\32\16\32\u022b\3\33\3\33\3\33\3\34\3\34\3\34\3\35\5")
        buf.write(u"\35\u0235\n\35\3\35\3\35\5\35\u0239\n\35\3\35\5\35\u023c")
        buf.write(u"\n\35\3\35\3\35\3\36\3\36\6\36\u0242\n\36\r\36\16\36")
        buf.write(u"\u0243\3\36\3\36\5\36\u0248\n\36\5\36\u024a\n\36\3\37")
        buf.write(u"\5\37\u024d\n\37\3\37\3\37\7\37\u0251\n\37\f\37\16\37")
        buf.write(u"\u0254\13\37\3\37\5\37\u0257\n\37\3\37\3\37\3 \3 \5 ")
        buf.write(u"\u025d\n \3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"")
        buf.write(u"\5\"\u026b\n\"\3#\3#\3#\7#\u0270\n#\f#\16#\u0273\13#")
        buf.write(u"\3$\3$\3$\5$\u0278\n$\3%\5%\u027b\n%\3%\3%\5%\u027f\n")
        buf.write(u"%\3%\3%\3%\3%\5%\u0285\n%\3%\3%\5%\u0289\n%\3&\3&\3&")
        buf.write(u"\3&\7&\u028f\n&\f&\16&\u0292\13&\5&\u0294\n&\3&\3&\3")
        buf.write(u"\'\7\'\u0299\n\'\f\'\16\'\u029c\13\'\3\'\3\'\3(\3(\3")
        buf.write(u"(\3(\3(\7(\u02a5\n(\f(\16(\u02a8\13(\3(\5(\u02ab\n(\5")
        buf.write(u"(\u02ad\n(\3(\3(\3)\3)\3)\3)\3*\3*\3*\3*\5*\u02b9\n*")
        buf.write(u"\5*\u02bb\n*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\5+\u02c7\n")
        buf.write(u"+\5+\u02c9\n+\3,\3,\3,\5,\u02ce\n,\3,\3,\7,\u02d2\n,")
        buf.write(u"\f,\16,\u02d5\13,\5,\u02d7\n,\3,\3,\3-\3-\5-\u02dd\n")
        buf.write(u"-\3.\3.\5.\u02e1\n.\3.\5.\u02e4\n.\3.\5.\u02e7\n.\3.")
        buf.write(u"\3.\3/\3/\3/\3/\3/\3\60\3\60\5\60\u02f2\n\60\3\61\3\61")
        buf.write(u"\6\61\u02f6\n\61\r\61\16\61\u02f7\5\61\u02fa\n\61\3\62")
        buf.write(u"\5\62\u02fd\n\62\3\62\3\62\3\62\3\62\7\62\u0303\n\62")
        buf.write(u"\f\62\16\62\u0306\13\62\3\63\3\63\5\63\u030a\n\63\3\63")
        buf.write(u"\3\63\3\63\3\63\5\63\u0310\n\63\3\64\3\64\3\64\3\64\3")
        buf.write(u"\64\3\65\3\65\5\65\u0319\n\65\3\65\6\65\u031c\n\65\r")
        buf.write(u"\65\16\65\u031d\5\65\u0320\n\65\3\66\3\66\3\66\3\66\3")
        buf.write(u"\66\3\67\3\67\3\67\3\67\3\67\38\38\38\39\39\39\39\39")
        buf.write(u"\39\39\59\u0336\n9\3:\3:\3:\7:\u033b\n:\f:\16:\u033e")
        buf.write(u"\13:\3:\3:\5:\u0342\n:\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<")
        buf.write(u"\3<\3<\3=\3=\3=\3>\3>\3>\3?\3?\3?\3@\5@\u035a\n@\3@\3")
        buf.write(u"@\3@\5@\u035f\n@\3@\3@\3@\5@\u0364\n@\3A\3A\5A\u0368")
        buf.write(u"\nA\3B\3B\5B\u036c\nB\3C\3C\5C\u0370\nC\3C\3C\3D\3D\3")
        buf.write(u"D\7D\u0377\nD\fD\16D\u037a\13D\3E\3E\3E\3E\5E\u0380\n")
        buf.write(u"E\3F\3F\3F\3F\3F\5F\u0387\nF\3G\3G\3G\3G\5G\u038d\nG")
        buf.write(u"\3H\5H\u0390\nH\3H\3H\5H\u0394\nH\3H\3H\3H\3H\3H\3I\5")
        buf.write(u"I\u039c\nI\3I\5I\u039f\nI\3I\3I\5I\u03a3\nI\3I\3I\3J")
        buf.write(u"\3J\3J\3J\5J\u03ab\nJ\3J\3J\3K\5K\u03b0\nK\3K\3K\3K\3")
        buf.write(u"K\3K\5K\u03b7\nK\3K\3K\3L\3L\3L\7L\u03be\nL\fL\16L\u03c1")
        buf.write(u"\13L\3M\5M\u03c4\nM\3M\3M\3N\3N\3N\3N\3N\3N\3N\3N\6N")
        buf.write(u"\u03d0\nN\rN\16N\u03d1\3O\3O\3O\3O\3O\3O\7O\u03da\nO")
        buf.write(u"\fO\16O\u03dd\13O\3O\3O\3O\3P\3P\3P\7P\u03e5\nP\fP\16")
        buf.write(u"P\u03e8\13P\3Q\3Q\3Q\5Q\u03ed\nQ\3R\3R\3R\5R\u03f2\n")
        buf.write(u"R\3R\3R\6R\u03f6\nR\rR\16R\u03f7\3R\3R\5R\u03fc\nR\3")
        buf.write(u"S\3S\3S\5S\u0401\nS\3S\3S\3T\3T\3T\3T\3T\3T\6T\u040b")
        buf.write(u"\nT\rT\16T\u040c\3U\3U\3U\3U\3U\3U\5U\u0415\nU\3V\3V")
        buf.write(u"\3W\3W\3X\3X\3Y\3Y\3Z\3Z\3Z\3Z\5Z\u0423\nZ\3[\3[\3\\")
        buf.write(u"\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\")
        buf.write(u"\3\\\5\\\u0436\n\\\5\\\u0438\n\\\3]\3]\3]\3]\3]\3^\3")
        buf.write(u"^\3^\7^\u0442\n^\f^\16^\u0445\13^\3_\3_\5_\u0449\n_\3")
        buf.write(u"_\3_\5_\u044d\n_\3`\3`\5`\u0451\n`\3`\3`\5`\u0455\n`")
        buf.write(u"\3`\3`\3`\3`\3`\5`\u045c\n`\3`\3`\3`\3`\5`\u0462\n`\3")
        buf.write(u"`\3`\3`\3`\3`\3`\3`\3`\3`\3`\5`\u046e\n`\3a\3a\3a\7a")
        buf.write(u"\u0473\na\fa\16a\u0476\13a\3a\5a\u0479\na\3b\3b\3b\5")
        buf.write(u"b\u047e\nb\3c\3c\5c\u0482\nc\3d\3d\3d\3d\3d\5d\u0489")
        buf.write(u"\nd\3d\7d\u048c\nd\fd\16d\u048f\13d\3d\3d\3d\5d\u0494")
        buf.write(u"\nd\3d\5d\u0497\nd\3d\3d\5d\u049b\nd\3e\3e\5e\u049f\n")
        buf.write(u"e\3e\3e\3f\3f\3f\5f\u04a6\nf\3g\3g\5g\u04aa\ng\3g\5g")
        buf.write(u"\u04ad\ng\3h\3h\3h\3h\3h\7h\u04b4\nh\fh\16h\u04b7\13")
        buf.write(u"h\3h\3h\5h\u04bb\nh\3i\3i\3i\5i\u04c0\ni\5i\u04c2\ni")
        buf.write(u"\3i\3i\3j\3j\3j\3j\3j\3j\7j\u04cc\nj\fj\16j\u04cf\13")
        buf.write(u"j\3j\5j\u04d2\nj\5j\u04d4\nj\3j\3j\3k\3k\3k\7k\u04db")
        buf.write(u"\nk\fk\16k\u04de\13k\3k\5k\u04e1\nk\3l\3l\5l\u04e5\n")
        buf.write(u"l\3l\5l\u04e8\nl\3m\3m\5m\u04ec\nm\3m\3m\5m\u04f0\nm")
        buf.write(u"\3m\3m\6m\u04f4\nm\rm\16m\u04f5\3m\3m\5m\u04fa\nm\3m")
        buf.write(u"\6m\u04fd\nm\rm\16m\u04fe\5m\u0501\nm\3n\3n\5n\u0505")
        buf.write(u"\nn\3n\3n\3n\5n\u050a\nn\3n\5n\u050d\nn\3o\3o\3o\7o\u0512")
        buf.write(u"\no\fo\16o\u0515\13o\3p\3p\3p\3p\5p\u051b\np\3q\5q\u051e")
        buf.write(u"\nq\3q\3q\3r\3r\5r\u0524\nr\3r\3r\5r\u0528\nr\3r\3r\5")
        buf.write(u"r\u052c\nr\3r\3r\5r\u0530\nr\3r\3r\5r\u0534\nr\3r\3r")
        buf.write(u"\5r\u0538\nr\3r\3r\5r\u053c\nr\3r\3r\5r\u0540\nr\3r\3")
        buf.write(u"r\5r\u0544\nr\3r\3r\5r\u0548\nr\3r\5r\u054b\nr\3s\3s")
        buf.write(u"\3s\3s\3t\3t\3t\5t\u0554\nt\3u\3u\3u\7u\u0559\nu\fu\16")
        buf.write(u"u\u055c\13u\3u\3u\3v\3v\3v\3v\3v\3v\3v\5v\u0567\nv\3")
        buf.write(u"v\5v\u056a\nv\3w\3w\3w\3w\3w\3w\3x\3x\7x\u0574\nx\fx")
        buf.write(u"\16x\u0577\13x\3x\3x\3y\6y\u057c\ny\ry\16y\u057d\3y\6")
        buf.write(u"y\u0581\ny\ry\16y\u0582\3z\3z\3z\3z\3z\3z\5z\u058b\n")
        buf.write(u"z\3z\3z\3z\3z\5z\u0591\nz\3{\3{\3{\3{\5{\u0597\n{\3|")
        buf.write(u"\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3~\3~\3~\5~\u05aa")
        buf.write(u"\n~\3~\3~\5~\u05ae\n~\3~\3~\5~\u05b2\n~\3~\3~\3~\3\177")
        buf.write(u"\3\177\3\177\3\177\5\177\u05bb\n\177\3\u0080\3\u0080")
        buf.write(u"\3\u0080\3\u0080\3\u0080\5\u0080\u05c2\n\u0080\3\u0080")
        buf.write(u"\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081")
        buf.write(u"\3\u0081\5\u0081\u05cd\n\u0081\5\u0081\u05cf\n\u0081")
        buf.write(u"\3\u0082\3\u0082\3\u0082\7\u0082\u05d4\n\u0082\f\u0082")
        buf.write(u"\16\u0082\u05d7\13\u0082\3\u0083\3\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\5\u0083\u05df\n\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\5\u0083\u05ec\n\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083")
        buf.write(u"\3\u0083\3\u0083\5\u0083\u0607\n\u0083\3\u0083\3\u0083")
        buf.write(u"\7\u0083\u060b\n\u0083\f\u0083\16\u0083\u060e\13\u0083")
        buf.write(u"\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085")
        buf.write(u"\3\u0085\3\u0085\5\u0085\u0619\n\u0085\5\u0085\u061b")
        buf.write(u"\n\u0085\3\u0086\3\u0086\3\u0086\5\u0086\u0620\n\u0086")
        buf.write(u"\3\u0087\3\u0087\5\u0087\u0624\n\u0087\3\u0088\3\u0088")
        buf.write(u"\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\5\u0088\u062d")
        buf.write(u"\n\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088\5\u0088")
        buf.write(u"\u0634\n\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a")
        buf.write(u"\7\u008a\u063b\n\u008a\f\u008a\16\u008a\u063e\13\u008a")
        buf.write(u"\3\u008a\3\u008a\3\u008a\3\u008a\7\u008a\u0644\n\u008a")
        buf.write(u"\f\u008a\16\u008a\u0647\13\u008a\7\u008a\u0649\n\u008a")
        buf.write(u"\f\u008a\16\u008a\u064c\13\u008a\3\u008b\3\u008b\3\u008b")
        buf.write(u"\3\u008b\3\u008b\3\u008b\5\u008b\u0654\n\u008b\3\u008b")
        buf.write(u"\3\u008b\3\u008b\3\u008b\6\u008b\u065a\n\u008b\r\u008b")
        buf.write(u"\16\u008b\u065b\3\u008b\3\u008b\5\u008b\u0660\n\u008b")
        buf.write(u"\3\u008c\3\u008c\3\u008c\7\u008c\u0665\n\u008c\f\u008c")
        buf.write(u"\16\u008c\u0668\13\u008c\3\u008d\3\u008d\5\u008d\u066c")
        buf.write(u"\n\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e")
        buf.write(u"\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e")
        buf.write(u"\3\u008e\3\u008e\5\u008e\u067d\n\u008e\3\u008f\3\u008f")
        buf.write(u"\3\u008f\3\u008f\5\u008f\u0683\n\u008f\3\u008f\3\u008f")
        buf.write(u"\5\u008f\u0687\n\u008f\3\u008f\3\u008f\3\u008f\3\u008f")
        buf.write(u"\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f\u0691\n\u008f")
        buf.write(u"\3\u0090\3\u0090\7\u0090\u0695\n\u0090\f\u0090\16\u0090")
        buf.write(u"\u0698\13\u0090\3\u0090\6\u0090\u069b\n\u0090\r\u0090")
        buf.write(u"\16\u0090\u069c\3\u0091\3\u0091\3\u0091\2\4\u0104\u0112")
        buf.write(u"\u0092\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*")
        buf.write(u",.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080")
        buf.write(u"\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092")
        buf.write(u"\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4")
        buf.write(u"\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6")
        buf.write(u"\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8")
        buf.write(u"\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da")
        buf.write(u"\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec")
        buf.write(u"\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe")
        buf.write(u"\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110")
        buf.write(u"\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\2\27")
        buf.write(u"\4\2HHMM\3\2\\]\5\2FFIIKL\4\2\35\35  \6\2WW``bbdd\3\2")
        buf.write(u"eh\6\2\3\3\16\16\26\26\34\34\6\2\23\23X[__ii\5\2,-\60")
        buf.write(u"\61\65\66\3\2jk\4\2\u009c\u009d\u00a1\u00a1\3\2\u009a")
        buf.write(u"\u009b\4\2\u008c\u008d\u0093\u0094\4\2\u0092\u0092\u0095")
        buf.write(u"\u0095\4\2\u008b\u008b\u00a2\u00ab\3\2\u0098\u0099\5")
        buf.write(u"\2\u008e\u008f\u009a\u009c\u009e\u009e\3\2\u0088\u0089")
        buf.write(u"\3\2\u0081\u0081\4\2\u00b9\u00b9\u00bb\u00bb\n\2*\61")
        buf.write(u"\65:SUWXZ_ccex\177\177\2\u0758\2\u0125\3\2\2\2\4\u0135")
        buf.write(u"\3\2\2\2\6\u0137\3\2\2\2\b\u013c\3\2\2\2\n\u0152\3\2")
        buf.write(u"\2\2\f\u0167\3\2\2\2\16\u0175\3\2\2\2\20\u017f\3\2\2")
        buf.write(u"\2\22\u0187\3\2\2\2\24\u01a3\3\2\2\2\26\u01a5\3\2\2\2")
        buf.write(u"\30\u01a9\3\2\2\2\32\u01b4\3\2\2\2\34\u01bc\3\2\2\2\36")
        buf.write(u"\u01cb\3\2\2\2 \u01e7\3\2\2\2\"\u01f1\3\2\2\2$\u01f3")
        buf.write(u"\3\2\2\2&\u0208\3\2\2\2(\u020a\3\2\2\2*\u0211\3\2\2\2")
        buf.write(u",\u0215\3\2\2\2.\u0218\3\2\2\2\60\u021c\3\2\2\2\62\u0229")
        buf.write(u"\3\2\2\2\64\u022d\3\2\2\2\66\u0230\3\2\2\28\u0234\3\2")
        buf.write(u"\2\2:\u0249\3\2\2\2<\u024c\3\2\2\2>\u025c\3\2\2\2@\u025e")
        buf.write(u"\3\2\2\2B\u026a\3\2\2\2D\u026c\3\2\2\2F\u0274\3\2\2\2")
        buf.write(u"H\u027a\3\2\2\2J\u028a\3\2\2\2L\u029a\3\2\2\2N\u029f")
        buf.write(u"\3\2\2\2P\u02b0\3\2\2\2R\u02b4\3\2\2\2T\u02c8\3\2\2\2")
        buf.write(u"V\u02ca\3\2\2\2X\u02dc\3\2\2\2Z\u02de\3\2\2\2\\\u02ea")
        buf.write(u"\3\2\2\2^\u02f1\3\2\2\2`\u02f9\3\2\2\2b\u02fc\3\2\2\2")
        buf.write(u"d\u0307\3\2\2\2f\u0311\3\2\2\2h\u031f\3\2\2\2j\u0321")
        buf.write(u"\3\2\2\2l\u0326\3\2\2\2n\u032b\3\2\2\2p\u0335\3\2\2\2")
        buf.write(u"r\u0337\3\2\2\2t\u0343\3\2\2\2v\u0349\3\2\2\2x\u034f")
        buf.write(u"\3\2\2\2z\u0352\3\2\2\2|\u0355\3\2\2\2~\u0359\3\2\2\2")
        buf.write(u"\u0080\u0365\3\2\2\2\u0082\u036b\3\2\2\2\u0084\u036d")
        buf.write(u"\3\2\2\2\u0086\u0373\3\2\2\2\u0088\u037f\3\2\2\2\u008a")
        buf.write(u"\u0381\3\2\2\2\u008c\u038c\3\2\2\2\u008e\u038f\3\2\2")
        buf.write(u"\2\u0090\u039b\3\2\2\2\u0092\u03aa\3\2\2\2\u0094\u03af")
        buf.write(u"\3\2\2\2\u0096\u03ba\3\2\2\2\u0098\u03c3\3\2\2\2\u009a")
        buf.write(u"\u03cf\3\2\2\2\u009c\u03d3\3\2\2\2\u009e\u03e1\3\2\2")
        buf.write(u"\2\u00a0\u03e9\3\2\2\2\u00a2\u03ee\3\2\2\2\u00a4\u03fd")
        buf.write(u"\3\2\2\2\u00a6\u040a\3\2\2\2\u00a8\u0414\3\2\2\2\u00aa")
        buf.write(u"\u0416\3\2\2\2\u00ac\u0418\3\2\2\2\u00ae\u041a\3\2\2")
        buf.write(u"\2\u00b0\u041c\3\2\2\2\u00b2\u0422\3\2\2\2\u00b4\u0424")
        buf.write(u"\3\2\2\2\u00b6\u0437\3\2\2\2\u00b8\u0439\3\2\2\2\u00ba")
        buf.write(u"\u043e\3\2\2\2\u00bc\u044c\3\2\2\2\u00be\u046d\3\2\2")
        buf.write(u"\2\u00c0\u046f\3\2\2\2\u00c2\u047a\3\2\2\2\u00c4\u0481")
        buf.write(u"\3\2\2\2\u00c6\u049a\3\2\2\2\u00c8\u049c\3\2\2\2\u00ca")
        buf.write(u"\u04a2\3\2\2\2\u00cc\u04a7\3\2\2\2\u00ce\u04ae\3\2\2")
        buf.write(u"\2\u00d0\u04bc\3\2\2\2\u00d2\u04c5\3\2\2\2\u00d4\u04d7")
        buf.write(u"\3\2\2\2\u00d6\u04e7\3\2\2\2\u00d8\u0500\3\2\2\2\u00da")
        buf.write(u"\u050c\3\2\2\2\u00dc\u050e\3\2\2\2\u00de\u051a\3\2\2")
        buf.write(u"\2\u00e0\u051d\3\2\2\2\u00e2\u054a\3\2\2\2\u00e4\u054c")
        buf.write(u"\3\2\2\2\u00e6\u0550\3\2\2\2\u00e8\u0555\3\2\2\2\u00ea")
        buf.write(u"\u0569\3\2\2\2\u00ec\u056b\3\2\2\2\u00ee\u0571\3\2\2")
        buf.write(u"\2\u00f0\u057b\3\2\2\2\u00f2\u0590\3\2\2\2\u00f4\u0596")
        buf.write(u"\3\2\2\2\u00f6\u0598\3\2\2\2\u00f8\u059e\3\2\2\2\u00fa")
        buf.write(u"\u05a6\3\2\2\2\u00fc\u05ba\3\2\2\2\u00fe\u05bc\3\2\2")
        buf.write(u"\2\u0100\u05ce\3\2\2\2\u0102\u05d0\3\2\2\2\u0104\u05de")
        buf.write(u"\3\2\2\2\u0106\u060f\3\2\2\2\u0108\u061a\3\2\2\2\u010a")
        buf.write(u"\u061f\3\2\2\2\u010c\u0623\3\2\2\2\u010e\u0633\3\2\2")
        buf.write(u"\2\u0110\u0635\3\2\2\2\u0112\u0637\3\2\2\2\u0114\u065f")
        buf.write(u"\3\2\2\2\u0116\u0661\3\2\2\2\u0118\u066b\3\2\2\2\u011a")
        buf.write(u"\u067c\3\2\2\2\u011c\u0690\3\2\2\2\u011e\u069a\3\2\2")
        buf.write(u"\2\u0120\u069e\3\2\2\2\u0122\u0124\5\4\3\2\u0123\u0122")
        buf.write(u"\3\2\2\2\u0124\u0127\3\2\2\2\u0125\u0123\3\2\2\2\u0125")
        buf.write(u"\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u0125\3\2\2")
        buf.write(u"\2\u0128\u0129\7\2\2\3\u0129\3\3\2\2\2\u012a\u0136\5")
        buf.write(u"\6\4\2\u012b\u0136\5z>\2\u012c\u0136\5\u008cG\2\u012d")
        buf.write(u"\u0136\5\b\5\2\u012e\u0136\5\f\7\2\u012f\u0136\5\n\6")
        buf.write(u"\2\u0130\u0136\5\16\b\2\u0131\u0136\5\22\n\2\u0132\u0136")
        buf.write(u"\5\26\f\2\u0133\u0136\5\30\r\2\u0134\u0136\5|?\2\u0135")
        buf.write(u"\u012a\3\2\2\2\u0135\u012b\3\2\2\2\u0135\u012c\3\2\2")
        buf.write(u"\2\u0135\u012d\3\2\2\2\u0135\u012e\3\2\2\2\u0135\u012f")
        buf.write(u"\3\2\2\2\u0135\u0130\3\2\2\2\u0135\u0131\3\2\2\2\u0135")
        buf.write(u"\u0132\3\2\2\2\u0135\u0133\3\2\2\2\u0135\u0134\3\2\2")
        buf.write(u"\2\u0136\5\3\2\2\2\u0137\u0138\7E\2\2\u0138\u0139\5\u0120")
        buf.write(u"\u0091\2\u0139\u013a\7\u0086\2\2\u013a\7\3\2\2\2\u013b")
        buf.write(u"\u013d\7x\2\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2\2\2")
        buf.write(u"\u013d\u013e\3\2\2\2\u013e\u013f\7D\2\2\u013f\u0142\5")
        buf.write(u"\20\t\2\u0140\u0141\7\u0091\2\2\u0141\u0143\5\u0120\u0091")
        buf.write(u"\2\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0148")
        buf.write(u"\3\2\2\2\u0144\u0145\7\u008d\2\2\u0145\u0146\5\32\16")
        buf.write(u"\2\u0146\u0147\7\u008c\2\2\u0147\u0149\3\2\2\2\u0148")
        buf.write(u"\u0144\3\2\2\2\u0148\u0149\3\2\2\2\u0149\u014b\3\2\2")
        buf.write(u"\2\u014a\u014c\5$\23\2\u014b\u014a\3\2\2\2\u014b\u014c")
        buf.write(u"\3\2\2\2\u014c\u014e\3\2\2\2\u014d\u014f\5*\26\2\u014e")
        buf.write(u"\u014d\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0150\3\2\2")
        buf.write(u"\2\u0150\u0151\7A\2\2\u0151\t\3\2\2\2\u0152\u0153\7D")
        buf.write(u"\2\2\u0153\u0154\5\20\t\2\u0154\u0156\7\u0080\2\2\u0155")
        buf.write(u"\u0157\5\u0120\u0091\2\u0156\u0155\3\2\2\2\u0156\u0157")
        buf.write(u"\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u015d\7\u0081\2\2")
        buf.write(u"\u0159\u015a\7\u008d\2\2\u015a\u015b\5\32\16\2\u015b")
        buf.write(u"\u015c\7\u008c\2\2\u015c\u015e\3\2\2\2\u015d\u0159\3")
        buf.write(u"\2\2\2\u015d\u015e\3\2\2\2\u015e\u0160\3\2\2\2\u015f")
        buf.write(u"\u0161\5$\23\2\u0160\u015f\3\2\2\2\u0160\u0161\3\2\2")
        buf.write(u"\2\u0161\u0163\3\2\2\2\u0162\u0164\5*\26\2\u0163\u0162")
        buf.write(u"\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0165\3\2\2\2\u0165")
        buf.write(u"\u0166\7A\2\2\u0166\13\3\2\2\2\u0167\u0168\7C\2\2\u0168")
        buf.write(u"\u016b\5\20\t\2\u0169\u016a\7\u0091\2\2\u016a\u016c\5")
        buf.write(u"\u0120\u0091\2\u016b\u0169\3\2\2\2\u016b\u016c\3\2\2")
        buf.write(u"\2\u016c\u016e\3\2\2\2\u016d\u016f\5$\23\2\u016e\u016d")
        buf.write(u"\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2\2\2\u0170")
        buf.write(u"\u0172\5\62\32\2\u0171\u0170\3\2\2\2\u0171\u0172\3\2")
        buf.write(u"\2\2\u0172\u0173\3\2\2\2\u0173\u0174\7A\2\2\u0174\r\3")
        buf.write(u"\2\2\2\u0175\u0176\7C\2\2\u0176\u0177\5\20\t\2\u0177")
        buf.write(u"\u0178\7\u0080\2\2\u0178\u0179\5\u0120\u0091\2\u0179")
        buf.write(u"\u017b\7\u0081\2\2\u017a\u017c\5\62\32\2\u017b\u017a")
        buf.write(u"\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017d\3\2\2\2\u017d")
        buf.write(u"\u017e\7A\2\2\u017e\17\3\2\2\2\u017f\u0185\5\u0120\u0091")
        buf.write(u"\2\u0180\u0181\7\u008d\2\2\u0181\u0182\5\32\16\2\u0182")
        buf.write(u"\u0183\7\u008c\2\2\u0183\u0186\3\2\2\2\u0184\u0186\5")
        buf.write(u"J&\2\u0185\u0180\3\2\2\2\u0185\u0184\3\2\2\2\u0185\u0186")
        buf.write(u"\3\2\2\2\u0186\21\3\2\2\2\u0187\u0188\7G\2\2\u0188\u018d")
        buf.write(u"\5\"\22\2\u0189\u018a\7\u008d\2\2\u018a\u018b\5\32\16")
        buf.write(u"\2\u018b\u018c\7\u008c\2\2\u018c\u018e\3\2\2\2\u018d")
        buf.write(u"\u0189\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u0192\3\2\2")
        buf.write(u"\2\u018f\u0191\5\24\13\2\u0190\u018f\3\2\2\2\u0191\u0194")
        buf.write(u"\3\2\2\2\u0192\u0190\3\2\2\2\u0192\u0193\3\2\2\2\u0193")
        buf.write(u"\u0195\3\2\2\2\u0194\u0192\3\2\2\2\u0195\u0196\7A\2\2")
        buf.write(u"\u0196\23\3\2\2\2\u0197\u019b\t\2\2\2\u0198\u019a\5*")
        buf.write(u"\26\2\u0199\u0198\3\2\2\2\u019a\u019d\3\2\2\2\u019b\u0199")
        buf.write(u"\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u01a4\3\2\2\2\u019d")
        buf.write(u"\u019b\3\2\2\2\u019e\u01a0\5*\26\2\u019f\u019e\3\2\2")
        buf.write(u"\2\u01a0\u01a1\3\2\2\2\u01a1\u019f\3\2\2\2\u01a1\u01a2")
        buf.write(u"\3\2\2\2\u01a2\u01a4\3\2\2\2\u01a3\u0197\3\2\2\2\u01a3")
        buf.write(u"\u019f\3\2\2\2\u01a4\25\3\2\2\2\u01a5\u01a6\7G\2\2\u01a6")
        buf.write(u"\u01a7\5\32\16\2\u01a7\u01a8\7\u0086\2\2\u01a8\27\3\2")
        buf.write(u"\2\2\u01a9\u01aa\7>\2\2\u01aa\u01af\5\u0120\u0091\2\u01ab")
        buf.write(u"\u01ac\7\u0087\2\2\u01ac\u01ae\5\u0120\u0091\2\u01ad")
        buf.write(u"\u01ab\3\2\2\2\u01ae\u01b1\3\2\2\2\u01af\u01ad\3\2\2")
        buf.write(u"\2\u01af\u01b0\3\2\2\2\u01b0\u01b2\3\2\2\2\u01b1\u01af")
        buf.write(u"\3\2\2\2\u01b2\u01b3\7\u0086\2\2\u01b3\31\3\2\2\2\u01b4")
        buf.write(u"\u01b9\5\"\22\2\u01b5\u01b6\7\u0087\2\2\u01b6\u01b8\5")
        buf.write(u"\"\22\2\u01b7\u01b5\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9")
        buf.write(u"\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\33\3\2\2\2\u01bb")
        buf.write(u"\u01b9\3\2\2\2\u01bc\u01c1\7J\2\2\u01bd\u01be\7\u0080")
        buf.write(u"\2\2\u01be\u01bf\5\36\20\2\u01bf\u01c0\7\u0081\2\2\u01c0")
        buf.write(u"\u01c2\3\2\2\2\u01c1\u01bd\3\2\2\2\u01c1\u01c2\3\2\2")
        buf.write(u"\2\u01c2\u01c4\3\2\2\2\u01c3\u01c5\5\u00a8U\2\u01c4\u01c3")
        buf.write(u"\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c7\3\2\2\2\u01c6")
        buf.write(u"\u01c8\7w\2\2\u01c7\u01c6\3\2\2\2\u01c7\u01c8\3\2\2\2")
        buf.write(u"\u01c8\u01c9\3\2\2\2\u01c9\u01ca\5\u00a4S\2\u01ca\35")
        buf.write(u"\3\2\2\2\u01cb\u01d0\5 \21\2\u01cc\u01cd\7\u0087\2\2")
        buf.write(u"\u01cd\u01cf\5 \21\2\u01ce\u01cc\3\2\2\2\u01cf\u01d2")
        buf.write(u"\3\2\2\2\u01d0\u01ce\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1")
        buf.write(u"\37\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d3\u01e8\7S\2\2\u01d4")
        buf.write(u"\u01e8\7T\2\2\u01d5\u01e8\7p\2\2\u01d6\u01e8\7s\2\2\u01d7")
        buf.write(u"\u01e8\7U\2\2\u01d8\u01e8\7l\2\2\u01d9\u01e8\7t\2\2\u01da")
        buf.write(u"\u01e8\7m\2\2\u01db\u01e8\7q\2\2\u01dc\u01e8\7r\2\2\u01dd")
        buf.write(u"\u01de\7n\2\2\u01de\u01df\7\u008b\2\2\u01df\u01e8\5\u0120")
        buf.write(u"\u0091\2\u01e0\u01e1\7o\2\2\u01e1\u01e2\7\u008b\2\2\u01e2")
        buf.write(u"\u01e3\5\u0120\u0091\2\u01e3\u01e4\7\u0091\2\2\u01e4")
        buf.write(u"\u01e8\3\2\2\2\u01e5\u01e8\5\u00acW\2\u01e6\u01e8\5\u0120")
        buf.write(u"\u0091\2\u01e7\u01d3\3\2\2\2\u01e7\u01d4\3\2\2\2\u01e7")
        buf.write(u"\u01d5\3\2\2\2\u01e7\u01d6\3\2\2\2\u01e7\u01d7\3\2\2")
        buf.write(u"\2\u01e7\u01d8\3\2\2\2\u01e7\u01d9\3\2\2\2\u01e7\u01da")
        buf.write(u"\3\2\2\2\u01e7\u01db\3\2\2\2\u01e7\u01dc\3\2\2\2\u01e7")
        buf.write(u"\u01dd\3\2\2\2\u01e7\u01e0\3\2\2\2\u01e7\u01e5\3\2\2")
        buf.write(u"\2\u01e7\u01e6\3\2\2\2\u01e8!\3\2\2\2\u01e9\u01ea\7\u008d")
        buf.write(u"\2\2\u01ea\u01eb\5\32\16\2\u01eb\u01ec\7\u008c\2\2\u01ec")
        buf.write(u"\u01f2\3\2\2\2\u01ed\u01ef\t\3\2\2\u01ee\u01ed\3\2\2")
        buf.write(u"\2\u01ee\u01ef\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f2")
        buf.write(u"\5\u0120\u0091\2\u01f1\u01e9\3\2\2\2\u01f1\u01ee\3\2")
        buf.write(u"\2\2\u01f2#\3\2\2\2\u01f3\u01f7\7\u0082\2\2\u01f4\u01f6")
        buf.write(u"\5&\24\2\u01f5\u01f4\3\2\2\2\u01f6\u01f9\3\2\2\2\u01f7")
        buf.write(u"\u01f5\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01fa\3\2\2")
        buf.write(u"\2\u01f9\u01f7\3\2\2\2\u01fa\u01fb\7\u0083\2\2\u01fb")
        buf.write(u"%\3\2\2\2\u01fc\u0200\5(\25\2\u01fd\u01ff\5\u00a4S\2")
        buf.write(u"\u01fe\u01fd\3\2\2\2\u01ff\u0202\3\2\2\2\u0200\u01fe")
        buf.write(u"\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0209\3\2\2\2\u0202")
        buf.write(u"\u0200\3\2\2\2\u0203\u0205\5\u00a4S\2\u0204\u0203\3\2")
        buf.write(u"\2\2\u0205\u0206\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207")
        buf.write(u"\3\2\2\2\u0207\u0209\3\2\2\2\u0208\u01fc\3\2\2\2\u0208")
        buf.write(u"\u0204\3\2\2\2\u0209\'\3\2\2\2\u020a\u020b\t\4\2\2\u020b")
        buf.write(u")\3\2\2\2\u020c\u0212\5\u008cG\2\u020d\u0212\5,\27\2")
        buf.write(u"\u020e\u0212\5.\30\2\u020f\u0212\5\34\17\2\u0210\u0212")
        buf.write(u"\5z>\2\u0211\u020c\3\2\2\2\u0211\u020d\3\2\2\2\u0211")
        buf.write(u"\u020e\3\2\2\2\u0211\u020f\3\2\2\2\u0211\u0210\3\2\2")
        buf.write(u"\2\u0212\u0213\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0214")
        buf.write(u"\3\2\2\2\u0214+\3\2\2\2\u0215\u0216\7\u009a\2\2\u0216")
        buf.write(u"\u0217\5\60\31\2\u0217-\3\2\2\2\u0218\u0219\7\u009b\2")
        buf.write(u"\2\u0219\u021a\5\60\31\2\u021a/\3\2\2\2\u021b\u021d\5")
        buf.write(u"@!\2\u021c\u021b\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u021e")
        buf.write(u"\3\2\2\2\u021e\u0220\5:\36\2\u021f\u0221\5\u00ceh\2\u0220")
        buf.write(u"\u021f\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222\3\2\2")
        buf.write(u"\2\u0222\u0223\7\u0086\2\2\u0223\61\3\2\2\2\u0224\u022a")
        buf.write(u"\5|?\2\u0225\u022a\5\u008cG\2\u0226\u022a\5\64\33\2\u0227")
        buf.write(u"\u022a\5\66\34\2\u0228\u022a\5B\"\2\u0229\u0224\3\2\2")
        buf.write(u"\2\u0229\u0225\3\2\2\2\u0229\u0226\3\2\2\2\u0229\u0227")
        buf.write(u"\3\2\2\2\u0229\u0228\3\2\2\2\u022a\u022b\3\2\2\2\u022b")
        buf.write(u"\u0229\3\2\2\2\u022b\u022c\3\2\2\2\u022c\63\3\2\2\2\u022d")
        buf.write(u"\u022e\7\u009a\2\2\u022e\u022f\58\35\2\u022f\65\3\2\2")
        buf.write(u"\2\u0230\u0231\7\u009b\2\2\u0231\u0232\58\35\2\u0232")
        buf.write(u"\67\3\2\2\2\u0233\u0235\5@!\2\u0234\u0233\3\2\2\2\u0234")
        buf.write(u"\u0235\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0238\5:\36")
        buf.write(u"\2\u0237\u0239\5\u009eP\2\u0238\u0237\3\2\2\2\u0238\u0239")
        buf.write(u"\3\2\2\2\u0239\u023b\3\2\2\2\u023a\u023c\7\u0086\2\2")
        buf.write(u"\u023b\u023a\3\2\2\2\u023b\u023c\3\2\2\2\u023c\u023d")
        buf.write(u"\3\2\2\2\u023d\u023e\5\u00e8u\2\u023e9\3\2\2\2\u023f")
        buf.write(u"\u024a\5> \2\u0240\u0242\5<\37\2\u0241\u0240\3\2\2\2")
        buf.write(u"\u0242\u0243\3\2\2\2\u0243\u0241\3\2\2\2\u0243\u0244")
        buf.write(u"\3\2\2\2\u0244\u0247\3\2\2\2\u0245\u0246\7\u0087\2\2")
        buf.write(u"\u0246\u0248\7\u00ac\2\2\u0247\u0245\3\2\2\2\u0247\u0248")
        buf.write(u"\3\2\2\2\u0248\u024a\3\2\2\2\u0249\u023f\3\2\2\2\u0249")
        buf.write(u"\u0241\3\2\2\2\u024a;\3\2\2\2\u024b\u024d\5> \2\u024c")
        buf.write(u"\u024b\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u024e\3\2\2")
        buf.write(u"\2\u024e\u0252\7\u0091\2\2\u024f\u0251\5@!\2\u0250\u024f")
        buf.write(u"\3\2\2\2\u0251\u0254\3\2\2\2\u0252\u0250\3\2\2\2\u0252")
        buf.write(u"\u0253\3\2\2\2\u0253\u0256\3\2\2\2\u0254\u0252\3\2\2")
        buf.write(u"\2\u0255\u0257\5\u00aaV\2\u0256\u0255\3\2\2\2\u0256\u0257")
        buf.write(u"\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u0259\5\u0120\u0091")
        buf.write(u"\2\u0259=\3\2\2\2\u025a\u025d\5\u0120\u0091\2\u025b\u025d")
        buf.write(u"\7\30\2\2\u025c\u025a\3\2\2\2\u025c\u025b\3\2\2\2\u025d")
        buf.write(u"?\3\2\2\2\u025e\u025f\7\u0080\2\2\u025f\u0260\5\u00d6")
        buf.write(u"l\2\u0260\u0261\7\u0081\2\2\u0261A\3\2\2\2\u0262\u0263")
        buf.write(u"\7P\2\2\u0263\u0264\5D#\2\u0264\u0265\7\u0086\2\2\u0265")
        buf.write(u"\u026b\3\2\2\2\u0266\u0267\7?\2\2\u0267\u0268\5D#\2\u0268")
        buf.write(u"\u0269\7\u0086\2\2\u0269\u026b\3\2\2\2\u026a\u0262\3")
        buf.write(u"\2\2\2\u026a\u0266\3\2\2\2\u026bC\3\2\2\2\u026c\u0271")
        buf.write(u"\5F$\2\u026d\u026e\7\u0087\2\2\u026e\u0270\5F$\2\u026f")
        buf.write(u"\u026d\3\2\2\2\u0270\u0273\3\2\2\2\u0271\u026f\3\2\2")
        buf.write(u"\2\u0271\u0272\3\2\2\2\u0272E\3\2\2\2\u0273\u0271\3\2")
        buf.write(u"\2\2\u0274\u0277\5\u0120\u0091\2\u0275\u0276\7\u008b")
        buf.write(u"\2\2\u0276\u0278\5\u0120\u0091\2\u0277\u0275\3\2\2\2")
        buf.write(u"\u0277\u0278\3\2\2\2\u0278G\3\2\2\2\u0279\u027b\5\u00ac")
        buf.write(u"W\2\u027a\u0279\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027c")
        buf.write(u"\3\2\2\2\u027c\u027e\5\u00b6\\\2\u027d\u027f\5\u00ac")
        buf.write(u"W\2\u027e\u027d\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u0280")
        buf.write(u"\3\2\2\2\u0280\u0281\7\u0080\2\2\u0281\u0284\7\u00a0")
        buf.write(u"\2\2\u0282\u0285\5\u00acW\2\u0283\u0285\5\u00b6\\\2\u0284")
        buf.write(u"\u0282\3\2\2\2\u0284\u0283\3\2\2\2\u0284\u0285\3\2\2")
        buf.write(u"\2\u0285\u0286\3\2\2\2\u0286\u0288\7\u0081\2\2\u0287")
        buf.write(u"\u0289\5V,\2\u0288\u0287\3\2\2\2\u0288\u0289\3\2\2\2")
        buf.write(u"\u0289I\3\2\2\2\u028a\u0293\7\u008d\2\2\u028b\u0290\5")
        buf.write(u"L\'\2\u028c\u028d\7\u0087\2\2\u028d\u028f\5L\'\2\u028e")
        buf.write(u"\u028c\3\2\2\2\u028f\u0292\3\2\2\2\u0290\u028e\3\2\2")
        buf.write(u"\2\u0290\u0291\3\2\2\2\u0291\u0294\3\2\2\2\u0292\u0290")
        buf.write(u"\3\2\2\2\u0293\u028b\3\2\2\2\u0293\u0294\3\2\2\2\u0294")
        buf.write(u"\u0295\3\2\2\2\u0295\u0296\7\u008c\2\2\u0296K\3\2\2\2")
        buf.write(u"\u0297\u0299\5\u00b0Y\2\u0298\u0297\3\2\2\2\u0299\u029c")
        buf.write(u"\3\2\2\2\u029a\u0298\3\2\2\2\u029a\u029b\3\2\2\2\u029b")
        buf.write(u"\u029d\3\2\2\2\u029c\u029a\3\2\2\2\u029d\u029e\5\u00b6")
        buf.write(u"\\\2\u029eM\3\2\2\2\u029f\u02a0\7\u008a\2\2\u02a0\u02ac")
        buf.write(u"\7\u0082\2\2\u02a1\u02a6\5P)\2\u02a2\u02a3\7\u0087\2")
        buf.write(u"\2\u02a3\u02a5\5P)\2\u02a4\u02a2\3\2\2\2\u02a5\u02a8")
        buf.write(u"\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7")
        buf.write(u"\u02aa\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a9\u02ab\7\u0087")
        buf.write(u"\2\2\u02aa\u02a9\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab\u02ad")
        buf.write(u"\3\2\2\2\u02ac\u02a1\3\2\2\2\u02ac\u02ad\3\2\2\2\u02ad")
        buf.write(u"\u02ae\3\2\2\2\u02ae\u02af\7\u0083\2\2\u02afO\3\2\2\2")
        buf.write(u"\u02b0\u02b1\5\u0108\u0085\2\u02b1\u02b2\7\u0091\2\2")
        buf.write(u"\u02b2\u02b3\5\u0104\u0083\2\u02b3Q\3\2\2\2\u02b4\u02b5")
        buf.write(u"\7\u008a\2\2\u02b5\u02ba\7\u0084\2\2\u02b6\u02b8\5\u0102")
        buf.write(u"\u0082\2\u02b7\u02b9\7\u0087\2\2\u02b8\u02b7\3\2\2\2")
        buf.write(u"\u02b8\u02b9\3\2\2\2\u02b9\u02bb\3\2\2\2\u02ba\u02b6")
        buf.write(u"\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc")
        buf.write(u"\u02bd\7\u0085\2\2\u02bdS\3\2\2\2\u02be\u02bf\7\u008a")
        buf.write(u"\2\2\u02bf\u02c0\7\u0080\2\2\u02c0\u02c1\5\u0104\u0083")
        buf.write(u"\2\u02c1\u02c2\7\u0081\2\2\u02c2\u02c9\3\2\2\2\u02c3")
        buf.write(u"\u02c6\7\u008a\2\2\u02c4\u02c7\5\u011c\u008f\2\u02c5")
        buf.write(u"\u02c7\5\u0120\u0091\2\u02c6\u02c4\3\2\2\2\u02c6\u02c5")
        buf.write(u"\3\2\2\2\u02c7\u02c9\3\2\2\2\u02c8\u02be\3\2\2\2\u02c8")
        buf.write(u"\u02c3\3\2\2\2\u02c9U\3\2\2\2\u02ca\u02d6\7\u0080\2\2")
        buf.write(u"\u02cb\u02ce\5X-\2\u02cc\u02ce\7\"\2\2\u02cd\u02cb\3")
        buf.write(u"\2\2\2\u02cd\u02cc\3\2\2\2\u02ce\u02d3\3\2\2\2\u02cf")
        buf.write(u"\u02d0\7\u0087\2\2\u02d0\u02d2\5X-\2\u02d1\u02cf\3\2")
        buf.write(u"\2\2\u02d2\u02d5\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d3\u02d4")
        buf.write(u"\3\2\2\2\u02d4\u02d7\3\2\2\2\u02d5\u02d3\3\2\2\2\u02d6")
        buf.write(u"\u02cd\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d8\3\2\2")
        buf.write(u"\2\u02d8\u02d9\7\u0081\2\2\u02d9W\3\2\2\2\u02da\u02dd")
        buf.write(u"\5n8\2\u02db\u02dd\5\u00d6l\2\u02dc\u02da\3\2\2\2\u02dc")
        buf.write(u"\u02db\3\2\2\2\u02ddY\3\2\2\2\u02de\u02e0\7\u00a0\2\2")
        buf.write(u"\u02df\u02e1\5\u00b6\\\2\u02e0\u02df\3\2\2\2\u02e0\u02e1")
        buf.write(u"\3\2\2\2\u02e1\u02e3\3\2\2\2\u02e2\u02e4\5\u00acW\2\u02e3")
        buf.write(u"\u02e2\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e6\3\2\2")
        buf.write(u"\2\u02e5\u02e7\5V,\2\u02e6\u02e5\3\2\2\2\u02e6\u02e7")
        buf.write(u"\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02e9\5\u00e8u\2\u02e9")
        buf.write(u"[\3\2\2\2\u02ea\u02eb\7\u0084\2\2\u02eb\u02ec\5^\60\2")
        buf.write(u"\u02ec\u02ed\5`\61\2\u02ed\u02ee\7\u0085\2\2\u02ee]\3")
        buf.write(u"\2\2\2\u02ef\u02f2\5\u0104\u0083\2\u02f0\u02f2\5\u00b6")
        buf.write(u"\\\2\u02f1\u02ef\3\2\2\2\u02f1\u02f0\3\2\2\2\u02f2_\3")
        buf.write(u"\2\2\2\u02f3\u02fa\5> \2\u02f4\u02f6\5b\62\2\u02f5\u02f4")
        buf.write(u"\3\2\2\2\u02f6\u02f7\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f7")
        buf.write(u"\u02f8\3\2\2\2\u02f8\u02fa\3\2\2\2\u02f9\u02f3\3\2\2")
        buf.write(u"\2\u02f9\u02f5\3\2\2\2\u02faa\3\2\2\2\u02fb\u02fd\5>")
        buf.write(u" \2\u02fc\u02fb\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02fe")
        buf.write(u"\3\2\2\2\u02fe\u02ff\7\u0091\2\2\u02ff\u0304\5d\63\2")
        buf.write(u"\u0300\u0301\7\u0087\2\2\u0301\u0303\5d\63\2\u0302\u0300")
        buf.write(u"\3\2\2\2\u0303\u0306\3\2\2\2\u0304\u0302\3\2\2\2\u0304")
        buf.write(u"\u0305\3\2\2\2\u0305c\3\2\2\2\u0306\u0304\3\2\2\2\u0307")
        buf.write(u"\u0309\5\u0102\u0082\2\u0308\u030a\5\u00acW\2\u0309\u0308")
        buf.write(u"\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030f\3\2\2\2\u030b")
        buf.write(u"\u030c\7\u0082\2\2\u030c\u030d\5\u00d4k\2\u030d\u030e")
        buf.write(u"\7\u0083\2\2\u030e\u0310\3\2\2\2\u030f\u030b\3\2\2\2")
        buf.write(u"\u030f\u0310\3\2\2\2\u0310e\3\2\2\2\u0311\u0312\7N\2")
        buf.write(u"\2\u0312\u0313\7\u0080\2\2\u0313\u0314\5h\65\2\u0314")
        buf.write(u"\u0315\7\u0081\2\2\u0315g\3\2\2\2\u0316\u0320\5> \2\u0317")
        buf.write(u"\u0319\5> \2\u0318\u0317\3\2\2\2\u0318\u0319\3\2\2\2")
        buf.write(u"\u0319\u031a\3\2\2\2\u031a\u031c\7\u0091\2\2\u031b\u0318")
        buf.write(u"\3\2\2\2\u031c\u031d\3\2\2\2\u031d\u031b\3\2\2\2\u031d")
        buf.write(u"\u031e\3\2\2\2\u031e\u0320\3\2\2\2\u031f\u0316\3\2\2")
        buf.write(u"\2\u031f\u031b\3\2\2\2\u0320i\3\2\2\2\u0321\u0322\7G")
        buf.write(u"\2\2\u0322\u0323\7\u0080\2\2\u0323\u0324\5\"\22\2\u0324")
        buf.write(u"\u0325\7\u0081\2\2\u0325k\3\2\2\2\u0326\u0327\7@\2\2")
        buf.write(u"\u0327\u0328\7\u0080\2\2\u0328\u0329\5\u00d6l\2\u0329")
        buf.write(u"\u032a\7\u0081\2\2\u032am\3\2\2\2\u032b\u032c\5\u009a")
        buf.write(u"N\2\u032c\u032d\5\u00e0q\2\u032do\3\2\2\2\u032e\u032f")
        buf.write(u"\7Q\2\2\u032f\u0330\7\u0080\2\2\u0330\u0331\5\u0120\u0091")
        buf.write(u"\2\u0331\u0332\7\u0081\2\2\u0332\u0336\3\2\2\2\u0333")
        buf.write(u"\u0334\7Q\2\2\u0334\u0336\5\u0104\u0083\2\u0335\u032e")
        buf.write(u"\3\2\2\2\u0335\u0333\3\2\2\2\u0336q\3\2\2\2\u0337\u0338")
        buf.write(u"\7R\2\2\u0338\u033c\5\u00e8u\2\u0339\u033b\5t;\2\u033a")
        buf.write(u"\u0339\3\2\2\2\u033b\u033e\3\2\2\2\u033c\u033a\3\2\2")
        buf.write(u"\2\u033c\u033d\3\2\2\2\u033d\u0341\3\2\2\2\u033e\u033c")
        buf.write(u"\3\2\2\2\u033f\u0340\7B\2\2\u0340\u0342\5\u00e8u\2\u0341")
        buf.write(u"\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342s\3\2\2\2\u0343")
        buf.write(u"\u0344\7=\2\2\u0344\u0345\7\u0080\2\2\u0345\u0346\5n")
        buf.write(u"8\2\u0346\u0347\7\u0081\2\2\u0347\u0348\5\u00e8u\2\u0348")
        buf.write(u"u\3\2\2\2\u0349\u034a\7O\2\2\u034a\u034b\7\u0080\2\2")
        buf.write(u"\u034b\u034c\5\u0104\u0083\2\u034c\u034d\7\u0081\2\2")
        buf.write(u"\u034d\u034e\5\u00e8u\2\u034ew\3\2\2\2\u034f\u0350\7")
        buf.write(u"<\2\2\u0350\u0351\5\u00e8u\2\u0351y\3\2\2\2\u0352\u0353")
        buf.write(u"\5~@\2\u0353\u0354\7\u0086\2\2\u0354{\3\2\2\2\u0355\u0356")
        buf.write(u"\5~@\2\u0356\u0357\5\u00e8u\2\u0357}\3\2\2\2\u0358\u035a")
        buf.write(u"\5\u009aN\2\u0359\u0358\3\2\2\2\u0359\u035a\3\2\2\2\u035a")
        buf.write(u"\u035b\3\2\2\2\u035b\u035c\5\u0120\u0091\2\u035c\u035e")
        buf.write(u"\7\u0080\2\2\u035d\u035f\5\u00caf\2\u035e\u035d\3\2\2")
        buf.write(u"\2\u035e\u035f\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0361")
        buf.write(u"\7\u0081\2\2\u0361\u0363\3\2\2\2\u0362\u0364\5\u009c")
        buf.write(u"O\2\u0363\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364\177")
        buf.write(u"\3\2\2\2\u0365\u0367\5\u0082B\2\u0366\u0368\5\u0084C")
        buf.write(u"\2\u0367\u0366\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u0081")
        buf.write(u"\3\2\2\2\u0369\u036c\7\7\2\2\u036a\u036c\5\u0120\u0091")
        buf.write(u"\2\u036b\u0369\3\2\2\2\u036b\u036a\3\2\2\2\u036c\u0083")
        buf.write(u"\3\2\2\2\u036d\u036f\7\u0080\2\2\u036e\u0370\5\u0086")
        buf.write(u"D\2\u036f\u036e\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u0371")
        buf.write(u"\3\2\2\2\u0371\u0372\7\u0081\2\2\u0372\u0085\3\2\2\2")
        buf.write(u"\u0373\u0378\5\u0088E\2\u0374\u0375\7\u0087\2\2\u0375")
        buf.write(u"\u0377\5\u0088E\2\u0376\u0374\3\2\2\2\u0377\u037a\3\2")
        buf.write(u"\2\2\u0378\u0376\3\2\2\2\u0378\u0379\3\2\2\2\u0379\u0087")
        buf.write(u"\3\2\2\2\u037a\u0378\3\2\2\2\u037b\u0380\5\u0080A\2\u037c")
        buf.write(u"\u0380\5\u011c\u008f\2\u037d\u0380\5\u011e\u0090\2\u037e")
        buf.write(u"\u0380\5\u008aF\2\u037f\u037b\3\2\2\2\u037f\u037c\3\2")
        buf.write(u"\2\2\u037f\u037d\3\2\2\2\u037f\u037e\3\2\2\2\u0380\u0089")
        buf.write(u"\3\2\2\2\u0381\u0382\5\u0082B\2\u0382\u0386\7\u008b\2")
        buf.write(u"\2\u0383\u0387\5\u011c\u008f\2\u0384\u0387\5\u0082B\2")
        buf.write(u"\u0385\u0387\5\u011e\u0090\2\u0386\u0383\3\2\2\2\u0386")
        buf.write(u"\u0384\3\2\2\2\u0386\u0385\3\2\2\2\u0387\u008b\3\2\2")
        buf.write(u"\2\u0388\u038d\5\u008eH\2\u0389\u038d\5\u0090I\2\u038a")
        buf.write(u"\u038d\5\u0092J\2\u038b\u038d\5\u0094K\2\u038c\u0388")
        buf.write(u"\3\2\2\2\u038c\u0389\3\2\2\2\u038c\u038a\3\2\2\2\u038c")
        buf.write(u"\u038b\3\2\2\2\u038d\u008d\3\2\2\2\u038e\u0390\5\u009c")
        buf.write(u"O\2\u038f\u038e\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0391")
        buf.write(u"\3\2\2\2\u0391\u0393\5\u0120\u0091\2\u0392\u0394\5\u009c")
        buf.write(u"O\2\u0393\u0392\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0395")
        buf.write(u"\3\2\2\2\u0395\u0396\7\u0080\2\2\u0396\u0397\5\u00c6")
        buf.write(u"d\2\u0397\u0398\7\u0081\2\2\u0398\u0399\7\u0086\2\2\u0399")
        buf.write(u"\u008f\3\2\2\2\u039a\u039c\5\u009cO\2\u039b\u039a\3\2")
        buf.write(u"\2\2\u039b\u039c\3\2\2\2\u039c\u039e\3\2\2\2\u039d\u039f")
        buf.write(u"\7\37\2\2\u039e\u039d\3\2\2\2\u039e\u039f\3\2\2\2\u039f")
        buf.write(u"\u03a0\3\2\2\2\u03a0\u03a2\5\u00be`\2\u03a1\u03a3\5\u0120")
        buf.write(u"\u0091\2\u03a2\u03a1\3\2\2\2\u03a2\u03a3\3\2\2\2\u03a3")
        buf.write(u"\u03a4\3\2\2\2\u03a4\u03a5\7\u0086\2\2\u03a5\u0091\3")
        buf.write(u"\2\2\2\u03a6\u03a7\5\u009aN\2\u03a7\u03a8\5\u009eP\2")
        buf.write(u"\u03a8\u03ab\3\2\2\2\u03a9\u03ab\5\u009aN\2\u03aa\u03a6")
        buf.write(u"\3\2\2\2\u03aa\u03a9\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac")
        buf.write(u"\u03ad\7\u0086\2\2\u03ad\u0093\3\2\2\2\u03ae\u03b0\5")
        buf.write(u"\u009cO\2\u03af\u03ae\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0")
        buf.write(u"\u03b1\3\2\2\2\u03b1\u03b6\7\37\2\2\u03b2\u03b3\5\u009a")
        buf.write(u"N\2\u03b3\u03b4\5\u0096L\2\u03b4\u03b7\3\2\2\2\u03b5")
        buf.write(u"\u03b7\5\u009aN\2\u03b6\u03b2\3\2\2\2\u03b6\u03b5\3\2")
        buf.write(u"\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\7\u0086\2\2\u03b9")
        buf.write(u"\u0095\3\2\2\2\u03ba\u03bf\5\u0098M\2\u03bb\u03bc\7\u0087")
        buf.write(u"\2\2\u03bc\u03be\5\u0098M\2\u03bd\u03bb\3\2\2\2\u03be")
        buf.write(u"\u03c1\3\2\2\2\u03bf\u03bd\3\2\2\2\u03bf\u03c0\3\2\2")
        buf.write(u"\2\u03c0\u0097\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c2\u03c4")
        buf.write(u"\5\u00ccg\2\u03c3\u03c2\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4")
        buf.write(u"\u03c5\3\2\2\2\u03c5\u03c6\5\u00c6d\2\u03c6\u0099\3\2")
        buf.write(u"\2\2\u03c7\u03d0\5\u00aeX\2\u03c8\u03d0\5\u009cO\2\u03c9")
        buf.write(u"\u03d0\5\u00aaV\2\u03ca\u03d0\5\u00acW\2\u03cb\u03d0")
        buf.write(u"\5\u00a8U\2\u03cc\u03d0\5\u00b0Y\2\u03cd\u03d0\5\u00b2")
        buf.write(u"Z\2\u03ce\u03d0\5\u00b6\\\2\u03cf\u03c7\3\2\2\2\u03cf")
        buf.write(u"\u03c8\3\2\2\2\u03cf\u03c9\3\2\2\2\u03cf\u03ca\3\2\2")
        buf.write(u"\2\u03cf\u03cb\3\2\2\2\u03cf\u03cc\3\2\2\2\u03cf\u03cd")
        buf.write(u"\3\2\2\2\u03cf\u03ce\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1")
        buf.write(u"\u03cf\3\2\2\2\u03d1\u03d2\3\2\2\2\u03d2\u009b\3\2\2")
        buf.write(u"\2\u03d3\u03d4\7V\2\2\u03d4\u03d5\7\u0080\2\2\u03d5\u03d6")
        buf.write(u"\7\u0080\2\2\u03d6\u03db\5\u0080A\2\u03d7\u03d8\7\u0087")
        buf.write(u"\2\2\u03d8\u03da\5\u0080A\2\u03d9\u03d7\3\2\2\2\u03da")
        buf.write(u"\u03dd\3\2\2\2\u03db\u03d9\3\2\2\2\u03db\u03dc\3\2\2")
        buf.write(u"\2\u03dc\u03de\3\2\2\2\u03dd\u03db\3\2\2\2\u03de\u03df")
        buf.write(u"\7\u0081\2\2\u03df\u03e0\7\u0081\2\2\u03e0\u009d\3\2")
        buf.write(u"\2\2\u03e1\u03e6\5\u00a0Q\2\u03e2\u03e3\7\u0087\2\2\u03e3")
        buf.write(u"\u03e5\5\u00a0Q\2\u03e4\u03e2\3\2\2\2\u03e5\u03e8\3\2")
        buf.write(u"\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u009f")
        buf.write(u"\3\2\2\2\u03e8\u03e6\3\2\2\2\u03e9\u03ec\5\u00e0q\2\u03ea")
        buf.write(u"\u03eb\7\u008b\2\2\u03eb\u03ed\5\u010a\u0086\2\u03ec")
        buf.write(u"\u03ea\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u00a1\3\2\2")
        buf.write(u"\2\u03ee\u03fb\t\5\2\2\u03ef\u03fc\5\u0120\u0091\2\u03f0")
        buf.write(u"\u03f2\5\u0120\u0091\2\u03f1\u03f0\3\2\2\2\u03f1\u03f2")
        buf.write(u"\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f5\7\u0082\2\2")
        buf.write(u"\u03f4\u03f6\5\u00a4S\2\u03f5\u03f4\3\2\2\2\u03f6\u03f7")
        buf.write(u"\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8")
        buf.write(u"\u03f9\3\2\2\2\u03f9\u03fa\7\u0083\2\2\u03fa\u03fc\3")
        buf.write(u"\2\2\2\u03fb\u03ef\3\2\2\2\u03fb\u03f1\3\2\2\2\u03fc")
        buf.write(u"\u00a3\3\2\2\2\u03fd\u03fe\5\u00a6T\2\u03fe\u0400\5\u00ba")
        buf.write(u"^\2\u03ff\u0401\5\u00ceh\2\u0400\u03ff\3\2\2\2\u0400")
        buf.write(u"\u0401\3\2\2\2\u0401\u0402\3\2\2\2\u0402\u0403\7\u0086")
        buf.write(u"\2\2\u0403\u00a5\3\2\2\2\u0404\u040b\5\u00aaV\2\u0405")
        buf.write(u"\u040b\5\u00acW\2\u0406\u040b\5\u00a8U\2\u0407\u040b")
        buf.write(u"\5\u00b0Y\2\u0408\u040b\5\u00b2Z\2\u0409\u040b\5\u00b6")
        buf.write(u"\\\2\u040a\u0404\3\2\2\2\u040a\u0405\3\2\2\2\u040a\u0406")
        buf.write(u"\3\2\2\2\u040a\u0407\3\2\2\2\u040a\u0408\3\2\2\2\u040a")
        buf.write(u"\u0409\3\2\2\2\u040b\u040c\3\2\2\2\u040c\u040a\3\2\2")
        buf.write(u"\2\u040c\u040d\3\2\2\2\u040d\u00a7\3\2\2\2\u040e\u040f")
        buf.write(u"\7v\2\2\u040f\u0410\7\u0080\2\2\u0410\u0411\5\u0120\u0091")
        buf.write(u"\2\u0411\u0412\7\u0081\2\2\u0412\u0415\3\2\2\2\u0413")
        buf.write(u"\u0415\7u\2\2\u0414\u040e\3\2\2\2\u0414\u0413\3\2\2\2")
        buf.write(u"\u0415\u00a9\3\2\2\2\u0416\u0417\t\6\2\2\u0417\u00ab")
        buf.write(u"\3\2\2\2\u0418\u0419\t\7\2\2\u0419\u00ad\3\2\2\2\u041a")
        buf.write(u"\u041b\t\b\2\2\u041b\u00af\3\2\2\2\u041c\u041d\t\t\2")
        buf.write(u"\2\u041d\u00b1\3\2\2\2\u041e\u0423\7\7\2\2\u041f\u0423")
        buf.write(u"\7#\2\2\u0420\u0423\7\27\2\2\u0421\u0423\5\u00b4[\2\u0422")
        buf.write(u"\u041e\3\2\2\2\u0422\u041f\3\2\2\2\u0422\u0420\3\2\2")
        buf.write(u"\2\u0422\u0421\3\2\2\2\u0423\u00b3\3\2\2\2\u0424\u0425")
        buf.write(u"\t\n\2\2\u0425\u00b5\3\2\2\2\u0426\u0438\7\"\2\2\u0427")
        buf.write(u"\u0438\7\6\2\2\u0428\u0438\7\31\2\2\u0429\u0438\7\24")
        buf.write(u"\2\2\u042a\u0438\7\25\2\2\u042b\u0438\7\17\2\2\u042c")
        buf.write(u"\u0438\7\13\2\2\u042d\u0438\7\32\2\2\u042e\u0438\7!\2")
        buf.write(u"\2\u042f\u0438\5\u00b8]\2\u0430\u0438\5\20\t\2\u0431")
        buf.write(u"\u0438\5\u00a2R\2\u0432\u0438\5\u00be`\2\u0433\u0435")
        buf.write(u"\5\u0120\u0091\2\u0434\u0436\5\u00ccg\2\u0435\u0434\3")
        buf.write(u"\2\2\2\u0435\u0436\3\2\2\2\u0436\u0438\3\2\2\2\u0437")
        buf.write(u"\u0426\3\2\2\2\u0437\u0427\3\2\2\2\u0437\u0428\3\2\2")
        buf.write(u"\2\u0437\u0429\3\2\2\2\u0437\u042a\3\2\2\2\u0437\u042b")
        buf.write(u"\3\2\2\2\u0437\u042c\3\2\2\2\u0437\u042d\3\2\2\2\u0437")
        buf.write(u"\u042e\3\2\2\2\u0437\u042f\3\2\2\2\u0437\u0430\3\2\2")
        buf.write(u"\2\u0437\u0431\3\2\2\2\u0437\u0432\3\2\2\2\u0437\u0433")
        buf.write(u"\3\2\2\2\u0438\u00b7\3\2\2\2\u0439\u043a\7a\2\2\u043a")
        buf.write(u"\u043b\7\u0080\2\2\u043b\u043c\5\u0104\u0083\2\u043c")
        buf.write(u"\u043d\7\u0081\2\2\u043d\u00b9\3\2\2\2\u043e\u0443\5")
        buf.write(u"\u00bc_\2\u043f\u0440\7\u0087\2\2\u0440\u0442\5\u00bc")
        buf.write(u"_\2\u0441\u043f\3\2\2\2\u0442\u0445\3\2\2\2\u0443\u0441")
        buf.write(u"\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u00bb\3\2\2\2\u0445")
        buf.write(u"\u0443\3\2\2\2\u0446\u044d\5\u00e0q\2\u0447\u0449\5\u00e0")
        buf.write(u"q\2\u0448\u0447\3\2\2\2\u0448\u0449\3\2\2\2\u0449\u044a")
        buf.write(u"\3\2\2\2\u044a\u044b\7\u0091\2\2\u044b\u044d\5\u011c")
        buf.write(u"\u008f\2\u044c\u0446\3\2\2\2\u044c\u0448\3\2\2\2\u044d")
        buf.write(u"\u00bd\3\2\2\2\u044e\u0454\7\r\2\2\u044f\u0451\5\u0120")
        buf.write(u"\u0091\2\u0450\u044f\3\2\2\2\u0450\u0451\3\2\2\2\u0451")
        buf.write(u"\u0452\3\2\2\2\u0452\u0453\7\u0091\2\2\u0453\u0455\5")
        buf.write(u"\u00d6l\2\u0454\u0450\3\2\2\2\u0454\u0455\3\2\2\2\u0455")
        buf.write(u"\u0461\3\2\2\2\u0456\u045b\5\u0120\u0091\2\u0457\u0458")
        buf.write(u"\7\u0082\2\2\u0458\u0459\5\u00c0a\2\u0459\u045a\7\u0083")
        buf.write(u"\2\2\u045a\u045c\3\2\2\2\u045b\u0457\3\2\2\2\u045b\u045c")
        buf.write(u"\3\2\2\2\u045c\u0462\3\2\2\2\u045d\u045e\7\u0082\2\2")
        buf.write(u"\u045e\u045f\5\u00c0a\2\u045f\u0460\7\u0083\2\2\u0460")
        buf.write(u"\u0462\3\2\2\2\u0461\u0456\3\2\2\2\u0461\u045d\3\2\2")
        buf.write(u"\2\u0462\u046e\3\2\2\2\u0463\u0464\t\13\2\2\u0464\u0465")
        buf.write(u"\7\u0080\2\2\u0465\u0466\5\u00d6l\2\u0466\u0467\7\u0087")
        buf.write(u"\2\2\u0467\u0468\5\u0120\u0091\2\u0468\u0469\7\u0081")
        buf.write(u"\2\2\u0469\u046a\7\u0082\2\2\u046a\u046b\5\u00c0a\2\u046b")
        buf.write(u"\u046c\7\u0083\2\2\u046c\u046e\3\2\2\2\u046d\u044e\3")
        buf.write(u"\2\2\2\u046d\u0463\3\2\2\2\u046e\u00bf\3\2\2\2\u046f")
        buf.write(u"\u0474\5\u00c2b\2\u0470\u0471\7\u0087\2\2\u0471\u0473")
        buf.write(u"\5\u00c2b\2\u0472\u0470\3\2\2\2\u0473\u0476\3\2\2\2\u0474")
        buf.write(u"\u0472\3\2\2\2\u0474\u0475\3\2\2\2\u0475\u0478\3\2\2")
        buf.write(u"\2\u0476\u0474\3\2\2\2\u0477\u0479\7\u0087\2\2\u0478")
        buf.write(u"\u0477\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u00c1\3\2\2")
        buf.write(u"\2\u047a\u047d\5\u00c4c\2\u047b\u047c\7\u008b\2\2\u047c")
        buf.write(u"\u047e\5\u0104\u0083\2\u047d\u047b\3\2\2\2\u047d\u047e")
        buf.write(u"\3\2\2\2\u047e\u00c3\3\2\2\2\u047f\u0482\5\u0120\u0091")
        buf.write(u"\2\u0480\u0482\7\t\2\2\u0481\u047f\3\2\2\2\u0481\u0480")
        buf.write(u"\3\2\2\2\u0482\u00c5\3\2\2\2\u0483\u0489\5\u0120\u0091")
        buf.write(u"\2\u0484\u0485\7\u0080\2\2\u0485\u0486\5\u00e0q\2\u0486")
        buf.write(u"\u0487\7\u0081\2\2\u0487\u0489\3\2\2\2\u0488\u0483\3")
        buf.write(u"\2\2\2\u0488\u0484\3\2\2\2\u0489\u048d\3\2\2\2\u048a")
        buf.write(u"\u048c\5\u00c8e\2\u048b\u048a\3\2\2\2\u048c\u048f\3\2")
        buf.write(u"\2\2\u048d\u048b\3\2\2\2\u048d\u048e\3\2\2\2\u048e\u049b")
        buf.write(u"\3\2\2\2\u048f\u048d\3\2\2\2\u0490\u0491\7\u0080\2\2")
        buf.write(u"\u0491\u0493\7\u00a0\2\2\u0492\u0494\5\u00acW\2\u0493")
        buf.write(u"\u0492\3\2\2\2\u0493\u0494\3\2\2\2\u0494\u0496\3\2\2")
        buf.write(u"\2\u0495\u0497\5\u0120\u0091\2\u0496\u0495\3\2\2\2\u0496")
        buf.write(u"\u0497\3\2\2\2\u0497\u0498\3\2\2\2\u0498\u0499\7\u0081")
        buf.write(u"\2\2\u0499\u049b\5V,\2\u049a\u0488\3\2\2\2\u049a\u0490")
        buf.write(u"\3\2\2\2\u049b\u00c7\3\2\2\2\u049c\u049e\7\u0084\2\2")
        buf.write(u"\u049d\u049f\5\u010c\u0087\2\u049e\u049d\3\2\2\2\u049e")
        buf.write(u"\u049f\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\7\u0085")
        buf.write(u"\2\2\u04a1\u00c9\3\2\2\2\u04a2\u04a5\5\u00dco\2\u04a3")
        buf.write(u"\u04a4\7\u0087\2\2\u04a4\u04a6\7\u00ac\2\2\u04a5\u04a3")
        buf.write(u"\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u00cb\3\2\2\2\u04a7")
        buf.write(u"\u04a9\7\u009c\2\2\u04a8\u04aa\5\u009aN\2\u04a9\u04a8")
        buf.write(u"\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ac\3\2\2\2\u04ab")
        buf.write(u"\u04ad\5\u00ccg\2\u04ac\u04ab\3\2\2\2\u04ac\u04ad\3\2")
        buf.write(u"\2\2\u04ad\u00cd\3\2\2\2\u04ae\u04ba\5\u0120\u0091\2")
        buf.write(u"\u04af\u04b0\7\u0080\2\2\u04b0\u04b5\5\u011a\u008e\2")
        buf.write(u"\u04b1\u04b2\7\u0087\2\2\u04b2\u04b4\5\u011a\u008e\2")
        buf.write(u"\u04b3\u04b1\3\2\2\2\u04b4\u04b7\3\2\2\2\u04b5\u04b3")
        buf.write(u"\3\2\2\2\u04b5\u04b6\3\2\2\2\u04b6\u04b8\3\2\2\2\u04b7")
        buf.write(u"\u04b5\3\2\2\2\u04b8\u04b9\7\u0081\2\2\u04b9\u04bb\3")
        buf.write(u"\2\2\2\u04ba\u04af\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb")
        buf.write(u"\u00cf\3\2\2\2\u04bc\u04c1\7\u0082\2\2\u04bd\u04bf\5")
        buf.write(u"\u0102\u0082\2\u04be\u04c0\7\u0087\2\2\u04bf\u04be\3")
        buf.write(u"\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c2\3\2\2\2\u04c1")
        buf.write(u"\u04bd\3\2\2\2\u04c1\u04c2\3\2\2\2\u04c2\u04c3\3\2\2")
        buf.write(u"\2\u04c3\u04c4\7\u0083\2\2\u04c4\u00d1\3\2\2\2\u04c5")
        buf.write(u"\u04d3\7\u0082\2\2\u04c6\u04c7\7\u0088\2\2\u04c7\u04cd")
        buf.write(u"\5\u0104\u0083\2\u04c8\u04c9\7\u0087\2\2\u04c9\u04ca")
        buf.write(u"\7\u0088\2\2\u04ca\u04cc\5\u0104\u0083\2\u04cb\u04c8")
        buf.write(u"\3\2\2\2\u04cc\u04cf\3\2\2\2\u04cd\u04cb\3\2\2\2\u04cd")
        buf.write(u"\u04ce\3\2\2\2\u04ce\u04d1\3\2\2\2\u04cf\u04cd\3\2\2")
        buf.write(u"\2\u04d0\u04d2\7\u0087\2\2\u04d1\u04d0\3\2\2\2\u04d1")
        buf.write(u"\u04d2\3\2\2\2\u04d2\u04d4\3\2\2\2\u04d3\u04c6\3\2\2")
        buf.write(u"\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\3\2\2\2\u04d5\u04d6")
        buf.write(u"\7\u0083\2\2\u04d6\u00d3\3\2\2\2\u04d7\u04dc\5\u010a")
        buf.write(u"\u0086\2\u04d8\u04d9\7\u0087\2\2\u04d9\u04db\5\u010a")
        buf.write(u"\u0086\2\u04da\u04d8\3\2\2\2\u04db\u04de\3\2\2\2\u04dc")
        buf.write(u"\u04da\3\2\2\2\u04dc\u04dd\3\2\2\2\u04dd\u04e0\3\2\2")
        buf.write(u"\2\u04de\u04dc\3\2\2\2\u04df\u04e1\7\u0087\2\2\u04e0")
        buf.write(u"\u04df\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1\u00d5\3\2\2")
        buf.write(u"\2\u04e2\u04e4\5\u00a6T\2\u04e3\u04e5\5\u00d8m\2\u04e4")
        buf.write(u"\u04e3\3\2\2\2\u04e4\u04e5\3\2\2\2\u04e5\u04e8\3\2\2")
        buf.write(u"\2\u04e6\u04e8\5H%\2\u04e7\u04e2\3\2\2\2\u04e7\u04e6")
        buf.write(u"\3\2\2\2\u04e8\u00d7\3\2\2\2\u04e9\u04eb\5\u00ccg\2\u04ea")
        buf.write(u"\u04ec\5\u00d8m\2\u04eb\u04ea\3\2\2\2\u04eb\u04ec\3\2")
        buf.write(u"\2\2\u04ec\u0501\3\2\2\2\u04ed\u04ef\7\u0080\2\2\u04ee")
        buf.write(u"\u04f0\5\u00d8m\2\u04ef\u04ee\3\2\2\2\u04ef\u04f0\3\2")
        buf.write(u"\2\2\u04f0\u04f1\3\2\2\2\u04f1\u04f3\7\u0081\2\2\u04f2")
        buf.write(u"\u04f4\5\u00dan\2\u04f3\u04f2\3\2\2\2\u04f4\u04f5\3\2")
        buf.write(u"\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6\u0501")
        buf.write(u"\3\2\2\2\u04f7\u04f9\7\u0084\2\2\u04f8\u04fa\5\u010c")
        buf.write(u"\u0087\2\u04f9\u04f8\3\2\2\2\u04f9\u04fa\3\2\2\2\u04fa")
        buf.write(u"\u04fb\3\2\2\2\u04fb\u04fd\7\u0085\2\2\u04fc\u04f7\3")
        buf.write(u"\2\2\2\u04fd\u04fe\3\2\2\2\u04fe\u04fc\3\2\2\2\u04fe")
        buf.write(u"\u04ff\3\2\2\2\u04ff\u0501\3\2\2\2\u0500\u04e9\3\2\2")
        buf.write(u"\2\u0500\u04ed\3\2\2\2\u0500\u04fc\3\2\2\2\u0501\u00d9")
        buf.write(u"\3\2\2\2\u0502\u0504\7\u0084\2\2\u0503\u0505\5\u010c")
        buf.write(u"\u0087\2\u0504\u0503\3\2\2\2\u0504\u0505\3\2\2\2\u0505")
        buf.write(u"\u0506\3\2\2\2\u0506\u050d\7\u0085\2\2\u0507\u0509\7")
        buf.write(u"\u0080\2\2\u0508\u050a\5\u00dco\2\u0509\u0508\3\2\2\2")
        buf.write(u"\u0509\u050a\3\2\2\2\u050a\u050b\3\2\2\2\u050b\u050d")
        buf.write(u"\7\u0081\2\2\u050c\u0502\3\2\2\2\u050c\u0507\3\2\2\2")
        buf.write(u"\u050d\u00db\3\2\2\2\u050e\u0513\5\u00dep\2\u050f\u0510")
        buf.write(u"\7\u0087\2\2\u0510\u0512\5\u00dep\2\u0511\u050f\3\2\2")
        buf.write(u"\2\u0512\u0515\3\2\2\2\u0513\u0511\3\2\2\2\u0513\u0514")
        buf.write(u"\3\2\2\2\u0514\u00dd\3\2\2\2\u0515\u0513\3\2\2\2\u0516")
        buf.write(u"\u0517\5\u009aN\2\u0517\u0518\5\u00e0q\2\u0518\u051b")
        buf.write(u"\3\2\2\2\u0519\u051b\7\"\2\2\u051a\u0516\3\2\2\2\u051a")
        buf.write(u"\u0519\3\2\2\2\u051b\u00df\3\2\2\2\u051c\u051e\5\u00cc")
        buf.write(u"g\2\u051d\u051c\3\2\2\2\u051d\u051e\3\2\2\2\u051e\u051f")
        buf.write(u"\3\2\2\2\u051f\u0520\5\u00c6d\2\u0520\u00e1\3\2\2\2\u0521")
        buf.write(u"\u0523\5\u00e4s\2\u0522\u0524\7\u0086\2\2\u0523\u0522")
        buf.write(u"\3\2\2\2\u0523\u0524\3\2\2\2\u0524\u054b\3\2\2\2\u0525")
        buf.write(u"\u0527\5\u00e8u\2\u0526\u0528\7\u0086\2\2\u0527\u0526")
        buf.write(u"\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u054b\3\2\2\2\u0529")
        buf.write(u"\u052b\5\u00eav\2\u052a\u052c\7\u0086\2\2\u052b\u052a")
        buf.write(u"\3\2\2\2\u052b\u052c\3\2\2\2\u052c\u054b\3\2\2\2\u052d")
        buf.write(u"\u052f\5\u00f4{\2\u052e\u0530\7\u0086\2\2\u052f\u052e")
        buf.write(u"\3\2\2\2\u052f\u0530\3\2\2\2\u0530\u054b\3\2\2\2\u0531")
        buf.write(u"\u0533\5\u0100\u0081\2\u0532\u0534\7\u0086\2\2\u0533")
        buf.write(u"\u0532\3\2\2\2\u0533\u0534\3\2\2\2\u0534\u054b\3\2\2")
        buf.write(u"\2\u0535\u0537\5v<\2\u0536\u0538\7\u0086\2\2\u0537\u0536")
        buf.write(u"\3\2\2\2\u0537\u0538\3\2\2\2\u0538\u054b\3\2\2\2\u0539")
        buf.write(u"\u053b\5x=\2\u053a\u053c\7\u0086\2\2\u053b\u053a\3\2")
        buf.write(u"\2\2\u053b\u053c\3\2\2\2\u053c\u054b\3\2\2\2\u053d\u053f")
        buf.write(u"\5p9\2\u053e\u0540\7\u0086\2\2\u053f\u053e\3\2\2\2\u053f")
        buf.write(u"\u0540\3\2\2\2\u0540\u054b\3\2\2\2\u0541\u0543\5r:\2")
        buf.write(u"\u0542\u0544\7\u0086\2\2\u0543\u0542\3\2\2\2\u0543\u0544")
        buf.write(u"\3\2\2\2\u0544\u054b\3\2\2\2\u0545\u0547\5\u0102\u0082")
        buf.write(u"\2\u0546\u0548\7\u0086\2\2\u0547\u0546\3\2\2\2\u0547")
        buf.write(u"\u0548\3\2\2\2\u0548\u054b\3\2\2\2\u0549\u054b\7\u0086")
        buf.write(u"\2\2\u054a\u0521\3\2\2\2\u054a\u0525\3\2\2\2\u054a\u0529")
        buf.write(u"\3\2\2\2\u054a\u052d\3\2\2\2\u054a\u0531\3\2\2\2\u054a")
        buf.write(u"\u0535\3\2\2\2\u054a\u0539\3\2\2\2\u054a\u053d\3\2\2")
        buf.write(u"\2\u054a\u0541\3\2\2\2\u054a\u0545\3\2\2\2\u054a\u0549")
        buf.write(u"\3\2\2\2\u054b\u00e3\3\2\2\2\u054c\u054d\5\u0120\u0091")
        buf.write(u"\2\u054d\u054e\7\u0091\2\2\u054e\u054f\5\u00e2r\2\u054f")
        buf.write(u"\u00e5\3\2\2\2\u0550\u0553\5\u010c\u0087\2\u0551\u0552")
        buf.write(u"\7\u00ac\2\2\u0552\u0554\5\u010c\u0087\2\u0553\u0551")
        buf.write(u"\3\2\2\2\u0553\u0554\3\2\2\2\u0554\u00e7\3\2\2\2\u0555")
        buf.write(u"\u055a\7\u0082\2\2\u0556\u0559\5\u008cG\2\u0557\u0559")
        buf.write(u"\5\u00e2r\2\u0558\u0556\3\2\2\2\u0558\u0557\3\2\2\2\u0559")
        buf.write(u"\u055c\3\2\2\2\u055a\u0558\3\2\2\2\u055a\u055b\3\2\2")
        buf.write(u"\2\u055b\u055d\3\2\2\2\u055c\u055a\3\2\2\2\u055d\u055e")
        buf.write(u"\7\u0083\2\2\u055e\u00e9\3\2\2\2\u055f\u0560\7\22\2\2")
        buf.write(u"\u0560\u0561\7\u0080\2\2\u0561\u0562\5\u0104\u0083\2")
        buf.write(u"\u0562\u0563\7\u0081\2\2\u0563\u0566\5\u00e2r\2\u0564")
        buf.write(u"\u0565\7\f\2\2\u0565\u0567\5\u00e2r\2\u0566\u0564\3\2")
        buf.write(u"\2\2\u0566\u0567\3\2\2\2\u0567\u056a\3\2\2\2\u0568\u056a")
        buf.write(u"\5\u00ecw\2\u0569\u055f\3\2\2\2\u0569\u0568\3\2\2\2\u056a")
        buf.write(u"\u00eb\3\2\2\2\u056b\u056c\7\36\2\2\u056c\u056d\7\u0080")
        buf.write(u"\2\2\u056d\u056e\5\u0104\u0083\2\u056e\u056f\7\u0081")
        buf.write(u"\2\2\u056f\u0570\5\u00eex\2\u0570\u00ed\3\2\2\2\u0571")
        buf.write(u"\u0575\7\u0082\2\2\u0572\u0574\5\u00f0y\2\u0573\u0572")
        buf.write(u"\3\2\2\2\u0574\u0577\3\2\2\2\u0575\u0573\3\2\2\2\u0575")
        buf.write(u"\u0576\3\2\2\2\u0576\u0578\3\2\2\2\u0577\u0575\3\2\2")
        buf.write(u"\2\u0578\u0579\7\u0083\2\2\u0579\u00ef\3\2\2\2\u057a")
        buf.write(u"\u057c\5\u00f2z\2\u057b\u057a\3\2\2\2\u057c\u057d\3\2")
        buf.write(u"\2\2\u057d\u057b\3\2\2\2\u057d\u057e\3\2\2\2\u057e\u0580")
        buf.write(u"\3\2\2\2\u057f\u0581\5\u00e2r\2\u0580\u057f\3\2\2\2\u0581")
        buf.write(u"\u0582\3\2\2\2\u0582\u0580\3\2\2\2\u0582\u0583\3\2\2")
        buf.write(u"\2\u0583\u00f1\3\2\2\2\u0584\u058a\7\5\2\2\u0585\u058b")
        buf.write(u"\5\u00e6t\2\u0586\u0587\7\u0080\2\2\u0587\u0588\5\u00e6")
        buf.write(u"t\2\u0588\u0589\7\u0081\2\2\u0589\u058b\3\2\2\2\u058a")
        buf.write(u"\u0585\3\2\2\2\u058a\u0586\3\2\2\2\u058b\u058c\3\2\2")
        buf.write(u"\2\u058c\u058d\7\u0091\2\2\u058d\u0591\3\2\2\2\u058e")
        buf.write(u"\u058f\7\t\2\2\u058f\u0591\7\u0091\2\2\u0590\u0584\3")
        buf.write(u"\2\2\2\u0590\u058e\3\2\2\2\u0591\u00f3\3\2\2\2\u0592")
        buf.write(u"\u0597\5\u00f6|\2\u0593\u0597\5\u00f8}\2\u0594\u0597")
        buf.write(u"\5\u00fa~\2\u0595\u0597\5\u00fe\u0080\2\u0596\u0592\3")
        buf.write(u"\2\2\2\u0596\u0593\3\2\2\2\u0596\u0594\3\2\2\2\u0596")
        buf.write(u"\u0595\3\2\2\2\u0597\u00f5\3\2\2\2\u0598\u0599\7$\2\2")
        buf.write(u"\u0599\u059a\7\u0080\2\2\u059a\u059b\5\u0104\u0083\2")
        buf.write(u"\u059b\u059c\7\u0081\2\2\u059c\u059d\5\u00e2r\2\u059d")
        buf.write(u"\u00f7\3\2\2\2\u059e\u059f\7\n\2\2\u059f\u05a0\5\u00e2")
        buf.write(u"r\2\u05a0\u05a1\7$\2\2\u05a1\u05a2\7\u0080\2\2\u05a2")
        buf.write(u"\u05a3\5\u0104\u0083\2\u05a3\u05a4\7\u0081\2\2\u05a4")
        buf.write(u"\u05a5\7\u0086\2\2\u05a5\u00f9\3\2\2\2\u05a6\u05a7\7")
        buf.write(u"\20\2\2\u05a7\u05a9\7\u0080\2\2\u05a8\u05aa\5\u00fc\177")
        buf.write(u"\2\u05a9\u05a8\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ab")
        buf.write(u"\3\2\2\2\u05ab\u05ad\7\u0086\2\2\u05ac\u05ae\5\u0104")
        buf.write(u"\u0083\2\u05ad\u05ac\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae")
        buf.write(u"\u05af\3\2\2\2\u05af\u05b1\7\u0086\2\2\u05b0\u05b2\5")
        buf.write(u"\u0102\u0082\2\u05b1\u05b0\3\2\2\2\u05b1\u05b2\3\2\2")
        buf.write(u"\2\u05b2\u05b3\3\2\2\2\u05b3\u05b4\7\u0081\2\2\u05b4")
        buf.write(u"\u05b5\5\u00e2r\2\u05b5\u00fb\3\2\2\2\u05b6\u05b7\5\u009a")
        buf.write(u"N\2\u05b7\u05b8\5\u009eP\2\u05b8\u05bb\3\2\2\2\u05b9")
        buf.write(u"\u05bb\5\u0102\u0082\2\u05ba\u05b6\3\2\2\2\u05ba\u05b9")
        buf.write(u"\3\2\2\2\u05bb\u00fd\3\2\2\2\u05bc\u05bd\7\20\2\2\u05bd")
        buf.write(u"\u05be\7\u0080\2\2\u05be\u05bf\5n8\2\u05bf\u05c1\7\60")
        buf.write(u"\2\2\u05c0\u05c2\5\u0104\u0083\2\u05c1\u05c0\3\2\2\2")
        buf.write(u"\u05c1\u05c2\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c4")
        buf.write(u"\7\u0081\2\2\u05c4\u05c5\5\u00e2r\2\u05c5\u00ff\3\2\2")
        buf.write(u"\2\u05c6\u05c7\7\21\2\2\u05c7\u05cf\5\u0120\u0091\2\u05c8")
        buf.write(u"\u05cf\7\b\2\2\u05c9\u05cf\7\4\2\2\u05ca\u05cc\7\30\2")
        buf.write(u"\2\u05cb\u05cd\5\u0104\u0083\2\u05cc\u05cb\3\2\2\2\u05cc")
        buf.write(u"\u05cd\3\2\2\2\u05cd\u05cf\3\2\2\2\u05ce\u05c6\3\2\2")
        buf.write(u"\2\u05ce\u05c8\3\2\2\2\u05ce\u05c9\3\2\2\2\u05ce\u05ca")
        buf.write(u"\3\2\2\2\u05cf\u0101\3\2\2\2\u05d0\u05d5\5\u0104\u0083")
        buf.write(u"\2\u05d1\u05d2\7\u0087\2\2\u05d2\u05d4\5\u0104\u0083")
        buf.write(u"\2\u05d3\u05d1\3\2\2\2\u05d4\u05d7\3\2\2\2\u05d5\u05d3")
        buf.write(u"\3\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u0103\3\2\2\2\u05d7")
        buf.write(u"\u05d5\3\2\2\2\u05d8\u05d9\b\u0083\1\2\u05d9\u05df\5")
        buf.write(u"\u0108\u0085\2\u05da\u05db\5\u010e\u0088\2\u05db\u05dc")
        buf.write(u"\5\u0106\u0084\2\u05dc\u05dd\5\u0104\u0083\3\u05dd\u05df")
        buf.write(u"\3\2\2\2\u05de\u05d8\3\2\2\2\u05de\u05da\3\2\2\2\u05df")
        buf.write(u"\u060c\3\2\2\2\u05e0\u05e1\f\16\2\2\u05e1\u05e2\t\f\2")
        buf.write(u"\2\u05e2\u060b\5\u0104\u0083\17\u05e3\u05e4\f\r\2\2\u05e4")
        buf.write(u"\u05e5\t\r\2\2\u05e5\u060b\5\u0104\u0083\16\u05e6\u05eb")
        buf.write(u"\f\f\2\2\u05e7\u05e8\7\u008d\2\2\u05e8\u05ec\7\u008d")
        buf.write(u"\2\2\u05e9\u05ea\7\u008c\2\2\u05ea\u05ec\7\u008c\2\2")
        buf.write(u"\u05eb\u05e7\3\2\2\2\u05eb\u05e9\3\2\2\2\u05ec\u05ed")
        buf.write(u"\3\2\2\2\u05ed\u060b\5\u0104\u0083\r\u05ee\u05ef\f\13")
        buf.write(u"\2\2\u05ef\u05f0\t\16\2\2\u05f0\u060b\5\u0104\u0083\f")
        buf.write(u"\u05f1\u05f2\f\n\2\2\u05f2\u05f3\t\17\2\2\u05f3\u060b")
        buf.write(u"\5\u0104\u0083\13\u05f4\u05f5\f\t\2\2\u05f5\u05f6\7\u009e")
        buf.write(u"\2\2\u05f6\u060b\5\u0104\u0083\n\u05f7\u05f8\f\b\2\2")
        buf.write(u"\u05f8\u05f9\7\u00a0\2\2\u05f9\u060b\5\u0104\u0083\t")
        buf.write(u"\u05fa\u05fb\f\7\2\2\u05fb\u05fc\7\u009f\2\2\u05fc\u060b")
        buf.write(u"\5\u0104\u0083\b\u05fd\u05fe\f\6\2\2\u05fe\u05ff\7\u0096")
        buf.write(u"\2\2\u05ff\u060b\5\u0104\u0083\7\u0600\u0601\f\5\2\2")
        buf.write(u"\u0601\u0602\7\u0097\2\2\u0602\u060b\5\u0104\u0083\6")
        buf.write(u"\u0603\u0604\f\4\2\2\u0604\u0606\7\u0090\2\2\u0605\u0607")
        buf.write(u"\5\u0104\u0083\2\u0606\u0605\3\2\2\2\u0606\u0607\3\2")
        buf.write(u"\2\2\u0607\u0608\3\2\2\2\u0608\u0609\7\u0091\2\2\u0609")
        buf.write(u"\u060b\5\u0104\u0083\5\u060a\u05e0\3\2\2\2\u060a\u05e3")
        buf.write(u"\3\2\2\2\u060a\u05e6\3\2\2\2\u060a\u05ee\3\2\2\2\u060a")
        buf.write(u"\u05f1\3\2\2\2\u060a\u05f4\3\2\2\2\u060a\u05f7\3\2\2")
        buf.write(u"\2\u060a\u05fa\3\2\2\2\u060a\u05fd\3\2\2\2\u060a\u0600")
        buf.write(u"\3\2\2\2\u060a\u0603\3\2\2\2\u060b\u060e\3\2\2\2\u060c")
        buf.write(u"\u060a\3\2\2\2\u060c\u060d\3\2\2\2\u060d\u0105\3\2\2")
        buf.write(u"\2\u060e\u060c\3\2\2\2\u060f\u0610\t\20\2\2\u0610\u0107")
        buf.write(u"\3\2\2\2\u0611\u061b\5\u010e\u0088\2\u0612\u0613\7\u0080")
        buf.write(u"\2\2\u0613\u0614\5\u00d6l\2\u0614\u0615\7\u0081\2\2\u0615")
        buf.write(u"\u0618\3\2\2\2\u0616\u0619\5\u0108\u0085\2\u0617\u0619")
        buf.write(u"\5\u010a\u0086\2\u0618\u0616\3\2\2\2\u0618\u0617\3\2")
        buf.write(u"\2\2\u0619\u061b\3\2\2\2\u061a\u0611\3\2\2\2\u061a\u0612")
        buf.write(u"\3\2\2\2\u061b\u0109\3\2\2\2\u061c\u0620\5\u0104\u0083")
        buf.write(u"\2\u061d\u0620\5\u00d0i\2\u061e\u0620\5\u00d2j\2\u061f")
        buf.write(u"\u061c\3\2\2\2\u061f\u061d\3\2\2\2\u061f\u061e\3\2\2")
        buf.write(u"\2\u0620\u010b\3\2\2\2\u0621\u0624\5\u0120\u0091\2\u0622")
        buf.write(u"\u0624\5\u011c\u008f\2\u0623\u0621\3\2\2\2\u0623\u0622")
        buf.write(u"\3\2\2\2\u0624\u010d\3\2\2\2\u0625\u0634\5\u0112\u008a")
        buf.write(u"\2\u0626\u062c\7\33\2\2\u0627\u062d\5\u010e\u0088\2\u0628")
        buf.write(u"\u0629\7\u0080\2\2\u0629\u062a\5\u00b6\\\2\u062a\u062b")
        buf.write(u"\7\u0081\2\2\u062b\u062d\3\2\2\2\u062c\u0627\3\2\2\2")
        buf.write(u"\u062c\u0628\3\2\2\2\u062d\u0634\3\2\2\2\u062e\u062f")
        buf.write(u"\t\21\2\2\u062f\u0634\5\u010e\u0088\2\u0630\u0631\5\u0110")
        buf.write(u"\u0089\2\u0631\u0632\5\u0108\u0085\2\u0632\u0634\3\2")
        buf.write(u"\2\2\u0633\u0625\3\2\2\2\u0633\u0626\3\2\2\2\u0633\u062e")
        buf.write(u"\3\2\2\2\u0633\u0630\3\2\2\2\u0634\u010f\3\2\2\2\u0635")
        buf.write(u"\u0636\t\22\2\2\u0636\u0111\3\2\2\2\u0637\u0638\b\u008a")
        buf.write(u"\1\2\u0638\u063c\5\u011a\u008e\2\u0639\u063b\5\u0114")
        buf.write(u"\u008b\2\u063a\u0639\3\2\2\2\u063b\u063e\3\2\2\2\u063c")
        buf.write(u"\u063a\3\2\2\2\u063c\u063d\3\2\2\2\u063d\u064a\3\2\2")
        buf.write(u"\2\u063e\u063c\3\2\2\2\u063f\u0640\f\3\2\2\u0640\u0641")
        buf.write(u"\t\23\2\2\u0641\u0645\5\u0120\u0091\2\u0642\u0644\5\u0114")
        buf.write(u"\u008b\2\u0643\u0642\3\2\2\2\u0644\u0647\3\2\2\2\u0645")
        buf.write(u"\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646\u0649\3\2\2")
        buf.write(u"\2\u0647\u0645\3\2\2\2\u0648\u063f\3\2\2\2\u0649\u064c")
        buf.write(u"\3\2\2\2\u064a\u0648\3\2\2\2\u064a\u064b\3\2\2\2\u064b")
        buf.write(u"\u0113\3\2\2\2\u064c\u064a\3\2\2\2\u064d\u064e\7\u0084")
        buf.write(u"\2\2\u064e\u064f\5\u0104\u0083\2\u064f\u0650\7\u0085")
        buf.write(u"\2\2\u0650\u0660\3\2\2\2\u0651\u0653\7\u0080\2\2\u0652")
        buf.write(u"\u0654\5\u0116\u008c\2\u0653\u0652\3\2\2\2\u0653\u0654")
        buf.write(u"\3\2\2\2\u0654\u0655\3\2\2\2\u0655\u0660\7\u0081\2\2")
        buf.write(u"\u0656\u0659\7\u0080\2\2\u0657\u065a\7\u0087\2\2\u0658")
        buf.write(u"\u065a\n\24\2\2\u0659\u0657\3\2\2\2\u0659\u0658\3\2\2")
        buf.write(u"\2\u065a\u065b\3\2\2\2\u065b\u0659\3\2\2\2\u065b\u065c")
        buf.write(u"\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u0660\7\u0081\2\2")
        buf.write(u"\u065e\u0660\t\21\2\2\u065f\u064d\3\2\2\2\u065f\u0651")
        buf.write(u"\3\2\2\2\u065f\u0656\3\2\2\2\u065f\u065e\3\2\2\2\u0660")
        buf.write(u"\u0115\3\2\2\2\u0661\u0666\5\u0118\u008d\2\u0662\u0663")
        buf.write(u"\7\u0087\2\2\u0663\u0665\5\u0118\u008d\2\u0664\u0662")
        buf.write(u"\3\2\2\2\u0665\u0668\3\2\2\2\u0666\u0664\3\2\2\2\u0666")
        buf.write(u"\u0667\3\2\2\2\u0667\u0117\3\2\2\2\u0668\u0666\3\2\2")
        buf.write(u"\2\u0669\u066c\5\u0104\u0083\2\u066a\u066c\5\u00b6\\")
        buf.write(u"\2\u066b\u0669\3\2\2\2\u066b\u066a\3\2\2\2\u066c\u0119")
        buf.write(u"\3\2\2\2\u066d\u067d\5\u0120\u0091\2\u066e\u067d\5\u011c")
        buf.write(u"\u008f\2\u066f\u067d\5\u011e\u0090\2\u0670\u0671\7\u0080")
        buf.write(u"\2\2\u0671\u0672\5\u0104\u0083\2\u0672\u0673\7\u0081")
        buf.write(u"\2\2\u0673\u067d\3\2\2\2\u0674\u067d\5\\/\2\u0675\u067d")
        buf.write(u"\5f\64\2\u0676\u067d\5j\66\2\u0677\u067d\5l\67\2\u0678")
        buf.write(u"\u067d\5N(\2\u0679\u067d\5R*\2\u067a\u067d\5T+\2\u067b")
        buf.write(u"\u067d\5Z.\2\u067c\u066d\3\2\2\2\u067c\u066e\3\2\2\2")
        buf.write(u"\u067c\u066f\3\2\2\2\u067c\u0670\3\2\2\2\u067c\u0674")
        buf.write(u"\3\2\2\2\u067c\u0675\3\2\2\2\u067c\u0676\3\2\2\2\u067c")
        buf.write(u"\u0677\3\2\2\2\u067c\u0678\3\2\2\2\u067c\u0679\3\2\2")
        buf.write(u"\2\u067c\u067a\3\2\2\2\u067c\u067b\3\2\2\2\u067d\u011b")
        buf.write(u"\3\2\2\2\u067e\u0691\7\u00af\2\2\u067f\u0691\7\u00b0")
        buf.write(u"\2\2\u0680\u0691\7\u00b1\2\2\u0681\u0683\t\r\2\2\u0682")
        buf.write(u"\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0684\3\2\2")
        buf.write(u"\2\u0684\u0691\7\u00b2\2\2\u0685\u0687\t\r\2\2\u0686")
        buf.write(u"\u0685\3\2\2\2\u0686\u0687\3\2\2\2\u0687\u0688\3\2\2")
        buf.write(u"\2\u0688\u0691\7\u00b3\2\2\u0689\u0691\7\u00ad\2\2\u068a")
        buf.write(u"\u0691\7\62\2\2\u068b\u0691\7\64\2\2\u068c\u0691\7;\2")
        buf.write(u"\2\u068d\u0691\7\63\2\2\u068e\u0691\7(\2\2\u068f\u0691")
        buf.write(u"\7)\2\2\u0690\u067e\3\2\2\2\u0690\u067f\3\2\2\2\u0690")
        buf.write(u"\u0680\3\2\2\2\u0690\u0682\3\2\2\2\u0690\u0686\3\2\2")
        buf.write(u"\2\u0690\u0689\3\2\2\2\u0690\u068a\3\2\2\2\u0690\u068b")
        buf.write(u"\3\2\2\2\u0690\u068c\3\2\2\2\u0690\u068d\3\2\2\2\u0690")
        buf.write(u"\u068e\3\2\2\2\u0690\u068f\3\2\2\2\u0691\u011d\3\2\2")
        buf.write(u"\2\u0692\u0696\7\u00ae\2\2\u0693\u0695\t\25\2\2\u0694")
        buf.write(u"\u0693\3\2\2\2\u0695\u0698\3\2\2\2\u0696\u0694\3\2\2")
        buf.write(u"\2\u0696\u0697\3\2\2\2\u0697\u0699\3\2\2\2\u0698\u0696")
        buf.write(u"\3\2\2\2\u0699\u069b\7\u00ba\2\2\u069a\u0692\3\2\2\2")
        buf.write(u"\u069b\u069c\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d")
        buf.write(u"\3\2\2\2\u069d\u011f\3\2\2\2\u069e\u069f\t\26\2\2\u069f")
        buf.write(u"\u0121\3\2\2\2\u00e0\u0125\u0135\u013c\u0142\u0148\u014b")
        buf.write(u"\u014e\u0156\u015d\u0160\u0163\u016b\u016e\u0171\u017b")
        buf.write(u"\u0185\u018d\u0192\u019b\u01a1\u01a3\u01af\u01b9\u01c1")
        buf.write(u"\u01c4\u01c7\u01d0\u01e7\u01ee\u01f1\u01f7\u0200\u0206")
        buf.write(u"\u0208\u0211\u0213\u021c\u0220\u0229\u022b\u0234\u0238")
        buf.write(u"\u023b\u0243\u0247\u0249\u024c\u0252\u0256\u025c\u026a")
        buf.write(u"\u0271\u0277\u027a\u027e\u0284\u0288\u0290\u0293\u029a")
        buf.write(u"\u02a6\u02aa\u02ac\u02b8\u02ba\u02c6\u02c8\u02cd\u02d3")
        buf.write(u"\u02d6\u02dc\u02e0\u02e3\u02e6\u02f1\u02f7\u02f9\u02fc")
        buf.write(u"\u0304\u0309\u030f\u0318\u031d\u031f\u0335\u033c\u0341")
        buf.write(u"\u0359\u035e\u0363\u0367\u036b\u036f\u0378\u037f\u0386")
        buf.write(u"\u038c\u038f\u0393\u039b\u039e\u03a2\u03aa\u03af\u03b6")
        buf.write(u"\u03bf\u03c3\u03cf\u03d1\u03db\u03e6\u03ec\u03f1\u03f7")
        buf.write(u"\u03fb\u0400\u040a\u040c\u0414\u0422\u0435\u0437\u0443")
        buf.write(u"\u0448\u044c\u0450\u0454\u045b\u0461\u046d\u0474\u0478")
        buf.write(u"\u047d\u0481\u0488\u048d\u0493\u0496\u049a\u049e\u04a5")
        buf.write(u"\u04a9\u04ac\u04b5\u04ba\u04bf\u04c1\u04cd\u04d1\u04d3")
        buf.write(u"\u04dc\u04e0\u04e4\u04e7\u04eb\u04ef\u04f5\u04f9\u04fe")
        buf.write(u"\u0500\u0504\u0509\u050c\u0513\u051a\u051d\u0523\u0527")
        buf.write(u"\u052b\u052f\u0533\u0537\u053b\u053f\u0543\u0547\u054a")
        buf.write(u"\u0553\u0558\u055a\u0566\u0569\u0575\u057d\u0582\u058a")
        buf.write(u"\u0590\u0596\u05a9\u05ad\u05b1\u05ba\u05c1\u05cc\u05ce")
        buf.write(u"\u05d5\u05de\u05eb\u0606\u060a\u060c\u0618\u061a\u061f")
        buf.write(u"\u0623\u062c\u0633\u063c\u0645\u064a\u0653\u0659\u065b")
        buf.write(u"\u065f\u0666\u066b\u067c\u0682\u0686\u0690\u0696\u069c")
        return buf.getvalue()


class ObjectiveCParser ( Parser ):

    grammarFileName = "ObjectiveCParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ u"<INVALID>", u"'auto'", u"'break'", u"'case'", u"'char'", 
                     u"'const'", u"'continue'", u"'default'", u"'do'", u"'double'", 
                     u"<INVALID>", u"'enum'", u"'extern'", u"'float'", u"'for'", 
                     u"'goto'", u"<INVALID>", u"'inline'", u"'int'", u"'long'", 
                     u"'register'", u"'restrict'", u"'return'", u"'short'", 
                     u"'signed'", u"'sizeof'", u"'static'", u"'struct'", 
                     u"'switch'", u"'typedef'", u"'union'", u"'unsigned'", 
                     u"'void'", u"'volatile'", u"'while'", u"'_Bool'", u"'_Complex'", 
                     u"'_Imaginery'", u"'true'", u"'false'", u"'BOOL'", 
                     u"'Class'", u"'bycopy'", u"'byref'", u"'id'", u"'IMP'", 
                     u"'in'", u"'inout'", u"'nil'", u"'NO'", u"'NULL'", 
                     u"'oneway'", u"'out'", u"'Protocol'", u"'SEL'", u"'self'", 
                     u"'super'", u"'YES'", u"'@autoreleasepool'", u"'@catch'", 
                     u"'@class'", u"'@dynamic'", u"'@encode'", u"'@end'", 
                     u"'@finally'", u"'@implementation'", u"'@interface'", 
                     u"'@import'", u"'@package'", u"'@protocol'", u"'@optional'", 
                     u"'@private'", u"'@property'", u"'@protected'", u"'@public'", 
                     u"'@required'", u"'@selector'", u"'@synchronized'", 
                     u"'@synthesize'", u"'@throw'", u"'@try'", u"'atomic'", 
                     u"'nonatomic'", u"'retain'", u"'__attribute__'", u"'__autoreleasing'", 
                     u"'__block'", u"'__bridge'", u"'__bridge_retained'", 
                     u"'__bridge_transfer'", u"'__covariant'", u"'__contravariant'", 
                     u"'__deprecated'", u"'__kindof'", u"'__strong'", u"<INVALID>", 
                     u"'__unsafe_unretained'", u"'__unused'", u"'__weak'", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'null_resettable'", 
                     u"'NS_INLINE'", u"'NS_ENUM'", u"'NS_OPTIONS'", u"'assign'", 
                     u"'copy'", u"'getter'", u"'setter'", u"'strong'", u"'readonly'", 
                     u"'readwrite'", u"'weak'", u"'unsafe_unretained'", 
                     u"'IBOutlet'", u"'IBOutletCollection'", u"'IBInspectable'", 
                     u"'IB_DESIGNABLE'", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"'__TVOS_PROHIBITED'", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'{'", u"'}'", 
                     u"'['", u"']'", u"';'", u"','", u"'.'", u"'->'", u"'@'", 
                     u"'='", u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'~'", 
                     u"'?'", u"':'", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'++'", 
                     u"'--'", u"'+'", u"'-'", u"'*'", u"'/'", u"'&'", u"'|'", 
                     u"'^'", u"'%'", u"'+='", u"'-='", u"'*='", u"'/='", 
                     u"'&='", u"'|='", u"'^='", u"'%='", u"'<<='", u"'>>='", 
                     u"'...'", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"'\\'", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>", 
                     u"'defined'", u"<INVALID>", u"'elif'", u"<INVALID>", 
                     u"'undef'", u"'ifdef'", u"'ifndef'", u"'endif'" ]

    symbolicNames = [ u"<INVALID>", u"AUTO", u"BREAK", u"CASE", u"CHAR", 
                      u"CONST", u"CONTINUE", u"DEFAULT", u"DO", u"DOUBLE", 
                      u"ELSE", u"ENUM", u"EXTERN", u"FLOAT", u"FOR", u"GOTO", 
                      u"IF", u"INLINE", u"INT", u"LONG", u"REGISTER", u"RESTRICT", 
                      u"RETURN", u"SHORT", u"SIGNED", u"SIZEOF", u"STATIC", 
                      u"STRUCT", u"SWITCH", u"TYPEDEF", u"UNION", u"UNSIGNED", 
                      u"VOID", u"VOLATILE", u"WHILE", u"BOOL_", u"COMPLEX", 
                      u"IMAGINERY", u"TRUE", u"FALSE", u"BOOL", u"Class", 
                      u"BYCOPY", u"BYREF", u"ID", u"IMP", u"IN", u"INOUT", 
                      u"NIL", u"NO", u"NULL", u"ONEWAY", u"OUT", u"PROTOCOL_", 
                      u"SEL", u"SELF", u"SUPER", u"YES", u"AUTORELEASEPOOL", 
                      u"CATCH", u"CLASS", u"DYNAMIC", u"ENCODE", u"END", 
                      u"FINALLY", u"IMPLEMENTATION", u"INTERFACE", u"IMPORT", 
                      u"PACKAGE", u"PROTOCOL", u"OPTIONAL", u"PRIVATE", 
                      u"PROPERTY", u"PROTECTED", u"PUBLIC", u"REQUIRED", 
                      u"SELECTOR", u"SYNCHRONIZED", u"SYNTHESIZE", u"THROW", 
                      u"TRY", u"ATOMIC", u"NONATOMIC", u"RETAIN", u"ATTRIBUTE", 
                      u"AUTORELEASING_QUALIFIER", u"BLOCK", u"BRIDGE", u"BRIDGE_RETAINED", 
                      u"BRIDGE_TRANSFER", u"COVARIANT", u"CONTRAVARIANT", 
                      u"DEPRECATED", u"KINDOF", u"STRONG_QUALIFIER", u"TYPEOF", 
                      u"UNSAFE_UNRETAINED_QUALIFIER", u"UNUSED", u"WEAK_QUALIFIER", 
                      u"NULL_UNSPECIFIED", u"NULLABLE", u"NONNULL", u"NULL_RESETTABLE", 
                      u"NS_INLINE", u"NS_ENUM", u"NS_OPTIONS", u"ASSIGN", 
                      u"COPY", u"GETTER", u"SETTER", u"STRONG", u"READONLY", 
                      u"READWRITE", u"WEAK", u"UNSAFE_UNRETAINED", u"IB_OUTLET", 
                      u"IB_OUTLET_COLLECTION", u"IB_INSPECTABLE", u"IB_DESIGNABLE", 
                      u"NS_ASSUME_NONNULL_BEGIN", u"NS_ASSUME_NONNULL_END", 
                      u"EXTERN_SUFFIX", u"IOS_SUFFIX", u"MAC_SUFFIX", u"TVOS_PROHIBITED", 
                      u"IDENTIFIER", u"LP", u"RP", u"LBRACE", u"RBRACE", 
                      u"LBRACK", u"RBRACK", u"SEMI", u"COMMA", u"DOT", u"STRUCTACCESS", 
                      u"AT", u"ASSIGNMENT", u"GT", u"LT", u"BANG", u"TILDE", 
                      u"QUESTION", u"COLON", u"EQUAL", u"LE", u"GE", u"NOTEQUAL", 
                      u"AND", u"OR", u"INC", u"DEC", u"ADD", u"SUB", u"MUL", 
                      u"DIV", u"BITAND", u"BITOR", u"BITXOR", u"MOD", u"ADD_ASSIGN", 
                      u"SUB_ASSIGN", u"MUL_ASSIGN", u"DIV_ASSIGN", u"AND_ASSIGN", 
                      u"OR_ASSIGN", u"XOR_ASSIGN", u"MOD_ASSIGN", u"LSHIFT_ASSIGN", 
                      u"RSHIFT_ASSIGN", u"ELIPSIS", u"CHARACTER_LITERAL", 
                      u"STRING_START", u"HEX_LITERAL", u"OCTAL_LITERAL", 
                      u"BINARY_LITERAL", u"DECIMAL_LITERAL", u"FLOATING_POINT_LITERAL", 
                      u"WS", u"MULTI_COMMENT", u"SINGLE_COMMENT", u"BACKSLASH", 
                      u"SHARP", u"STRING_NEWLINE", u"STRING_END", u"STRING_VALUE", 
                      u"DIRECTIVE_IMPORT", u"DIRECTIVE_INCLUDE", u"DIRECTIVE_PRAGMA", 
                      u"DIRECTIVE_DEFINE", u"DIRECTIVE_DEFINED", u"DIRECTIVE_IF", 
                      u"DIRECTIVE_ELIF", u"DIRECTIVE_ELSE", u"DIRECTIVE_UNDEF", 
                      u"DIRECTIVE_IFDEF", u"DIRECTIVE_IFNDEF", u"DIRECTIVE_ENDIF", 
                      u"DIRECTIVE_TRUE", u"DIRECTIVE_FALSE", u"DIRECTIVE_ERROR", 
                      u"DIRECTIVE_WARNING", u"DIRECTIVE_BANG", u"DIRECTIVE_LP", 
                      u"DIRECTIVE_RP", u"DIRECTIVE_EQUAL", u"DIRECTIVE_NOTEQUAL", 
                      u"DIRECTIVE_AND", u"DIRECTIVE_OR", u"DIRECTIVE_LT", 
                      u"DIRECTIVE_GT", u"DIRECTIVE_LE", u"DIRECTIVE_GE", 
                      u"DIRECTIVE_STRING", u"DIRECTIVE_ID", u"DIRECTIVE_DECIMAL_LITERAL", 
                      u"DIRECTIVE_FLOAT", u"DIRECTIVE_NEWLINE", u"DIRECTIVE_MULTI_COMMENT", 
                      u"DIRECTIVE_SINGLE_COMMENT", u"DIRECTIVE_BACKSLASH_NEWLINE", 
                      u"DIRECTIVE_TEXT_NEWLINE", u"DIRECTIVE_TEXT" ]

    RULE_translationUnit = 0
    RULE_topLevelDeclaration = 1
    RULE_importDeclaration = 2
    RULE_classInterface = 3
    RULE_categoryInterface = 4
    RULE_classImplementation = 5
    RULE_categoryImplementation = 6
    RULE_genericTypeSpecifier = 7
    RULE_protocolDeclaration = 8
    RULE_protocolDeclarationSection = 9
    RULE_protocolDeclarationList = 10
    RULE_classDeclarationList = 11
    RULE_protocolList = 12
    RULE_propertyDeclaration = 13
    RULE_propertyAttributesList = 14
    RULE_propertyAttribute = 15
    RULE_protocolName = 16
    RULE_instanceVariables = 17
    RULE_visibilitySection = 18
    RULE_accessModifier = 19
    RULE_interfaceDeclarationList = 20
    RULE_classMethodDeclaration = 21
    RULE_instanceMethodDeclaration = 22
    RULE_methodDeclaration = 23
    RULE_implementationDefinitionList = 24
    RULE_classMethodDefinition = 25
    RULE_instanceMethodDefinition = 26
    RULE_methodDefinition = 27
    RULE_methodSelector = 28
    RULE_keywordDeclarator = 29
    RULE_selector = 30
    RULE_methodType = 31
    RULE_propertyImplementation = 32
    RULE_propertySynthesizeList = 33
    RULE_propertySynthesizeItem = 34
    RULE_blockType = 35
    RULE_genericsSpecifier = 36
    RULE_typeSpecifierWithPrefixes = 37
    RULE_dictionaryExpression = 38
    RULE_dictionaryPair = 39
    RULE_arrayExpression = 40
    RULE_boxExpression = 41
    RULE_blockParameters = 42
    RULE_typeVariableDeclaratorOrName = 43
    RULE_blockExpression = 44
    RULE_messageExpression = 45
    RULE_receiver = 46
    RULE_messageSelector = 47
    RULE_keywordArgument = 48
    RULE_keywordArgumentType = 49
    RULE_selectorExpression = 50
    RULE_selectorName = 51
    RULE_protocolExpression = 52
    RULE_encodeExpression = 53
    RULE_typeVariableDeclarator = 54
    RULE_throwStatement = 55
    RULE_tryBlock = 56
    RULE_catchStatement = 57
    RULE_synchronizedStatement = 58
    RULE_autoreleaseStatement = 59
    RULE_functionDeclaration = 60
    RULE_functionDefinition = 61
    RULE_functionSignature = 62
    RULE_attribute = 63
    RULE_attributeName = 64
    RULE_attributeParameters = 65
    RULE_attributeParameterList = 66
    RULE_attributeParameter = 67
    RULE_attributeParameterAssignment = 68
    RULE_declaration = 69
    RULE_functionCallExpression = 70
    RULE_enumDeclaration = 71
    RULE_varDeclaration = 72
    RULE_typedefDeclaration = 73
    RULE_typeDeclaratorList = 74
    RULE_typeDeclarator = 75
    RULE_declarationSpecifiers = 76
    RULE_attributeSpecifier = 77
    RULE_initDeclaratorList = 78
    RULE_initDeclarator = 79
    RULE_structOrUnionSpecifier = 80
    RULE_fieldDeclaration = 81
    RULE_specifierQualifierList = 82
    RULE_ibOutletQualifier = 83
    RULE_arcBehaviourSpecifier = 84
    RULE_nullabilitySpecifier = 85
    RULE_storageClassSpecifier = 86
    RULE_typePrefix = 87
    RULE_typeQualifier = 88
    RULE_protocolQualifier = 89
    RULE_typeSpecifier = 90
    RULE_typeofExpression = 91
    RULE_fieldDeclaratorList = 92
    RULE_fieldDeclarator = 93
    RULE_enumSpecifier = 94
    RULE_enumeratorList = 95
    RULE_enumerator = 96
    RULE_enumeratorIdentifier = 97
    RULE_directDeclarator = 98
    RULE_declaratorSuffix = 99
    RULE_parameterList = 100
    RULE_pointer = 101
    RULE_macro = 102
    RULE_arrayInitializer = 103
    RULE_structInitializer = 104
    RULE_initializerList = 105
    RULE_typeName = 106
    RULE_abstractDeclarator = 107
    RULE_abstractDeclaratorSuffix = 108
    RULE_parameterDeclarationList = 109
    RULE_parameterDeclaration = 110
    RULE_declarator = 111
    RULE_statement = 112
    RULE_labeledStatement = 113
    RULE_rangeExpression = 114
    RULE_compoundStatement = 115
    RULE_selectionStatement = 116
    RULE_switchStatement = 117
    RULE_switchBlock = 118
    RULE_switchSection = 119
    RULE_switchLabel = 120
    RULE_iterationStatement = 121
    RULE_whileStatement = 122
    RULE_doStatement = 123
    RULE_forStatement = 124
    RULE_forLoopInitializer = 125
    RULE_forInStatement = 126
    RULE_jumpStatement = 127
    RULE_expressions = 128
    RULE_expression = 129
    RULE_assignmentOperator = 130
    RULE_castExpression = 131
    RULE_initializer = 132
    RULE_constantExpression = 133
    RULE_unaryExpression = 134
    RULE_unaryOperator = 135
    RULE_postfixExpression = 136
    RULE_postfix = 137
    RULE_argumentExpressionList = 138
    RULE_argumentExpression = 139
    RULE_primaryExpression = 140
    RULE_constant = 141
    RULE_stringLiteral = 142
    RULE_identifier = 143

    ruleNames =  [ u"translationUnit", u"topLevelDeclaration", u"importDeclaration", 
                   u"classInterface", u"categoryInterface", u"classImplementation", 
                   u"categoryImplementation", u"genericTypeSpecifier", u"protocolDeclaration", 
                   u"protocolDeclarationSection", u"protocolDeclarationList", 
                   u"classDeclarationList", u"protocolList", u"propertyDeclaration", 
                   u"propertyAttributesList", u"propertyAttribute", u"protocolName", 
                   u"instanceVariables", u"visibilitySection", u"accessModifier", 
                   u"interfaceDeclarationList", u"classMethodDeclaration", 
                   u"instanceMethodDeclaration", u"methodDeclaration", u"implementationDefinitionList", 
                   u"classMethodDefinition", u"instanceMethodDefinition", 
                   u"methodDefinition", u"methodSelector", u"keywordDeclarator", 
                   u"selector", u"methodType", u"propertyImplementation", 
                   u"propertySynthesizeList", u"propertySynthesizeItem", 
                   u"blockType", u"genericsSpecifier", u"typeSpecifierWithPrefixes", 
                   u"dictionaryExpression", u"dictionaryPair", u"arrayExpression", 
                   u"boxExpression", u"blockParameters", u"typeVariableDeclaratorOrName", 
                   u"blockExpression", u"messageExpression", u"receiver", 
                   u"messageSelector", u"keywordArgument", u"keywordArgumentType", 
                   u"selectorExpression", u"selectorName", u"protocolExpression", 
                   u"encodeExpression", u"typeVariableDeclarator", u"throwStatement", 
                   u"tryBlock", u"catchStatement", u"synchronizedStatement", 
                   u"autoreleaseStatement", u"functionDeclaration", u"functionDefinition", 
                   u"functionSignature", u"attribute", u"attributeName", 
                   u"attributeParameters", u"attributeParameterList", u"attributeParameter", 
                   u"attributeParameterAssignment", u"declaration", u"functionCallExpression", 
                   u"enumDeclaration", u"varDeclaration", u"typedefDeclaration", 
                   u"typeDeclaratorList", u"typeDeclarator", u"declarationSpecifiers", 
                   u"attributeSpecifier", u"initDeclaratorList", u"initDeclarator", 
                   u"structOrUnionSpecifier", u"fieldDeclaration", u"specifierQualifierList", 
                   u"ibOutletQualifier", u"arcBehaviourSpecifier", u"nullabilitySpecifier", 
                   u"storageClassSpecifier", u"typePrefix", u"typeQualifier", 
                   u"protocolQualifier", u"typeSpecifier", u"typeofExpression", 
                   u"fieldDeclaratorList", u"fieldDeclarator", u"enumSpecifier", 
                   u"enumeratorList", u"enumerator", u"enumeratorIdentifier", 
                   u"directDeclarator", u"declaratorSuffix", u"parameterList", 
                   u"pointer", u"macro", u"arrayInitializer", u"structInitializer", 
                   u"initializerList", u"typeName", u"abstractDeclarator", 
                   u"abstractDeclaratorSuffix", u"parameterDeclarationList", 
                   u"parameterDeclaration", u"declarator", u"statement", 
                   u"labeledStatement", u"rangeExpression", u"compoundStatement", 
                   u"selectionStatement", u"switchStatement", u"switchBlock", 
                   u"switchSection", u"switchLabel", u"iterationStatement", 
                   u"whileStatement", u"doStatement", u"forStatement", u"forLoopInitializer", 
                   u"forInStatement", u"jumpStatement", u"expressions", 
                   u"expression", u"assignmentOperator", u"castExpression", 
                   u"initializer", u"constantExpression", u"unaryExpression", 
                   u"unaryOperator", u"postfixExpression", u"postfix", u"argumentExpressionList", 
                   u"argumentExpression", u"primaryExpression", u"constant", 
                   u"stringLiteral", u"identifier" ]

    EOF = Token.EOF
    AUTO=1
    BREAK=2
    CASE=3
    CHAR=4
    CONST=5
    CONTINUE=6
    DEFAULT=7
    DO=8
    DOUBLE=9
    ELSE=10
    ENUM=11
    EXTERN=12
    FLOAT=13
    FOR=14
    GOTO=15
    IF=16
    INLINE=17
    INT=18
    LONG=19
    REGISTER=20
    RESTRICT=21
    RETURN=22
    SHORT=23
    SIGNED=24
    SIZEOF=25
    STATIC=26
    STRUCT=27
    SWITCH=28
    TYPEDEF=29
    UNION=30
    UNSIGNED=31
    VOID=32
    VOLATILE=33
    WHILE=34
    BOOL_=35
    COMPLEX=36
    IMAGINERY=37
    TRUE=38
    FALSE=39
    BOOL=40
    Class=41
    BYCOPY=42
    BYREF=43
    ID=44
    IMP=45
    IN=46
    INOUT=47
    NIL=48
    NO=49
    NULL=50
    ONEWAY=51
    OUT=52
    PROTOCOL_=53
    SEL=54
    SELF=55
    SUPER=56
    YES=57
    AUTORELEASEPOOL=58
    CATCH=59
    CLASS=60
    DYNAMIC=61
    ENCODE=62
    END=63
    FINALLY=64
    IMPLEMENTATION=65
    INTERFACE=66
    IMPORT=67
    PACKAGE=68
    PROTOCOL=69
    OPTIONAL=70
    PRIVATE=71
    PROPERTY=72
    PROTECTED=73
    PUBLIC=74
    REQUIRED=75
    SELECTOR=76
    SYNCHRONIZED=77
    SYNTHESIZE=78
    THROW=79
    TRY=80
    ATOMIC=81
    NONATOMIC=82
    RETAIN=83
    ATTRIBUTE=84
    AUTORELEASING_QUALIFIER=85
    BLOCK=86
    BRIDGE=87
    BRIDGE_RETAINED=88
    BRIDGE_TRANSFER=89
    COVARIANT=90
    CONTRAVARIANT=91
    DEPRECATED=92
    KINDOF=93
    STRONG_QUALIFIER=94
    TYPEOF=95
    UNSAFE_UNRETAINED_QUALIFIER=96
    UNUSED=97
    WEAK_QUALIFIER=98
    NULL_UNSPECIFIED=99
    NULLABLE=100
    NONNULL=101
    NULL_RESETTABLE=102
    NS_INLINE=103
    NS_ENUM=104
    NS_OPTIONS=105
    ASSIGN=106
    COPY=107
    GETTER=108
    SETTER=109
    STRONG=110
    READONLY=111
    READWRITE=112
    WEAK=113
    UNSAFE_UNRETAINED=114
    IB_OUTLET=115
    IB_OUTLET_COLLECTION=116
    IB_INSPECTABLE=117
    IB_DESIGNABLE=118
    NS_ASSUME_NONNULL_BEGIN=119
    NS_ASSUME_NONNULL_END=120
    EXTERN_SUFFIX=121
    IOS_SUFFIX=122
    MAC_SUFFIX=123
    TVOS_PROHIBITED=124
    IDENTIFIER=125
    LP=126
    RP=127
    LBRACE=128
    RBRACE=129
    LBRACK=130
    RBRACK=131
    SEMI=132
    COMMA=133
    DOT=134
    STRUCTACCESS=135
    AT=136
    ASSIGNMENT=137
    GT=138
    LT=139
    BANG=140
    TILDE=141
    QUESTION=142
    COLON=143
    EQUAL=144
    LE=145
    GE=146
    NOTEQUAL=147
    AND=148
    OR=149
    INC=150
    DEC=151
    ADD=152
    SUB=153
    MUL=154
    DIV=155
    BITAND=156
    BITOR=157
    BITXOR=158
    MOD=159
    ADD_ASSIGN=160
    SUB_ASSIGN=161
    MUL_ASSIGN=162
    DIV_ASSIGN=163
    AND_ASSIGN=164
    OR_ASSIGN=165
    XOR_ASSIGN=166
    MOD_ASSIGN=167
    LSHIFT_ASSIGN=168
    RSHIFT_ASSIGN=169
    ELIPSIS=170
    CHARACTER_LITERAL=171
    STRING_START=172
    HEX_LITERAL=173
    OCTAL_LITERAL=174
    BINARY_LITERAL=175
    DECIMAL_LITERAL=176
    FLOATING_POINT_LITERAL=177
    WS=178
    MULTI_COMMENT=179
    SINGLE_COMMENT=180
    BACKSLASH=181
    SHARP=182
    STRING_NEWLINE=183
    STRING_END=184
    STRING_VALUE=185
    DIRECTIVE_IMPORT=186
    DIRECTIVE_INCLUDE=187
    DIRECTIVE_PRAGMA=188
    DIRECTIVE_DEFINE=189
    DIRECTIVE_DEFINED=190
    DIRECTIVE_IF=191
    DIRECTIVE_ELIF=192
    DIRECTIVE_ELSE=193
    DIRECTIVE_UNDEF=194
    DIRECTIVE_IFDEF=195
    DIRECTIVE_IFNDEF=196
    DIRECTIVE_ENDIF=197
    DIRECTIVE_TRUE=198
    DIRECTIVE_FALSE=199
    DIRECTIVE_ERROR=200
    DIRECTIVE_WARNING=201
    DIRECTIVE_BANG=202
    DIRECTIVE_LP=203
    DIRECTIVE_RP=204
    DIRECTIVE_EQUAL=205
    DIRECTIVE_NOTEQUAL=206
    DIRECTIVE_AND=207
    DIRECTIVE_OR=208
    DIRECTIVE_LT=209
    DIRECTIVE_GT=210
    DIRECTIVE_LE=211
    DIRECTIVE_GE=212
    DIRECTIVE_STRING=213
    DIRECTIVE_ID=214
    DIRECTIVE_DECIMAL_LITERAL=215
    DIRECTIVE_FLOAT=216
    DIRECTIVE_NEWLINE=217
    DIRECTIVE_MULTI_COMMENT=218
    DIRECTIVE_SINGLE_COMMENT=219
    DIRECTIVE_BACKSLASH_NEWLINE=220
    DIRECTIVE_TEXT_NEWLINE=221
    DIRECTIVE_TEXT=222

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



    class TranslationUnitContext(ParserRuleContext):

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

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

        def topLevelDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TopLevelDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TopLevelDeclarationContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_translationUnit

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

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




    def translationUnit(self):

        localctx = ObjectiveCParser.TranslationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 291
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.CLASS))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (ObjectiveCParser.IMPLEMENTATION - 65)) | (1 << (ObjectiveCParser.INTERFACE - 65)) | (1 << (ObjectiveCParser.IMPORT - 65)) | (1 << (ObjectiveCParser.PROTOCOL - 65)) | (1 << (ObjectiveCParser.ATOMIC - 65)) | (1 << (ObjectiveCParser.NONATOMIC - 65)) | (1 << (ObjectiveCParser.RETAIN - 65)) | (1 << (ObjectiveCParser.ATTRIBUTE - 65)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 65)) | (1 << (ObjectiveCParser.BLOCK - 65)) | (1 << (ObjectiveCParser.BRIDGE - 65)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 65)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 65)) | (1 << (ObjectiveCParser.COVARIANT - 65)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 65)) | (1 << (ObjectiveCParser.DEPRECATED - 65)) | (1 << (ObjectiveCParser.KINDOF - 65)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 65)) | (1 << (ObjectiveCParser.TYPEOF - 65)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 65)) | (1 << (ObjectiveCParser.UNUSED - 65)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 65)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 65)) | (1 << (ObjectiveCParser.NULLABLE - 65)) | (1 << (ObjectiveCParser.NONNULL - 65)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 65)) | (1 << (ObjectiveCParser.NS_INLINE - 65)) | (1 << (ObjectiveCParser.NS_ENUM - 65)) | (1 << (ObjectiveCParser.NS_OPTIONS - 65)) | (1 << (ObjectiveCParser.ASSIGN - 65)) | (1 << (ObjectiveCParser.COPY - 65)) | (1 << (ObjectiveCParser.GETTER - 65)) | (1 << (ObjectiveCParser.SETTER - 65)) | (1 << (ObjectiveCParser.STRONG - 65)) | (1 << (ObjectiveCParser.READONLY - 65)) | (1 << (ObjectiveCParser.READWRITE - 65)) | (1 << (ObjectiveCParser.WEAK - 65)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 65)) | (1 << (ObjectiveCParser.IB_OUTLET - 65)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 65)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 65)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 65)) | (1 << (ObjectiveCParser.IDENTIFIER - 65)))) != 0):
                self.state = 288
                self.topLevelDeclaration()
                self.state = 293
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class TopLevelDeclarationContext(ParserRuleContext):

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

        def importDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.ImportDeclarationContext,0)


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


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


        def classInterface(self):
            return self.getTypedRuleContext(ObjectiveCParser.ClassInterfaceContext,0)


        def classImplementation(self):
            return self.getTypedRuleContext(ObjectiveCParser.ClassImplementationContext,0)


        def categoryInterface(self):
            return self.getTypedRuleContext(ObjectiveCParser.CategoryInterfaceContext,0)


        def categoryImplementation(self):
            return self.getTypedRuleContext(ObjectiveCParser.CategoryImplementationContext,0)


        def protocolDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolDeclarationContext,0)


        def protocolDeclarationList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolDeclarationListContext,0)


        def classDeclarationList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ClassDeclarationListContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_topLevelDeclaration

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

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




    def topLevelDeclaration(self):

        localctx = ObjectiveCParser.TopLevelDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_topLevelDeclaration)
        try:
            self.state = 307
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 296
                self.importDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 297
                self.functionDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 298
                self.declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 299
                self.classInterface()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 300
                self.classImplementation()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 301
                self.categoryInterface()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 302
                self.categoryImplementation()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 303
                self.protocolDeclaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 304
                self.protocolDeclarationList()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 305
                self.classDeclarationList()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 306
                self.functionDefinition()
                pass


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

    class ImportDeclarationContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_importDeclaration

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

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




    def importDeclaration(self):

        localctx = ObjectiveCParser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_importDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 309
            self.match(ObjectiveCParser.IMPORT)
            self.state = 310
            self.identifier()
            self.state = 311
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassInterfaceContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.ClassInterfaceContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.className = None # GenericTypeSpecifierContext
            self.superclassName = None # IdentifierContext

        def genericTypeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.GenericTypeSpecifierContext,0)


        def IB_DESIGNABLE(self):
            return self.getToken(ObjectiveCParser.IB_DESIGNABLE, 0)

        def LT(self):
            return self.getToken(ObjectiveCParser.LT, 0)

        def protocolList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolListContext,0)


        def GT(self):
            return self.getToken(ObjectiveCParser.GT, 0)

        def instanceVariables(self):
            return self.getTypedRuleContext(ObjectiveCParser.InstanceVariablesContext,0)


        def interfaceDeclarationList(self):
            return self.getTypedRuleContext(ObjectiveCParser.InterfaceDeclarationListContext,0)


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_classInterface

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

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




    def classInterface(self):

        localctx = ObjectiveCParser.ClassInterfaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_classInterface)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 314
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.IB_DESIGNABLE:
                self.state = 313
                self.match(ObjectiveCParser.IB_DESIGNABLE)


            self.state = 316
            self.match(ObjectiveCParser.INTERFACE)
            self.state = 317
            localctx.className = self.genericTypeSpecifier()
            self.state = 320
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.COLON:
                self.state = 318
                self.match(ObjectiveCParser.COLON)
                self.state = 319
                localctx.superclassName = self.identifier()


            self.state = 326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LT:
                self.state = 322
                self.match(ObjectiveCParser.LT)
                self.state = 323
                self.protocolList()
                self.state = 324
                self.match(ObjectiveCParser.GT)


            self.state = 329
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LBRACE:
                self.state = 328
                self.instanceVariables()


            self.state = 332
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (ObjectiveCParser.PROPERTY - 72)) | (1 << (ObjectiveCParser.ATOMIC - 72)) | (1 << (ObjectiveCParser.NONATOMIC - 72)) | (1 << (ObjectiveCParser.RETAIN - 72)) | (1 << (ObjectiveCParser.ATTRIBUTE - 72)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 72)) | (1 << (ObjectiveCParser.BLOCK - 72)) | (1 << (ObjectiveCParser.BRIDGE - 72)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 72)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 72)) | (1 << (ObjectiveCParser.COVARIANT - 72)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 72)) | (1 << (ObjectiveCParser.DEPRECATED - 72)) | (1 << (ObjectiveCParser.KINDOF - 72)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 72)) | (1 << (ObjectiveCParser.TYPEOF - 72)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 72)) | (1 << (ObjectiveCParser.UNUSED - 72)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 72)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 72)) | (1 << (ObjectiveCParser.NULLABLE - 72)) | (1 << (ObjectiveCParser.NONNULL - 72)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 72)) | (1 << (ObjectiveCParser.NS_INLINE - 72)) | (1 << (ObjectiveCParser.NS_ENUM - 72)) | (1 << (ObjectiveCParser.NS_OPTIONS - 72)) | (1 << (ObjectiveCParser.ASSIGN - 72)) | (1 << (ObjectiveCParser.COPY - 72)) | (1 << (ObjectiveCParser.GETTER - 72)) | (1 << (ObjectiveCParser.SETTER - 72)) | (1 << (ObjectiveCParser.STRONG - 72)) | (1 << (ObjectiveCParser.READONLY - 72)) | (1 << (ObjectiveCParser.READWRITE - 72)) | (1 << (ObjectiveCParser.WEAK - 72)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 72)) | (1 << (ObjectiveCParser.IB_OUTLET - 72)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 72)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 72)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 72)) | (1 << (ObjectiveCParser.IDENTIFIER - 72)))) != 0) or _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                self.state = 331
                self.interfaceDeclarationList()


            self.state = 334
            self.match(ObjectiveCParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CategoryInterfaceContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.CategoryInterfaceContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.categoryName = None # GenericTypeSpecifierContext
            self.className = None # IdentifierContext

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

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

        def genericTypeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.GenericTypeSpecifierContext,0)


        def LT(self):
            return self.getToken(ObjectiveCParser.LT, 0)

        def protocolList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolListContext,0)


        def GT(self):
            return self.getToken(ObjectiveCParser.GT, 0)

        def instanceVariables(self):
            return self.getTypedRuleContext(ObjectiveCParser.InstanceVariablesContext,0)


        def interfaceDeclarationList(self):
            return self.getTypedRuleContext(ObjectiveCParser.InterfaceDeclarationListContext,0)


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_categoryInterface

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

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




    def categoryInterface(self):

        localctx = ObjectiveCParser.CategoryInterfaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_categoryInterface)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self.match(ObjectiveCParser.INTERFACE)
            self.state = 337
            localctx.categoryName = self.genericTypeSpecifier()
            self.state = 338
            self.match(ObjectiveCParser.LP)
            self.state = 340
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 339
                localctx.className = self.identifier()


            self.state = 342
            self.match(ObjectiveCParser.RP)
            self.state = 347
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LT:
                self.state = 343
                self.match(ObjectiveCParser.LT)
                self.state = 344
                self.protocolList()
                self.state = 345
                self.match(ObjectiveCParser.GT)


            self.state = 350
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LBRACE:
                self.state = 349
                self.instanceVariables()


            self.state = 353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (ObjectiveCParser.PROPERTY - 72)) | (1 << (ObjectiveCParser.ATOMIC - 72)) | (1 << (ObjectiveCParser.NONATOMIC - 72)) | (1 << (ObjectiveCParser.RETAIN - 72)) | (1 << (ObjectiveCParser.ATTRIBUTE - 72)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 72)) | (1 << (ObjectiveCParser.BLOCK - 72)) | (1 << (ObjectiveCParser.BRIDGE - 72)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 72)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 72)) | (1 << (ObjectiveCParser.COVARIANT - 72)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 72)) | (1 << (ObjectiveCParser.DEPRECATED - 72)) | (1 << (ObjectiveCParser.KINDOF - 72)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 72)) | (1 << (ObjectiveCParser.TYPEOF - 72)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 72)) | (1 << (ObjectiveCParser.UNUSED - 72)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 72)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 72)) | (1 << (ObjectiveCParser.NULLABLE - 72)) | (1 << (ObjectiveCParser.NONNULL - 72)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 72)) | (1 << (ObjectiveCParser.NS_INLINE - 72)) | (1 << (ObjectiveCParser.NS_ENUM - 72)) | (1 << (ObjectiveCParser.NS_OPTIONS - 72)) | (1 << (ObjectiveCParser.ASSIGN - 72)) | (1 << (ObjectiveCParser.COPY - 72)) | (1 << (ObjectiveCParser.GETTER - 72)) | (1 << (ObjectiveCParser.SETTER - 72)) | (1 << (ObjectiveCParser.STRONG - 72)) | (1 << (ObjectiveCParser.READONLY - 72)) | (1 << (ObjectiveCParser.READWRITE - 72)) | (1 << (ObjectiveCParser.WEAK - 72)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 72)) | (1 << (ObjectiveCParser.IB_OUTLET - 72)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 72)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 72)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 72)) | (1 << (ObjectiveCParser.IDENTIFIER - 72)))) != 0) or _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                self.state = 352
                self.interfaceDeclarationList()


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

    class ClassImplementationContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.ClassImplementationContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.className = None # GenericTypeSpecifierContext
            self.superclassName = None # IdentifierContext

        def genericTypeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.GenericTypeSpecifierContext,0)


        def instanceVariables(self):
            return self.getTypedRuleContext(ObjectiveCParser.InstanceVariablesContext,0)


        def implementationDefinitionList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ImplementationDefinitionListContext,0)


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_classImplementation

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

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




    def classImplementation(self):

        localctx = ObjectiveCParser.ClassImplementationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_classImplementation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 357
            self.match(ObjectiveCParser.IMPLEMENTATION)
            self.state = 358
            localctx.className = self.genericTypeSpecifier()
            self.state = 361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.COLON:
                self.state = 359
                self.match(ObjectiveCParser.COLON)
                self.state = 360
                localctx.superclassName = self.identifier()


            self.state = 364
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LBRACE:
                self.state = 363
                self.instanceVariables()


            self.state = 367
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.DYNAMIC))) != 0) or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & ((1 << (ObjectiveCParser.SYNTHESIZE - 78)) | (1 << (ObjectiveCParser.ATOMIC - 78)) | (1 << (ObjectiveCParser.NONATOMIC - 78)) | (1 << (ObjectiveCParser.RETAIN - 78)) | (1 << (ObjectiveCParser.ATTRIBUTE - 78)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 78)) | (1 << (ObjectiveCParser.BLOCK - 78)) | (1 << (ObjectiveCParser.BRIDGE - 78)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 78)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 78)) | (1 << (ObjectiveCParser.COVARIANT - 78)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 78)) | (1 << (ObjectiveCParser.DEPRECATED - 78)) | (1 << (ObjectiveCParser.KINDOF - 78)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 78)) | (1 << (ObjectiveCParser.TYPEOF - 78)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 78)) | (1 << (ObjectiveCParser.UNUSED - 78)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 78)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 78)) | (1 << (ObjectiveCParser.NULLABLE - 78)) | (1 << (ObjectiveCParser.NONNULL - 78)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 78)) | (1 << (ObjectiveCParser.NS_INLINE - 78)) | (1 << (ObjectiveCParser.NS_ENUM - 78)) | (1 << (ObjectiveCParser.NS_OPTIONS - 78)) | (1 << (ObjectiveCParser.ASSIGN - 78)) | (1 << (ObjectiveCParser.COPY - 78)) | (1 << (ObjectiveCParser.GETTER - 78)) | (1 << (ObjectiveCParser.SETTER - 78)) | (1 << (ObjectiveCParser.STRONG - 78)) | (1 << (ObjectiveCParser.READONLY - 78)) | (1 << (ObjectiveCParser.READWRITE - 78)) | (1 << (ObjectiveCParser.WEAK - 78)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 78)) | (1 << (ObjectiveCParser.IB_OUTLET - 78)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 78)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 78)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 78)) | (1 << (ObjectiveCParser.IDENTIFIER - 78)))) != 0) or _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                self.state = 366
                self.implementationDefinitionList()


            self.state = 369
            self.match(ObjectiveCParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CategoryImplementationContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.CategoryImplementationContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.categoryName = None # GenericTypeSpecifierContext
            self.className = None # IdentifierContext

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

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

        def genericTypeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.GenericTypeSpecifierContext,0)


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def implementationDefinitionList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ImplementationDefinitionListContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_categoryImplementation

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

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




    def categoryImplementation(self):

        localctx = ObjectiveCParser.CategoryImplementationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_categoryImplementation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self.match(ObjectiveCParser.IMPLEMENTATION)
            self.state = 372
            localctx.categoryName = self.genericTypeSpecifier()
            self.state = 373
            self.match(ObjectiveCParser.LP)
            self.state = 374
            localctx.className = self.identifier()
            self.state = 375
            self.match(ObjectiveCParser.RP)
            self.state = 377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.DYNAMIC))) != 0) or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & ((1 << (ObjectiveCParser.SYNTHESIZE - 78)) | (1 << (ObjectiveCParser.ATOMIC - 78)) | (1 << (ObjectiveCParser.NONATOMIC - 78)) | (1 << (ObjectiveCParser.RETAIN - 78)) | (1 << (ObjectiveCParser.ATTRIBUTE - 78)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 78)) | (1 << (ObjectiveCParser.BLOCK - 78)) | (1 << (ObjectiveCParser.BRIDGE - 78)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 78)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 78)) | (1 << (ObjectiveCParser.COVARIANT - 78)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 78)) | (1 << (ObjectiveCParser.DEPRECATED - 78)) | (1 << (ObjectiveCParser.KINDOF - 78)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 78)) | (1 << (ObjectiveCParser.TYPEOF - 78)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 78)) | (1 << (ObjectiveCParser.UNUSED - 78)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 78)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 78)) | (1 << (ObjectiveCParser.NULLABLE - 78)) | (1 << (ObjectiveCParser.NONNULL - 78)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 78)) | (1 << (ObjectiveCParser.NS_INLINE - 78)) | (1 << (ObjectiveCParser.NS_ENUM - 78)) | (1 << (ObjectiveCParser.NS_OPTIONS - 78)) | (1 << (ObjectiveCParser.ASSIGN - 78)) | (1 << (ObjectiveCParser.COPY - 78)) | (1 << (ObjectiveCParser.GETTER - 78)) | (1 << (ObjectiveCParser.SETTER - 78)) | (1 << (ObjectiveCParser.STRONG - 78)) | (1 << (ObjectiveCParser.READONLY - 78)) | (1 << (ObjectiveCParser.READWRITE - 78)) | (1 << (ObjectiveCParser.WEAK - 78)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 78)) | (1 << (ObjectiveCParser.IB_OUTLET - 78)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 78)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 78)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 78)) | (1 << (ObjectiveCParser.IDENTIFIER - 78)))) != 0) or _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                self.state = 376
                self.implementationDefinitionList()


            self.state = 379
            self.match(ObjectiveCParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class GenericTypeSpecifierContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def genericsSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.GenericsSpecifierContext,0)


        def LT(self):
            return self.getToken(ObjectiveCParser.LT, 0)

        def protocolList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolListContext,0)


        def GT(self):
            return self.getToken(ObjectiveCParser.GT, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_genericTypeSpecifier

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

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




    def genericTypeSpecifier(self):

        localctx = ObjectiveCParser.GenericTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_genericTypeSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 381
            self.identifier()
            self.state = 387
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
            if la_ == 1:
                self.state = 382
                self.match(ObjectiveCParser.LT)
                self.state = 383
                self.protocolList()
                self.state = 384
                self.match(ObjectiveCParser.GT)

            elif la_ == 2:
                self.state = 386
                self.genericsSpecifier()


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

    class ProtocolDeclarationContext(ParserRuleContext):

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

        def protocolName(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolNameContext,0)


        def LT(self):
            return self.getToken(ObjectiveCParser.LT, 0)

        def protocolList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolListContext,0)


        def GT(self):
            return self.getToken(ObjectiveCParser.GT, 0)

        def protocolDeclarationSection(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ProtocolDeclarationSectionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ProtocolDeclarationSectionContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolDeclaration

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

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




    def protocolDeclaration(self):

        localctx = ObjectiveCParser.ProtocolDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_protocolDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 389
            self.match(ObjectiveCParser.PROTOCOL)
            self.state = 390
            self.protocolName()
            self.state = 395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LT:
                self.state = 391
                self.match(ObjectiveCParser.LT)
                self.state = 392
                self.protocolList()
                self.state = 393
                self.match(ObjectiveCParser.GT)


            self.state = 400
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (ObjectiveCParser.OPTIONAL - 70)) | (1 << (ObjectiveCParser.PROPERTY - 70)) | (1 << (ObjectiveCParser.REQUIRED - 70)) | (1 << (ObjectiveCParser.ATOMIC - 70)) | (1 << (ObjectiveCParser.NONATOMIC - 70)) | (1 << (ObjectiveCParser.RETAIN - 70)) | (1 << (ObjectiveCParser.ATTRIBUTE - 70)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 70)) | (1 << (ObjectiveCParser.BLOCK - 70)) | (1 << (ObjectiveCParser.BRIDGE - 70)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 70)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 70)) | (1 << (ObjectiveCParser.COVARIANT - 70)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 70)) | (1 << (ObjectiveCParser.DEPRECATED - 70)) | (1 << (ObjectiveCParser.KINDOF - 70)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 70)) | (1 << (ObjectiveCParser.TYPEOF - 70)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 70)) | (1 << (ObjectiveCParser.UNUSED - 70)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 70)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 70)) | (1 << (ObjectiveCParser.NULLABLE - 70)) | (1 << (ObjectiveCParser.NONNULL - 70)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 70)) | (1 << (ObjectiveCParser.NS_INLINE - 70)) | (1 << (ObjectiveCParser.NS_ENUM - 70)) | (1 << (ObjectiveCParser.NS_OPTIONS - 70)) | (1 << (ObjectiveCParser.ASSIGN - 70)) | (1 << (ObjectiveCParser.COPY - 70)) | (1 << (ObjectiveCParser.GETTER - 70)) | (1 << (ObjectiveCParser.SETTER - 70)) | (1 << (ObjectiveCParser.STRONG - 70)) | (1 << (ObjectiveCParser.READONLY - 70)) | (1 << (ObjectiveCParser.READWRITE - 70)) | (1 << (ObjectiveCParser.WEAK - 70)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 70)) | (1 << (ObjectiveCParser.IB_OUTLET - 70)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 70)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 70)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 70)) | (1 << (ObjectiveCParser.IDENTIFIER - 70)))) != 0) or _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                self.state = 397
                self.protocolDeclarationSection()
                self.state = 402
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 403
            self.match(ObjectiveCParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ProtocolDeclarationSectionContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.ProtocolDeclarationSectionContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.modifier = None # Token

        def REQUIRED(self):
            return self.getToken(ObjectiveCParser.REQUIRED, 0)

        def OPTIONAL(self):
            return self.getToken(ObjectiveCParser.OPTIONAL, 0)

        def interfaceDeclarationList(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.InterfaceDeclarationListContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.InterfaceDeclarationListContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolDeclarationSection

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

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




    def protocolDeclarationSection(self):

        localctx = ObjectiveCParser.ProtocolDeclarationSectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_protocolDeclarationSection)
        self._la = 0 # Token type
        try:
            self.state = 417
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.OPTIONAL, ObjectiveCParser.REQUIRED]:
                self.enterOuterAlt(localctx, 1)
                self.state = 405
                localctx.modifier = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==ObjectiveCParser.OPTIONAL or _la==ObjectiveCParser.REQUIRED):
                    localctx.modifier = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 409
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,18,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 406
                        self.interfaceDeclarationList() 
                    self.state = 411
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,18,self._ctx)

                pass
            elif token in [ObjectiveCParser.AUTO, ObjectiveCParser.CHAR, ObjectiveCParser.CONST, ObjectiveCParser.DOUBLE, ObjectiveCParser.ENUM, ObjectiveCParser.EXTERN, ObjectiveCParser.FLOAT, ObjectiveCParser.INLINE, ObjectiveCParser.INT, ObjectiveCParser.LONG, ObjectiveCParser.REGISTER, ObjectiveCParser.RESTRICT, ObjectiveCParser.SHORT, ObjectiveCParser.SIGNED, ObjectiveCParser.STATIC, ObjectiveCParser.STRUCT, ObjectiveCParser.TYPEDEF, ObjectiveCParser.UNION, ObjectiveCParser.UNSIGNED, ObjectiveCParser.VOID, ObjectiveCParser.VOLATILE, ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.PROPERTY, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.ATTRIBUTE, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.STRONG_QUALIFIER, ObjectiveCParser.TYPEOF, ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER, ObjectiveCParser.UNUSED, ObjectiveCParser.WEAK_QUALIFIER, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER, ObjectiveCParser.ADD, ObjectiveCParser.SUB]:
                self.enterOuterAlt(localctx, 2)
                self.state = 413 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 412
                        self.interfaceDeclarationList()

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

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

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

        def protocolList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolListContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolDeclarationList

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

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




    def protocolDeclarationList(self):

        localctx = ObjectiveCParser.ProtocolDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_protocolDeclarationList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self.match(ObjectiveCParser.PROTOCOL)
            self.state = 420
            self.protocolList()
            self.state = 421
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassDeclarationListContext(ParserRuleContext):

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

        def identifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_classDeclarationList

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

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




    def classDeclarationList(self):

        localctx = ObjectiveCParser.ClassDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_classDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 423
            self.match(ObjectiveCParser.CLASS)
            self.state = 424
            self.identifier()
            self.state = 429
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 425
                self.match(ObjectiveCParser.COMMA)
                self.state = 426
                self.identifier()
                self.state = 431
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 432
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ProtocolListContext(ParserRuleContext):

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

        def protocolName(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ProtocolNameContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ProtocolNameContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolList

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

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




    def protocolList(self):

        localctx = ObjectiveCParser.ProtocolListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_protocolList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 434
            self.protocolName()
            self.state = 439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 435
                self.match(ObjectiveCParser.COMMA)
                self.state = 436
                self.protocolName()
                self.state = 441
                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 PropertyDeclarationContext(ParserRuleContext):

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

        def fieldDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.FieldDeclarationContext,0)


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

        def propertyAttributesList(self):
            return self.getTypedRuleContext(ObjectiveCParser.PropertyAttributesListContext,0)


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

        def ibOutletQualifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IbOutletQualifierContext,0)


        def IB_INSPECTABLE(self):
            return self.getToken(ObjectiveCParser.IB_INSPECTABLE, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_propertyDeclaration

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

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




    def propertyDeclaration(self):

        localctx = ObjectiveCParser.PropertyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_propertyDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 442
            self.match(ObjectiveCParser.PROPERTY)
            self.state = 447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 443
                self.match(ObjectiveCParser.LP)
                self.state = 444
                self.propertyAttributesList()
                self.state = 445
                self.match(ObjectiveCParser.RP)


            self.state = 450
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 449
                self.ibOutletQualifier()


            self.state = 453
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.state = 452
                self.match(ObjectiveCParser.IB_INSPECTABLE)


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

    class PropertyAttributesListContext(ParserRuleContext):

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

        def propertyAttribute(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.PropertyAttributeContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.PropertyAttributeContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_propertyAttributesList

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

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




    def propertyAttributesList(self):

        localctx = ObjectiveCParser.PropertyAttributesListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_propertyAttributesList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 457
            self.propertyAttribute()
            self.state = 462
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 458
                self.match(ObjectiveCParser.COMMA)
                self.state = 459
                self.propertyAttribute()
                self.state = 464
                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 PropertyAttributeContext(ParserRuleContext):

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

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

        def NONATOMIC(self):
            return self.getToken(ObjectiveCParser.NONATOMIC, 0)

        def STRONG(self):
            return self.getToken(ObjectiveCParser.STRONG, 0)

        def WEAK(self):
            return self.getToken(ObjectiveCParser.WEAK, 0)

        def RETAIN(self):
            return self.getToken(ObjectiveCParser.RETAIN, 0)

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

        def UNSAFE_UNRETAINED(self):
            return self.getToken(ObjectiveCParser.UNSAFE_UNRETAINED, 0)

        def COPY(self):
            return self.getToken(ObjectiveCParser.COPY, 0)

        def READONLY(self):
            return self.getToken(ObjectiveCParser.READONLY, 0)

        def READWRITE(self):
            return self.getToken(ObjectiveCParser.READWRITE, 0)

        def GETTER(self):
            return self.getToken(ObjectiveCParser.GETTER, 0)

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def SETTER(self):
            return self.getToken(ObjectiveCParser.SETTER, 0)

        def nullabilitySpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_propertyAttribute

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

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




    def propertyAttribute(self):

        localctx = ObjectiveCParser.PropertyAttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_propertyAttribute)
        try:
            self.state = 485
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 465
                self.match(ObjectiveCParser.ATOMIC)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 466
                self.match(ObjectiveCParser.NONATOMIC)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 467
                self.match(ObjectiveCParser.STRONG)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 468
                self.match(ObjectiveCParser.WEAK)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 469
                self.match(ObjectiveCParser.RETAIN)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 470
                self.match(ObjectiveCParser.ASSIGN)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 471
                self.match(ObjectiveCParser.UNSAFE_UNRETAINED)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 472
                self.match(ObjectiveCParser.COPY)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 473
                self.match(ObjectiveCParser.READONLY)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 474
                self.match(ObjectiveCParser.READWRITE)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 475
                self.match(ObjectiveCParser.GETTER)
                self.state = 476
                self.match(ObjectiveCParser.ASSIGNMENT)
                self.state = 477
                self.identifier()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 478
                self.match(ObjectiveCParser.SETTER)
                self.state = 479
                self.match(ObjectiveCParser.ASSIGNMENT)
                self.state = 480
                self.identifier()
                self.state = 481
                self.match(ObjectiveCParser.COLON)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 483
                self.nullabilitySpecifier()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 484
                self.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 ProtocolNameContext(ParserRuleContext):

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

        def LT(self):
            return self.getToken(ObjectiveCParser.LT, 0)

        def protocolList(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolListContext,0)


        def GT(self):
            return self.getToken(ObjectiveCParser.GT, 0)

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolName

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

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




    def protocolName(self):

        localctx = ObjectiveCParser.ProtocolNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_protocolName)
        self._la = 0 # Token type
        try:
            self.state = 495
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.LT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 487
                self.match(ObjectiveCParser.LT)
                self.state = 488
                self.protocolList()
                self.state = 489
                self.match(ObjectiveCParser.GT)
                pass
            elif token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 492
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
                if la_ == 1:
                    self.state = 491
                    _la = self._input.LA(1)
                    if not(_la==ObjectiveCParser.COVARIANT or _la==ObjectiveCParser.CONTRAVARIANT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


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

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

        def visibilitySection(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.VisibilitySectionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.VisibilitySectionContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_instanceVariables

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

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




    def instanceVariables(self):

        localctx = ObjectiveCParser.InstanceVariablesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_instanceVariables)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 497
            self.match(ObjectiveCParser.LBRACE)
            self.state = 501
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (ObjectiveCParser.PACKAGE - 68)) | (1 << (ObjectiveCParser.PRIVATE - 68)) | (1 << (ObjectiveCParser.PROTECTED - 68)) | (1 << (ObjectiveCParser.PUBLIC - 68)) | (1 << (ObjectiveCParser.ATOMIC - 68)) | (1 << (ObjectiveCParser.NONATOMIC - 68)) | (1 << (ObjectiveCParser.RETAIN - 68)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 68)) | (1 << (ObjectiveCParser.BLOCK - 68)) | (1 << (ObjectiveCParser.BRIDGE - 68)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 68)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 68)) | (1 << (ObjectiveCParser.COVARIANT - 68)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 68)) | (1 << (ObjectiveCParser.DEPRECATED - 68)) | (1 << (ObjectiveCParser.KINDOF - 68)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 68)) | (1 << (ObjectiveCParser.TYPEOF - 68)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 68)) | (1 << (ObjectiveCParser.UNUSED - 68)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 68)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 68)) | (1 << (ObjectiveCParser.NULLABLE - 68)) | (1 << (ObjectiveCParser.NONNULL - 68)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 68)) | (1 << (ObjectiveCParser.NS_INLINE - 68)) | (1 << (ObjectiveCParser.NS_ENUM - 68)) | (1 << (ObjectiveCParser.NS_OPTIONS - 68)) | (1 << (ObjectiveCParser.ASSIGN - 68)) | (1 << (ObjectiveCParser.COPY - 68)) | (1 << (ObjectiveCParser.GETTER - 68)) | (1 << (ObjectiveCParser.SETTER - 68)) | (1 << (ObjectiveCParser.STRONG - 68)) | (1 << (ObjectiveCParser.READONLY - 68)) | (1 << (ObjectiveCParser.READWRITE - 68)) | (1 << (ObjectiveCParser.WEAK - 68)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 68)) | (1 << (ObjectiveCParser.IB_OUTLET - 68)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 68)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 68)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 68)) | (1 << (ObjectiveCParser.IDENTIFIER - 68)))) != 0):
                self.state = 498
                self.visibilitySection()
                self.state = 503
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 504
            self.match(ObjectiveCParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VisibilitySectionContext(ParserRuleContext):

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

        def accessModifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.AccessModifierContext,0)


        def fieldDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.FieldDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.FieldDeclarationContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_visibilitySection

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

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




    def visibilitySection(self):

        localctx = ObjectiveCParser.VisibilitySectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_visibilitySection)
        try:
            self.state = 518
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.PACKAGE, ObjectiveCParser.PRIVATE, ObjectiveCParser.PROTECTED, ObjectiveCParser.PUBLIC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 506
                self.accessModifier()
                self.state = 510
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,31,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 507
                        self.fieldDeclaration() 
                    self.state = 512
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,31,self._ctx)

                pass
            elif token in [ObjectiveCParser.CHAR, ObjectiveCParser.CONST, ObjectiveCParser.DOUBLE, ObjectiveCParser.ENUM, ObjectiveCParser.FLOAT, ObjectiveCParser.INLINE, ObjectiveCParser.INT, ObjectiveCParser.LONG, ObjectiveCParser.RESTRICT, ObjectiveCParser.SHORT, ObjectiveCParser.SIGNED, ObjectiveCParser.STRUCT, ObjectiveCParser.UNION, ObjectiveCParser.UNSIGNED, ObjectiveCParser.VOID, ObjectiveCParser.VOLATILE, ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.STRONG_QUALIFIER, ObjectiveCParser.TYPEOF, ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER, ObjectiveCParser.UNUSED, ObjectiveCParser.WEAK_QUALIFIER, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 514 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 513
                        self.fieldDeclaration()

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

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

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

        def PRIVATE(self):
            return self.getToken(ObjectiveCParser.PRIVATE, 0)

        def PROTECTED(self):
            return self.getToken(ObjectiveCParser.PROTECTED, 0)

        def PACKAGE(self):
            return self.getToken(ObjectiveCParser.PACKAGE, 0)

        def PUBLIC(self):
            return self.getToken(ObjectiveCParser.PUBLIC, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_accessModifier

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

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




    def accessModifier(self):

        localctx = ObjectiveCParser.AccessModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_accessModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 520
            _la = self._input.LA(1)
            if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (ObjectiveCParser.PACKAGE - 68)) | (1 << (ObjectiveCParser.PRIVATE - 68)) | (1 << (ObjectiveCParser.PROTECTED - 68)) | (1 << (ObjectiveCParser.PUBLIC - 68)))) != 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 InterfaceDeclarationListContext(ParserRuleContext):

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

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


        def classMethodDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ClassMethodDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ClassMethodDeclarationContext,i)


        def instanceMethodDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.InstanceMethodDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.InstanceMethodDeclarationContext,i)


        def propertyDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.PropertyDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.PropertyDeclarationContext,i)


        def functionDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.FunctionDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.FunctionDeclarationContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_interfaceDeclarationList

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

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




    def interfaceDeclarationList(self):

        localctx = ObjectiveCParser.InterfaceDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_interfaceDeclarationList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 527
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                    if la_ == 1:
                        self.state = 522
                        self.declaration()
                        pass

                    elif la_ == 2:
                        self.state = 523
                        self.classMethodDeclaration()
                        pass

                    elif la_ == 3:
                        self.state = 524
                        self.instanceMethodDeclaration()
                        pass

                    elif la_ == 4:
                        self.state = 525
                        self.propertyDeclaration()
                        pass

                    elif la_ == 5:
                        self.state = 526
                        self.functionDeclaration()
                        pass



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

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

    class ClassMethodDeclarationContext(ParserRuleContext):

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

        def methodDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodDeclarationContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_classMethodDeclaration

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

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




    def classMethodDeclaration(self):

        localctx = ObjectiveCParser.ClassMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_classMethodDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531
            self.match(ObjectiveCParser.ADD)
            self.state = 532
            self.methodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InstanceMethodDeclarationContext(ParserRuleContext):

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

        def methodDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodDeclarationContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_instanceMethodDeclaration

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

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




    def instanceMethodDeclaration(self):

        localctx = ObjectiveCParser.InstanceMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_instanceMethodDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 534
            self.match(ObjectiveCParser.SUB)
            self.state = 535
            self.methodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodDeclarationContext(ParserRuleContext):

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

        def methodSelector(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodSelectorContext,0)


        def methodType(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodTypeContext,0)


        def macro(self):
            return self.getTypedRuleContext(ObjectiveCParser.MacroContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_methodDeclaration

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

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




    def methodDeclaration(self):

        localctx = ObjectiveCParser.MethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_methodDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 537
                self.methodType()


            self.state = 540
            self.methodSelector()
            self.state = 542
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 541
                self.macro()


            self.state = 544
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ImplementationDefinitionListContext(ParserRuleContext):

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

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


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


        def classMethodDefinition(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ClassMethodDefinitionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ClassMethodDefinitionContext,i)


        def instanceMethodDefinition(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.InstanceMethodDefinitionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.InstanceMethodDefinitionContext,i)


        def propertyImplementation(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.PropertyImplementationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.PropertyImplementationContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_implementationDefinitionList

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

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




    def implementationDefinitionList(self):

        localctx = ObjectiveCParser.ImplementationDefinitionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_implementationDefinitionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 551
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
                if la_ == 1:
                    self.state = 546
                    self.functionDefinition()
                    pass

                elif la_ == 2:
                    self.state = 547
                    self.declaration()
                    pass

                elif la_ == 3:
                    self.state = 548
                    self.classMethodDefinition()
                    pass

                elif la_ == 4:
                    self.state = 549
                    self.instanceMethodDefinition()
                    pass

                elif la_ == 5:
                    self.state = 550
                    self.propertyImplementation()
                    pass


                self.state = 553 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.DYNAMIC))) != 0) or ((((_la - 78)) & ~0x3f) == 0 and ((1 << (_la - 78)) & ((1 << (ObjectiveCParser.SYNTHESIZE - 78)) | (1 << (ObjectiveCParser.ATOMIC - 78)) | (1 << (ObjectiveCParser.NONATOMIC - 78)) | (1 << (ObjectiveCParser.RETAIN - 78)) | (1 << (ObjectiveCParser.ATTRIBUTE - 78)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 78)) | (1 << (ObjectiveCParser.BLOCK - 78)) | (1 << (ObjectiveCParser.BRIDGE - 78)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 78)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 78)) | (1 << (ObjectiveCParser.COVARIANT - 78)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 78)) | (1 << (ObjectiveCParser.DEPRECATED - 78)) | (1 << (ObjectiveCParser.KINDOF - 78)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 78)) | (1 << (ObjectiveCParser.TYPEOF - 78)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 78)) | (1 << (ObjectiveCParser.UNUSED - 78)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 78)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 78)) | (1 << (ObjectiveCParser.NULLABLE - 78)) | (1 << (ObjectiveCParser.NONNULL - 78)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 78)) | (1 << (ObjectiveCParser.NS_INLINE - 78)) | (1 << (ObjectiveCParser.NS_ENUM - 78)) | (1 << (ObjectiveCParser.NS_OPTIONS - 78)) | (1 << (ObjectiveCParser.ASSIGN - 78)) | (1 << (ObjectiveCParser.COPY - 78)) | (1 << (ObjectiveCParser.GETTER - 78)) | (1 << (ObjectiveCParser.SETTER - 78)) | (1 << (ObjectiveCParser.STRONG - 78)) | (1 << (ObjectiveCParser.READONLY - 78)) | (1 << (ObjectiveCParser.READWRITE - 78)) | (1 << (ObjectiveCParser.WEAK - 78)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 78)) | (1 << (ObjectiveCParser.IB_OUTLET - 78)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 78)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 78)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 78)) | (1 << (ObjectiveCParser.IDENTIFIER - 78)))) != 0) or _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB):
                    break

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

    class ClassMethodDefinitionContext(ParserRuleContext):

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

        def methodDefinition(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodDefinitionContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_classMethodDefinition

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

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




    def classMethodDefinition(self):

        localctx = ObjectiveCParser.ClassMethodDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_classMethodDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 555
            self.match(ObjectiveCParser.ADD)
            self.state = 556
            self.methodDefinition()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InstanceMethodDefinitionContext(ParserRuleContext):

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

        def methodDefinition(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodDefinitionContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_instanceMethodDefinition

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

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




    def instanceMethodDefinition(self):

        localctx = ObjectiveCParser.InstanceMethodDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_instanceMethodDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self.match(ObjectiveCParser.SUB)
            self.state = 559
            self.methodDefinition()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodDefinitionContext(ParserRuleContext):

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

        def methodSelector(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodSelectorContext,0)


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


        def methodType(self):
            return self.getTypedRuleContext(ObjectiveCParser.MethodTypeContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_methodDefinition

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

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




    def methodDefinition(self):

        localctx = ObjectiveCParser.MethodDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_methodDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 562
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 561
                self.methodType()


            self.state = 564
            self.methodSelector()
            self.state = 566
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 40)) & ~0x3f) == 0 and ((1 << (_la - 40)) & ((1 << (ObjectiveCParser.BOOL - 40)) | (1 << (ObjectiveCParser.Class - 40)) | (1 << (ObjectiveCParser.BYCOPY - 40)) | (1 << (ObjectiveCParser.BYREF - 40)) | (1 << (ObjectiveCParser.ID - 40)) | (1 << (ObjectiveCParser.IMP - 40)) | (1 << (ObjectiveCParser.IN - 40)) | (1 << (ObjectiveCParser.INOUT - 40)) | (1 << (ObjectiveCParser.ONEWAY - 40)) | (1 << (ObjectiveCParser.OUT - 40)) | (1 << (ObjectiveCParser.PROTOCOL_ - 40)) | (1 << (ObjectiveCParser.SEL - 40)) | (1 << (ObjectiveCParser.SELF - 40)) | (1 << (ObjectiveCParser.SUPER - 40)) | (1 << (ObjectiveCParser.ATOMIC - 40)) | (1 << (ObjectiveCParser.NONATOMIC - 40)) | (1 << (ObjectiveCParser.RETAIN - 40)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 40)) | (1 << (ObjectiveCParser.BLOCK - 40)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 40)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 40)) | (1 << (ObjectiveCParser.COVARIANT - 40)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 40)) | (1 << (ObjectiveCParser.DEPRECATED - 40)) | (1 << (ObjectiveCParser.KINDOF - 40)) | (1 << (ObjectiveCParser.UNUSED - 40)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 40)) | (1 << (ObjectiveCParser.NULLABLE - 40)) | (1 << (ObjectiveCParser.NONNULL - 40)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 40)) | (1 << (ObjectiveCParser.NS_INLINE - 40)))) != 0) or ((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & ((1 << (ObjectiveCParser.NS_ENUM - 104)) | (1 << (ObjectiveCParser.NS_OPTIONS - 104)) | (1 << (ObjectiveCParser.ASSIGN - 104)) | (1 << (ObjectiveCParser.COPY - 104)) | (1 << (ObjectiveCParser.GETTER - 104)) | (1 << (ObjectiveCParser.SETTER - 104)) | (1 << (ObjectiveCParser.STRONG - 104)) | (1 << (ObjectiveCParser.READONLY - 104)) | (1 << (ObjectiveCParser.READWRITE - 104)) | (1 << (ObjectiveCParser.WEAK - 104)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 104)) | (1 << (ObjectiveCParser.IB_OUTLET - 104)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 104)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 104)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 104)) | (1 << (ObjectiveCParser.IDENTIFIER - 104)) | (1 << (ObjectiveCParser.LP - 104)) | (1 << (ObjectiveCParser.MUL - 104)))) != 0):
                self.state = 565
                self.initDeclaratorList()


            self.state = 569
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.SEMI:
                self.state = 568
                self.match(ObjectiveCParser.SEMI)


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

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

        def selector(self):
            return self.getTypedRuleContext(ObjectiveCParser.SelectorContext,0)


        def keywordDeclarator(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.KeywordDeclaratorContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.KeywordDeclaratorContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_methodSelector

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

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




    def methodSelector(self):

        localctx = ObjectiveCParser.MethodSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_methodSelector)
        self._la = 0 # Token type
        try:
            self.state = 583
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 573
                self.selector()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 575 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 574
                        self.keywordDeclarator()

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

                self.state = 581
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.COMMA:
                    self.state = 579
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 580
                    self.match(ObjectiveCParser.ELIPSIS)


                pass


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

    class KeywordDeclaratorContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def selector(self):
            return self.getTypedRuleContext(ObjectiveCParser.SelectorContext,0)


        def methodType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.MethodTypeContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.MethodTypeContext,i)


        def arcBehaviourSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.ArcBehaviourSpecifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_keywordDeclarator

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

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




    def keywordDeclarator(self):

        localctx = ObjectiveCParser.KeywordDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_keywordDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 586
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 585
                self.selector()


            self.state = 588
            self.match(ObjectiveCParser.COLON)
            self.state = 592
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.LP:
                self.state = 589
                self.methodType()
                self.state = 594
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 596
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.state = 595
                self.arcBehaviourSpecifier()


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

    class SelectorContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_selector

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

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




    def selector(self):

        localctx = ObjectiveCParser.SelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_selector)
        try:
            self.state = 602
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 600
                self.identifier()
                pass
            elif token in [ObjectiveCParser.RETURN]:
                self.enterOuterAlt(localctx, 2)
                self.state = 601
                self.match(ObjectiveCParser.RETURN)
                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 MethodTypeContext(ParserRuleContext):

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

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

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


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_methodType

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

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




    def methodType(self):

        localctx = ObjectiveCParser.MethodTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_methodType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 604
            self.match(ObjectiveCParser.LP)
            self.state = 605
            self.typeName()
            self.state = 606
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PropertyImplementationContext(ParserRuleContext):

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

        def propertySynthesizeList(self):
            return self.getTypedRuleContext(ObjectiveCParser.PropertySynthesizeListContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_propertyImplementation

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

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




    def propertyImplementation(self):

        localctx = ObjectiveCParser.PropertyImplementationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_propertyImplementation)
        try:
            self.state = 616
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.SYNTHESIZE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 608
                self.match(ObjectiveCParser.SYNTHESIZE)
                self.state = 609
                self.propertySynthesizeList()
                self.state = 610
                self.match(ObjectiveCParser.SEMI)
                pass
            elif token in [ObjectiveCParser.DYNAMIC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 612
                self.match(ObjectiveCParser.DYNAMIC)
                self.state = 613
                self.propertySynthesizeList()
                self.state = 614
                self.match(ObjectiveCParser.SEMI)
                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 PropertySynthesizeListContext(ParserRuleContext):

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

        def propertySynthesizeItem(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.PropertySynthesizeItemContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.PropertySynthesizeItemContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_propertySynthesizeList

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

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




    def propertySynthesizeList(self):

        localctx = ObjectiveCParser.PropertySynthesizeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_propertySynthesizeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 618
            self.propertySynthesizeItem()
            self.state = 623
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 619
                self.match(ObjectiveCParser.COMMA)
                self.state = 620
                self.propertySynthesizeItem()
                self.state = 625
                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 PropertySynthesizeItemContext(ParserRuleContext):

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

        def identifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_propertySynthesizeItem

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

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




    def propertySynthesizeItem(self):

        localctx = ObjectiveCParser.PropertySynthesizeItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_propertySynthesizeItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 626
            self.identifier()
            self.state = 629
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ASSIGNMENT:
                self.state = 627
                self.match(ObjectiveCParser.ASSIGNMENT)
                self.state = 628
                self.identifier()


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

    class BlockTypeContext(ParserRuleContext):

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

        def typeSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypeSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypeSpecifierContext,i)


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

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

        def nullabilitySpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.NullabilitySpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,i)


        def blockParameters(self):
            return self.getTypedRuleContext(ObjectiveCParser.BlockParametersContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_blockType

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

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




    def blockType(self):

        localctx = ObjectiveCParser.BlockTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_blockType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 632
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.state = 631
                self.nullabilitySpecifier()


            self.state = 634
            self.typeSpecifier()
            self.state = 636
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & ((1 << (ObjectiveCParser.NULL_UNSPECIFIED - 99)) | (1 << (ObjectiveCParser.NULLABLE - 99)) | (1 << (ObjectiveCParser.NONNULL - 99)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 99)))) != 0):
                self.state = 635
                self.nullabilitySpecifier()


            self.state = 638
            self.match(ObjectiveCParser.LP)
            self.state = 639
            self.match(ObjectiveCParser.BITXOR)
            self.state = 642
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 640
                self.nullabilitySpecifier()

            elif la_ == 2:
                self.state = 641
                self.typeSpecifier()


            self.state = 644
            self.match(ObjectiveCParser.RP)
            self.state = 646
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 645
                self.blockParameters()


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

    class GenericsSpecifierContext(ParserRuleContext):

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

        def LT(self):
            return self.getToken(ObjectiveCParser.LT, 0)

        def GT(self):
            return self.getToken(ObjectiveCParser.GT, 0)

        def typeSpecifierWithPrefixes(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypeSpecifierWithPrefixesContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypeSpecifierWithPrefixesContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_genericsSpecifier

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

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




    def genericsSpecifier(self):

        localctx = ObjectiveCParser.GenericsSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_genericsSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self.match(ObjectiveCParser.LT)
            self.state = 657
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.TYPEOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 649
                self.typeSpecifierWithPrefixes()
                self.state = 654
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ObjectiveCParser.COMMA:
                    self.state = 650
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 651
                    self.typeSpecifierWithPrefixes()
                    self.state = 656
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 659
            self.match(ObjectiveCParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeSpecifierWithPrefixesContext(ParserRuleContext):

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

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


        def typePrefix(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypePrefixContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypePrefixContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeSpecifierWithPrefixes

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

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




    def typeSpecifierWithPrefixes(self):

        localctx = ObjectiveCParser.TypeSpecifierWithPrefixesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_typeSpecifierWithPrefixes)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 664
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,59,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 661
                    self.typePrefix() 
                self.state = 666
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,59,self._ctx)

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

    class DictionaryExpressionContext(ParserRuleContext):

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

        def dictionaryPair(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.DictionaryPairContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.DictionaryPairContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_dictionaryExpression

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

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




    def dictionaryExpression(self):

        localctx = ObjectiveCParser.DictionaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_dictionaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 669
            self.match(ObjectiveCParser.AT)
            self.state = 670
            self.match(ObjectiveCParser.LBRACE)
            self.state = 682
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 671
                self.dictionaryPair()
                self.state = 676
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 672
                        self.match(ObjectiveCParser.COMMA)
                        self.state = 673
                        self.dictionaryPair() 
                    self.state = 678
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,60,self._ctx)

                self.state = 680
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.COMMA:
                    self.state = 679
                    self.match(ObjectiveCParser.COMMA)




            self.state = 684
            self.match(ObjectiveCParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DictionaryPairContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_dictionaryPair

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

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




    def dictionaryPair(self):

        localctx = ObjectiveCParser.DictionaryPairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_dictionaryPair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 686
            self.castExpression()
            self.state = 687
            self.match(ObjectiveCParser.COLON)
            self.state = 688
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArrayExpressionContext(ParserRuleContext):

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

        def expressions(self):
            return self.getTypedRuleContext(ObjectiveCParser.ExpressionsContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_arrayExpression

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

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




    def arrayExpression(self):

        localctx = ObjectiveCParser.ArrayExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_arrayExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 690
            self.match(ObjectiveCParser.AT)
            self.state = 691
            self.match(ObjectiveCParser.LBRACK)
            self.state = 696
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 692
                self.expressions()
                self.state = 694
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.COMMA:
                    self.state = 693
                    self.match(ObjectiveCParser.COMMA)




            self.state = 698
            self.match(ObjectiveCParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BoxExpressionContext(ParserRuleContext):

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

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

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


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

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


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_boxExpression

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

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




    def boxExpression(self):

        localctx = ObjectiveCParser.BoxExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_boxExpression)
        try:
            self.state = 710
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 700
                self.match(ObjectiveCParser.AT)
                self.state = 701
                self.match(ObjectiveCParser.LP)
                self.state = 702
                self.expression(0)
                self.state = 703
                self.match(ObjectiveCParser.RP)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 705
                self.match(ObjectiveCParser.AT)
                self.state = 708
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [ObjectiveCParser.TRUE, ObjectiveCParser.FALSE, ObjectiveCParser.NIL, ObjectiveCParser.NO, ObjectiveCParser.NULL, ObjectiveCParser.YES, ObjectiveCParser.ADD, ObjectiveCParser.SUB, ObjectiveCParser.CHARACTER_LITERAL, ObjectiveCParser.HEX_LITERAL, ObjectiveCParser.OCTAL_LITERAL, ObjectiveCParser.BINARY_LITERAL, ObjectiveCParser.DECIMAL_LITERAL, ObjectiveCParser.FLOATING_POINT_LITERAL]:
                    self.state = 706
                    self.constant()
                    pass
                elif token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                    self.state = 707
                    self.identifier()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


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

    class BlockParametersContext(ParserRuleContext):

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

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

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

        def typeVariableDeclaratorOrName(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypeVariableDeclaratorOrNameContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypeVariableDeclaratorOrNameContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_blockParameters

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

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




    def blockParameters(self):

        localctx = ObjectiveCParser.BlockParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_blockParameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            self.match(ObjectiveCParser.LP)
            self.state = 724
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.ATTRIBUTE - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 81)) | (1 << (ObjectiveCParser.TYPEOF - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 715
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
                if la_ == 1:
                    self.state = 713
                    self.typeVariableDeclaratorOrName()
                    pass

                elif la_ == 2:
                    self.state = 714
                    self.match(ObjectiveCParser.VOID)
                    pass


                self.state = 721
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ObjectiveCParser.COMMA:
                    self.state = 717
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 718
                    self.typeVariableDeclaratorOrName()
                    self.state = 723
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 726
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeVariableDeclaratorOrNameContext(ParserRuleContext):

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

        def typeVariableDeclarator(self):
            return self.getTypedRuleContext(ObjectiveCParser.TypeVariableDeclaratorContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeVariableDeclaratorOrName

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

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




    def typeVariableDeclaratorOrName(self):

        localctx = ObjectiveCParser.TypeVariableDeclaratorOrNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_typeVariableDeclaratorOrName)
        try:
            self.state = 730
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 728
                self.typeVariableDeclarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 729
                self.typeName()
                pass


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

    class BlockExpressionContext(ParserRuleContext):

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

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


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


        def nullabilitySpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,0)


        def blockParameters(self):
            return self.getTypedRuleContext(ObjectiveCParser.BlockParametersContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_blockExpression

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

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




    def blockExpression(self):

        localctx = ObjectiveCParser.BlockExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_blockExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 732
            self.match(ObjectiveCParser.BITXOR)
            self.state = 734
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 733
                self.typeSpecifier()


            self.state = 737
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & ((1 << (ObjectiveCParser.NULL_UNSPECIFIED - 99)) | (1 << (ObjectiveCParser.NULLABLE - 99)) | (1 << (ObjectiveCParser.NONNULL - 99)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 99)))) != 0):
                self.state = 736
                self.nullabilitySpecifier()


            self.state = 740
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 739
                self.blockParameters()


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

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

        def receiver(self):
            return self.getTypedRuleContext(ObjectiveCParser.ReceiverContext,0)


        def messageSelector(self):
            return self.getTypedRuleContext(ObjectiveCParser.MessageSelectorContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_messageExpression

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

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




    def messageExpression(self):

        localctx = ObjectiveCParser.MessageExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_messageExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 744
            self.match(ObjectiveCParser.LBRACK)
            self.state = 745
            self.receiver()
            self.state = 746
            self.messageSelector()
            self.state = 747
            self.match(ObjectiveCParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ReceiverContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_receiver

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

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




    def receiver(self):

        localctx = ObjectiveCParser.ReceiverContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_receiver)
        try:
            self.state = 751
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 749
                self.expression(0)
                pass

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


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

    class MessageSelectorContext(ParserRuleContext):

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

        def selector(self):
            return self.getTypedRuleContext(ObjectiveCParser.SelectorContext,0)


        def keywordArgument(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.KeywordArgumentContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.KeywordArgumentContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_messageSelector

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

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




    def messageSelector(self):

        localctx = ObjectiveCParser.MessageSelectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_messageSelector)
        self._la = 0 # Token type
        try:
            self.state = 759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 753
                self.selector()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 755 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 754
                    self.keywordArgument()
                    self.state = 757 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)) | (1 << (ObjectiveCParser.COLON - 81)))) != 0)):
                        break

                pass


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

    class KeywordArgumentContext(ParserRuleContext):

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

        def keywordArgumentType(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.KeywordArgumentTypeContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.KeywordArgumentTypeContext,i)


        def selector(self):
            return self.getTypedRuleContext(ObjectiveCParser.SelectorContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_keywordArgument

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

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




    def keywordArgument(self):

        localctx = ObjectiveCParser.KeywordArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_keywordArgument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 762
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 761
                self.selector()


            self.state = 764
            self.match(ObjectiveCParser.COLON)
            self.state = 765
            self.keywordArgumentType()
            self.state = 770
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 766
                self.match(ObjectiveCParser.COMMA)
                self.state = 767
                self.keywordArgumentType()
                self.state = 772
                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 KeywordArgumentTypeContext(ParserRuleContext):

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

        def expressions(self):
            return self.getTypedRuleContext(ObjectiveCParser.ExpressionsContext,0)


        def nullabilitySpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_keywordArgumentType

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

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




    def keywordArgumentType(self):

        localctx = ObjectiveCParser.KeywordArgumentTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_keywordArgumentType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 773
            self.expressions()
            self.state = 775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 774
                self.nullabilitySpecifier()


            self.state = 781
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LBRACE:
                self.state = 777
                self.match(ObjectiveCParser.LBRACE)
                self.state = 778
                self.initializerList()
                self.state = 779
                self.match(ObjectiveCParser.RBRACE)


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

    class SelectorExpressionContext(ParserRuleContext):

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

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

        def selectorName(self):
            return self.getTypedRuleContext(ObjectiveCParser.SelectorNameContext,0)


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_selectorExpression

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

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




    def selectorExpression(self):

        localctx = ObjectiveCParser.SelectorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_selectorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 783
            self.match(ObjectiveCParser.SELECTOR)
            self.state = 784
            self.match(ObjectiveCParser.LP)
            self.state = 785
            self.selectorName()
            self.state = 786
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SelectorNameContext(ParserRuleContext):

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

        def selector(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.SelectorContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.SelectorContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_selectorName

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

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




    def selectorName(self):

        localctx = ObjectiveCParser.SelectorNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_selectorName)
        self._la = 0 # Token type
        try:
            self.state = 797
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 788
                self.selector()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 793 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 790
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                        self.state = 789
                        self.selector()


                    self.state = 792
                    self.match(ObjectiveCParser.COLON)
                    self.state = 795 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)) | (1 << (ObjectiveCParser.COLON - 81)))) != 0)):
                        break

                pass


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

    class ProtocolExpressionContext(ParserRuleContext):

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

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

        def protocolName(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolNameContext,0)


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolExpression

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

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




    def protocolExpression(self):

        localctx = ObjectiveCParser.ProtocolExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_protocolExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 799
            self.match(ObjectiveCParser.PROTOCOL)
            self.state = 800
            self.match(ObjectiveCParser.LP)
            self.state = 801
            self.protocolName()
            self.state = 802
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EncodeExpressionContext(ParserRuleContext):

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

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

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


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_encodeExpression

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

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




    def encodeExpression(self):

        localctx = ObjectiveCParser.EncodeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_encodeExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 804
            self.match(ObjectiveCParser.ENCODE)
            self.state = 805
            self.match(ObjectiveCParser.LP)
            self.state = 806
            self.typeName()
            self.state = 807
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeVariableDeclaratorContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeVariableDeclarator

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

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




    def typeVariableDeclarator(self):

        localctx = ObjectiveCParser.TypeVariableDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_typeVariableDeclarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 809
            self.declarationSpecifiers()
            self.state = 810
            self.declarator()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ThrowStatementContext(ParserRuleContext):

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

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_throwStatement

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

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




    def throwStatement(self):

        localctx = ObjectiveCParser.ThrowStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_throwStatement)
        try:
            self.state = 819
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 812
                self.match(ObjectiveCParser.THROW)
                self.state = 813
                self.match(ObjectiveCParser.LP)
                self.state = 814
                self.identifier()
                self.state = 815
                self.match(ObjectiveCParser.RP)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 817
                self.match(ObjectiveCParser.THROW)
                self.state = 818
                self.expression(0)
                pass


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

    class TryBlockContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.TryBlockContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.tryStatement = None # CompoundStatementContext
            self.finallyStatement = None # CompoundStatementContext

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


        def catchStatement(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.CatchStatementContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.CatchStatementContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_tryBlock

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

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




    def tryBlock(self):

        localctx = ObjectiveCParser.TryBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_tryBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 821
            self.match(ObjectiveCParser.TRY)
            self.state = 822
            localctx.tryStatement = self.compoundStatement()
            self.state = 826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.CATCH:
                self.state = 823
                self.catchStatement()
                self.state = 828
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 831
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.FINALLY:
                self.state = 829
                self.match(ObjectiveCParser.FINALLY)
                self.state = 830
                localctx.finallyStatement = 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 CatchStatementContext(ParserRuleContext):

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

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

        def typeVariableDeclarator(self):
            return self.getTypedRuleContext(ObjectiveCParser.TypeVariableDeclaratorContext,0)


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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_catchStatement

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

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




    def catchStatement(self):

        localctx = ObjectiveCParser.CatchStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_catchStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 833
            self.match(ObjectiveCParser.CATCH)
            self.state = 834
            self.match(ObjectiveCParser.LP)
            self.state = 835
            self.typeVariableDeclarator()
            self.state = 836
            self.match(ObjectiveCParser.RP)
            self.state = 837
            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 SynchronizedStatementContext(ParserRuleContext):

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

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

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


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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_synchronizedStatement

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

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




    def synchronizedStatement(self):

        localctx = ObjectiveCParser.SynchronizedStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_synchronizedStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 839
            self.match(ObjectiveCParser.SYNCHRONIZED)
            self.state = 840
            self.match(ObjectiveCParser.LP)
            self.state = 841
            self.expression(0)
            self.state = 842
            self.match(ObjectiveCParser.RP)
            self.state = 843
            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 AutoreleaseStatementContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_autoreleaseStatement

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

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




    def autoreleaseStatement(self):

        localctx = ObjectiveCParser.AutoreleaseStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_autoreleaseStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 845
            self.match(ObjectiveCParser.AUTORELEASEPOOL)
            self.state = 846
            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 FunctionDeclarationContext(ParserRuleContext):

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

        def functionSignature(self):
            return self.getTypedRuleContext(ObjectiveCParser.FunctionSignatureContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_functionDeclaration

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

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




    def functionDeclaration(self):

        localctx = ObjectiveCParser.FunctionDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_functionDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 848
            self.functionSignature()
            self.state = 849
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FunctionDefinitionContext(ParserRuleContext):

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

        def functionSignature(self):
            return self.getTypedRuleContext(ObjectiveCParser.FunctionSignatureContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_functionDefinition

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

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




    def functionDefinition(self):

        localctx = ObjectiveCParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_functionDefinition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self.functionSignature()
            self.state = 852
            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 FunctionSignatureContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

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

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


        def attributeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeSpecifierContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_functionSignature

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

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




    def functionSignature(self):

        localctx = ObjectiveCParser.FunctionSignatureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_functionSignature)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 855
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 854
                self.declarationSpecifiers()


            self.state = 857
            self.identifier()

            self.state = 858
            self.match(ObjectiveCParser.LP)
            self.state = 860
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.ATTRIBUTE - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 81)) | (1 << (ObjectiveCParser.TYPEOF - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 859
                self.parameterList()


            self.state = 862
            self.match(ObjectiveCParser.RP)
            self.state = 865
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ATTRIBUTE:
                self.state = 864
                self.attributeSpecifier()


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

    class AttributeContext(ParserRuleContext):

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

        def attributeName(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeNameContext,0)


        def attributeParameters(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeParametersContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attribute

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

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




    def attribute(self):

        localctx = ObjectiveCParser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 867
            self.attributeName()
            self.state = 869
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 868
                self.attributeParameters()


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

    class AttributeNameContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attributeName

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

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




    def attributeName(self):

        localctx = ObjectiveCParser.AttributeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_attributeName)
        try:
            self.state = 873
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.CONST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 871
                self.match(ObjectiveCParser.CONST)
                pass
            elif token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 872
                self.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 AttributeParametersContext(ParserRuleContext):

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

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

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

        def attributeParameterList(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeParameterListContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attributeParameters

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

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




    def attributeParameters(self):

        localctx = ObjectiveCParser.AttributeParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_attributeParameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 875
            self.match(ObjectiveCParser.LP)
            self.state = 877
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (ObjectiveCParser.ADD - 152)) | (1 << (ObjectiveCParser.SUB - 152)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 152)) | (1 << (ObjectiveCParser.STRING_START - 152)) | (1 << (ObjectiveCParser.HEX_LITERAL - 152)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 152)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 152)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 152)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 152)))) != 0):
                self.state = 876
                self.attributeParameterList()


            self.state = 879
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AttributeParameterListContext(ParserRuleContext):

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

        def attributeParameter(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.AttributeParameterContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.AttributeParameterContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attributeParameterList

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

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




    def attributeParameterList(self):

        localctx = ObjectiveCParser.AttributeParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_attributeParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 881
            self.attributeParameter()
            self.state = 886
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 882
                self.match(ObjectiveCParser.COMMA)
                self.state = 883
                self.attributeParameter()
                self.state = 888
                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 AttributeParameterContext(ParserRuleContext):

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

        def attribute(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeContext,0)


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


        def stringLiteral(self):
            return self.getTypedRuleContext(ObjectiveCParser.StringLiteralContext,0)


        def attributeParameterAssignment(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeParameterAssignmentContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attributeParameter

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

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




    def attributeParameter(self):

        localctx = ObjectiveCParser.AttributeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_attributeParameter)
        try:
            self.state = 893
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 889
                self.attribute()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 890
                self.constant()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 891
                self.stringLiteral()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 892
                self.attributeParameterAssignment()
                pass


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

    class AttributeParameterAssignmentContext(ParserRuleContext):

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

        def attributeName(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.AttributeNameContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.AttributeNameContext,i)


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


        def stringLiteral(self):
            return self.getTypedRuleContext(ObjectiveCParser.StringLiteralContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attributeParameterAssignment

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

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




    def attributeParameterAssignment(self):

        localctx = ObjectiveCParser.AttributeParameterAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_attributeParameterAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 895
            self.attributeName()
            self.state = 896
            self.match(ObjectiveCParser.ASSIGNMENT)
            self.state = 900
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.TRUE, ObjectiveCParser.FALSE, ObjectiveCParser.NIL, ObjectiveCParser.NO, ObjectiveCParser.NULL, ObjectiveCParser.YES, ObjectiveCParser.ADD, ObjectiveCParser.SUB, ObjectiveCParser.CHARACTER_LITERAL, ObjectiveCParser.HEX_LITERAL, ObjectiveCParser.OCTAL_LITERAL, ObjectiveCParser.BINARY_LITERAL, ObjectiveCParser.DECIMAL_LITERAL, ObjectiveCParser.FLOATING_POINT_LITERAL]:
                self.state = 897
                self.constant()
                pass
            elif token in [ObjectiveCParser.CONST, ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.state = 898
                self.attributeName()
                pass
            elif token in [ObjectiveCParser.STRING_START]:
                self.state = 899
                self.stringLiteral()
                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 DeclarationContext(ParserRuleContext):

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

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


        def enumDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.EnumDeclarationContext,0)


        def varDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.VarDeclarationContext,0)


        def typedefDeclaration(self):
            return self.getTypedRuleContext(ObjectiveCParser.TypedefDeclarationContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_declaration

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

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




    def declaration(self):

        localctx = ObjectiveCParser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_declaration)
        try:
            self.state = 906
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 902
                self.functionCallExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 903
                self.enumDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 904
                self.varDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 905
                self.typedefDeclaration()
                pass


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

    class FunctionCallExpressionContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

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


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

        def attributeSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.AttributeSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.AttributeSpecifierContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_functionCallExpression

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

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




    def functionCallExpression(self):

        localctx = ObjectiveCParser.FunctionCallExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_functionCallExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 909
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ATTRIBUTE:
                self.state = 908
                self.attributeSpecifier()


            self.state = 911
            self.identifier()
            self.state = 913
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ATTRIBUTE:
                self.state = 912
                self.attributeSpecifier()


            self.state = 915
            self.match(ObjectiveCParser.LP)
            self.state = 916
            self.directDeclarator()
            self.state = 917
            self.match(ObjectiveCParser.RP)
            self.state = 918
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumDeclarationContext(ParserRuleContext):

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

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


        def attributeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeSpecifierContext,0)


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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_enumDeclaration

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

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




    def enumDeclaration(self):

        localctx = ObjectiveCParser.EnumDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_enumDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ATTRIBUTE:
                self.state = 920
                self.attributeSpecifier()


            self.state = 924
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.TYPEDEF:
                self.state = 923
                self.match(ObjectiveCParser.TYPEDEF)


            self.state = 926
            self.enumSpecifier()
            self.state = 928
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 927
                self.identifier()


            self.state = 930
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VarDeclarationContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_varDeclaration

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

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




    def varDeclaration(self):

        localctx = ObjectiveCParser.VarDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_varDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 936
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
            if la_ == 1:
                self.state = 932
                self.declarationSpecifiers()
                self.state = 933
                self.initDeclaratorList()
                pass

            elif la_ == 2:
                self.state = 935
                self.declarationSpecifiers()
                pass


            self.state = 938
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypedefDeclarationContext(ParserRuleContext):

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

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

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


        def typeDeclaratorList(self):
            return self.getTypedRuleContext(ObjectiveCParser.TypeDeclaratorListContext,0)


        def attributeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.AttributeSpecifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typedefDeclaration

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

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




    def typedefDeclaration(self):

        localctx = ObjectiveCParser.TypedefDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_typedefDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 941
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ATTRIBUTE:
                self.state = 940
                self.attributeSpecifier()


            self.state = 943
            self.match(ObjectiveCParser.TYPEDEF)
            self.state = 948
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                self.state = 944
                self.declarationSpecifiers()
                self.state = 945
                self.typeDeclaratorList()
                pass

            elif la_ == 2:
                self.state = 947
                self.declarationSpecifiers()
                pass


            self.state = 950
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeDeclaratorListContext(ParserRuleContext):

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

        def typeDeclarator(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypeDeclaratorContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypeDeclaratorContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeDeclaratorList

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

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




    def typeDeclaratorList(self):

        localctx = ObjectiveCParser.TypeDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_typeDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 952
            self.typeDeclarator()
            self.state = 957
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 953
                self.match(ObjectiveCParser.COMMA)
                self.state = 954
                self.typeDeclarator()
                self.state = 959
                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 TypeDeclaratorContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeDeclarator

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

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




    def typeDeclarator(self):

        localctx = ObjectiveCParser.TypeDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_typeDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 961
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.MUL:
                self.state = 960
                self.pointer()


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

    class DeclarationSpecifiersContext(ParserRuleContext):

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

        def storageClassSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.StorageClassSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.StorageClassSpecifierContext,i)


        def attributeSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.AttributeSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.AttributeSpecifierContext,i)


        def arcBehaviourSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ArcBehaviourSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ArcBehaviourSpecifierContext,i)


        def nullabilitySpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.NullabilitySpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,i)


        def ibOutletQualifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.IbOutletQualifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.IbOutletQualifierContext,i)


        def typePrefix(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypePrefixContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypePrefixContext,i)


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


        def typeSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypeSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypeSpecifierContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_declarationSpecifiers

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

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




    def declarationSpecifiers(self):

        localctx = ObjectiveCParser.DeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_declarationSpecifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 973 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 973
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
                    if la_ == 1:
                        self.state = 965
                        self.storageClassSpecifier()
                        pass

                    elif la_ == 2:
                        self.state = 966
                        self.attributeSpecifier()
                        pass

                    elif la_ == 3:
                        self.state = 967
                        self.arcBehaviourSpecifier()
                        pass

                    elif la_ == 4:
                        self.state = 968
                        self.nullabilitySpecifier()
                        pass

                    elif la_ == 5:
                        self.state = 969
                        self.ibOutletQualifier()
                        pass

                    elif la_ == 6:
                        self.state = 970
                        self.typePrefix()
                        pass

                    elif la_ == 7:
                        self.state = 971
                        self.typeQualifier()
                        pass

                    elif la_ == 8:
                        self.state = 972
                        self.typeSpecifier()
                        pass



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

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

    class AttributeSpecifierContext(ParserRuleContext):

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

        def LP(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.LP)
            else:
                return self.getToken(ObjectiveCParser.LP, i)

        def attribute(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.AttributeContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.AttributeContext,i)


        def RP(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.RP)
            else:
                return self.getToken(ObjectiveCParser.RP, i)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_attributeSpecifier

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

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




    def attributeSpecifier(self):

        localctx = ObjectiveCParser.AttributeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_attributeSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 977
            self.match(ObjectiveCParser.ATTRIBUTE)
            self.state = 978
            self.match(ObjectiveCParser.LP)
            self.state = 979
            self.match(ObjectiveCParser.LP)
            self.state = 980
            self.attribute()
            self.state = 985
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 981
                self.match(ObjectiveCParser.COMMA)
                self.state = 982
                self.attribute()
                self.state = 987
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 988
            self.match(ObjectiveCParser.RP)
            self.state = 989
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InitDeclaratorListContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_initDeclaratorList

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

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




    def initDeclaratorList(self):

        localctx = ObjectiveCParser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 991
            self.initDeclarator()
            self.state = 996
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 992
                self.match(ObjectiveCParser.COMMA)
                self.state = 993
                self.initDeclarator()
                self.state = 998
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class InitDeclaratorContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_initDeclarator

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

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




    def initDeclarator(self):

        localctx = ObjectiveCParser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 999
            self.declarator()
            self.state = 1002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ASSIGNMENT:
                self.state = 1000
                self.match(ObjectiveCParser.ASSIGNMENT)
                self.state = 1001
                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 StructOrUnionSpecifierContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def fieldDeclaration(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.FieldDeclarationContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.FieldDeclarationContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_structOrUnionSpecifier

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

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




    def structOrUnionSpecifier(self):

        localctx = ObjectiveCParser.StructOrUnionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_structOrUnionSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1004
            _la = self._input.LA(1)
            if not(_la==ObjectiveCParser.STRUCT or _la==ObjectiveCParser.UNION):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1017
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 1005
                self.identifier()
                pass

            elif la_ == 2:
                self.state = 1007
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                    self.state = 1006
                    self.identifier()


                self.state = 1009
                self.match(ObjectiveCParser.LBRACE)
                self.state = 1011 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1010
                    self.fieldDeclaration()
                    self.state = 1013 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 81)) | (1 << (ObjectiveCParser.TYPEOF - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0)):
                        break

                self.state = 1015
                self.match(ObjectiveCParser.RBRACE)
                pass


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

    class FieldDeclarationContext(ParserRuleContext):

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

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


        def fieldDeclaratorList(self):
            return self.getTypedRuleContext(ObjectiveCParser.FieldDeclaratorListContext,0)


        def macro(self):
            return self.getTypedRuleContext(ObjectiveCParser.MacroContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_fieldDeclaration

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

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




    def fieldDeclaration(self):

        localctx = ObjectiveCParser.FieldDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_fieldDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1019
            self.specifierQualifierList()
            self.state = 1020
            self.fieldDeclaratorList()
            self.state = 1022
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                self.state = 1021
                self.macro()


            self.state = 1024
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SpecifierQualifierListContext(ParserRuleContext):

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

        def arcBehaviourSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ArcBehaviourSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ArcBehaviourSpecifierContext,i)


        def nullabilitySpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.NullabilitySpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,i)


        def ibOutletQualifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.IbOutletQualifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.IbOutletQualifierContext,i)


        def typePrefix(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypePrefixContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypePrefixContext,i)


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


        def typeSpecifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.TypeSpecifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.TypeSpecifierContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_specifierQualifierList

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

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




    def specifierQualifierList(self):

        localctx = ObjectiveCParser.SpecifierQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_specifierQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1032 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1032
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
                    if la_ == 1:
                        self.state = 1026
                        self.arcBehaviourSpecifier()
                        pass

                    elif la_ == 2:
                        self.state = 1027
                        self.nullabilitySpecifier()
                        pass

                    elif la_ == 3:
                        self.state = 1028
                        self.ibOutletQualifier()
                        pass

                    elif la_ == 4:
                        self.state = 1029
                        self.typePrefix()
                        pass

                    elif la_ == 5:
                        self.state = 1030
                        self.typeQualifier()
                        pass

                    elif la_ == 6:
                        self.state = 1031
                        self.typeSpecifier()
                        pass



                else:
                    raise NoViableAltException(self)
                self.state = 1034 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,117,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 IbOutletQualifierContext(ParserRuleContext):

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

        def IB_OUTLET_COLLECTION(self):
            return self.getToken(ObjectiveCParser.IB_OUTLET_COLLECTION, 0)

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

        def IB_OUTLET(self):
            return self.getToken(ObjectiveCParser.IB_OUTLET, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_ibOutletQualifier

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

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




    def ibOutletQualifier(self):

        localctx = ObjectiveCParser.IbOutletQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_ibOutletQualifier)
        try:
            self.state = 1042
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.IB_OUTLET_COLLECTION]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1036
                self.match(ObjectiveCParser.IB_OUTLET_COLLECTION)
                self.state = 1037
                self.match(ObjectiveCParser.LP)
                self.state = 1038
                self.identifier()
                self.state = 1039
                self.match(ObjectiveCParser.RP)
                pass
            elif token in [ObjectiveCParser.IB_OUTLET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1041
                self.match(ObjectiveCParser.IB_OUTLET)
                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 ArcBehaviourSpecifierContext(ParserRuleContext):

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

        def WEAK_QUALIFIER(self):
            return self.getToken(ObjectiveCParser.WEAK_QUALIFIER, 0)

        def STRONG_QUALIFIER(self):
            return self.getToken(ObjectiveCParser.STRONG_QUALIFIER, 0)

        def AUTORELEASING_QUALIFIER(self):
            return self.getToken(ObjectiveCParser.AUTORELEASING_QUALIFIER, 0)

        def UNSAFE_UNRETAINED_QUALIFIER(self):
            return self.getToken(ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_arcBehaviourSpecifier

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

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




    def arcBehaviourSpecifier(self):

        localctx = ObjectiveCParser.ArcBehaviourSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_arcBehaviourSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1044
            _la = self._input.LA(1)
            if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 85)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 85)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 85)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 85)))) != 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 NullabilitySpecifierContext(ParserRuleContext):

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

        def NULL_UNSPECIFIED(self):
            return self.getToken(ObjectiveCParser.NULL_UNSPECIFIED, 0)

        def NULLABLE(self):
            return self.getToken(ObjectiveCParser.NULLABLE, 0)

        def NONNULL(self):
            return self.getToken(ObjectiveCParser.NONNULL, 0)

        def NULL_RESETTABLE(self):
            return self.getToken(ObjectiveCParser.NULL_RESETTABLE, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_nullabilitySpecifier

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

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




    def nullabilitySpecifier(self):

        localctx = ObjectiveCParser.NullabilitySpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_nullabilitySpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1046
            _la = self._input.LA(1)
            if not(((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & ((1 << (ObjectiveCParser.NULL_UNSPECIFIED - 99)) | (1 << (ObjectiveCParser.NULLABLE - 99)) | (1 << (ObjectiveCParser.NONNULL - 99)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 99)))) != 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 StorageClassSpecifierContext(ParserRuleContext):

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

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

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

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

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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_storageClassSpecifier

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

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




    def storageClassSpecifier(self):

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

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

        def BRIDGE(self):
            return self.getToken(ObjectiveCParser.BRIDGE, 0)

        def BRIDGE_TRANSFER(self):
            return self.getToken(ObjectiveCParser.BRIDGE_TRANSFER, 0)

        def BRIDGE_RETAINED(self):
            return self.getToken(ObjectiveCParser.BRIDGE_RETAINED, 0)

        def BLOCK(self):
            return self.getToken(ObjectiveCParser.BLOCK, 0)

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

        def NS_INLINE(self):
            return self.getToken(ObjectiveCParser.NS_INLINE, 0)

        def KINDOF(self):
            return self.getToken(ObjectiveCParser.KINDOF, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typePrefix

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

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




    def typePrefix(self):

        localctx = ObjectiveCParser.TypePrefixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_typePrefix)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1050
            _la = self._input.LA(1)
            if not(_la==ObjectiveCParser.INLINE or ((((_la - 86)) & ~0x3f) == 0 and ((1 << (_la - 86)) & ((1 << (ObjectiveCParser.BLOCK - 86)) | (1 << (ObjectiveCParser.BRIDGE - 86)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 86)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 86)) | (1 << (ObjectiveCParser.KINDOF - 86)) | (1 << (ObjectiveCParser.NS_INLINE - 86)))) != 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 TypeQualifierContext(ParserRuleContext):

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

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

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

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

        def protocolQualifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolQualifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeQualifier

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

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




    def typeQualifier(self):

        localctx = ObjectiveCParser.TypeQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_typeQualifier)
        try:
            self.state = 1056
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.CONST]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1052
                self.match(ObjectiveCParser.CONST)
                pass
            elif token in [ObjectiveCParser.VOLATILE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1053
                self.match(ObjectiveCParser.VOLATILE)
                pass
            elif token in [ObjectiveCParser.RESTRICT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1054
                self.match(ObjectiveCParser.RESTRICT)
                pass
            elif token in [ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1055
                self.protocolQualifier()
                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 ProtocolQualifierContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_protocolQualifier

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

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




    def protocolQualifier(self):

        localctx = ObjectiveCParser.ProtocolQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_protocolQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1058
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeSpecifierContext(ParserRuleContext):

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

        def typeofExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.TypeofExpressionContext,0)


        def genericTypeSpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.GenericTypeSpecifierContext,0)


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


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


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeSpecifier

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

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




    def typeSpecifier(self):

        localctx = ObjectiveCParser.TypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_typeSpecifier)
        try:
            self.state = 1077
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1060
                self.match(ObjectiveCParser.VOID)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1061
                self.match(ObjectiveCParser.CHAR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1062
                self.match(ObjectiveCParser.SHORT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1063
                self.match(ObjectiveCParser.INT)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1064
                self.match(ObjectiveCParser.LONG)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1065
                self.match(ObjectiveCParser.FLOAT)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1066
                self.match(ObjectiveCParser.DOUBLE)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1067
                self.match(ObjectiveCParser.SIGNED)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1068
                self.match(ObjectiveCParser.UNSIGNED)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1069
                self.typeofExpression()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1070
                self.genericTypeSpecifier()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1071
                self.structOrUnionSpecifier()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1072
                self.enumSpecifier()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1073
                self.identifier()
                self.state = 1075
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,120,self._ctx)
                if la_ == 1:
                    self.state = 1074
                    self.pointer()


                pass


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

    class TypeofExpressionContext(ParserRuleContext):

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

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

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

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


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeofExpression

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

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




    def typeofExpression(self):

        localctx = ObjectiveCParser.TypeofExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_typeofExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1079
            self.match(ObjectiveCParser.TYPEOF)

            self.state = 1080
            self.match(ObjectiveCParser.LP)
            self.state = 1081
            self.expression(0)
            self.state = 1082
            self.match(ObjectiveCParser.RP)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FieldDeclaratorListContext(ParserRuleContext):

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

        def fieldDeclarator(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.FieldDeclaratorContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.FieldDeclaratorContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_fieldDeclaratorList

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

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




    def fieldDeclaratorList(self):

        localctx = ObjectiveCParser.FieldDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_fieldDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1084
            self.fieldDeclarator()
            self.state = 1089
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 1085
                self.match(ObjectiveCParser.COMMA)
                self.state = 1086
                self.fieldDeclarator()
                self.state = 1091
                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 FieldDeclaratorContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_fieldDeclarator

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

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




    def fieldDeclarator(self):

        localctx = ObjectiveCParser.FieldDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_fieldDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1098
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1092
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1094
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 40)) & ~0x3f) == 0 and ((1 << (_la - 40)) & ((1 << (ObjectiveCParser.BOOL - 40)) | (1 << (ObjectiveCParser.Class - 40)) | (1 << (ObjectiveCParser.BYCOPY - 40)) | (1 << (ObjectiveCParser.BYREF - 40)) | (1 << (ObjectiveCParser.ID - 40)) | (1 << (ObjectiveCParser.IMP - 40)) | (1 << (ObjectiveCParser.IN - 40)) | (1 << (ObjectiveCParser.INOUT - 40)) | (1 << (ObjectiveCParser.ONEWAY - 40)) | (1 << (ObjectiveCParser.OUT - 40)) | (1 << (ObjectiveCParser.PROTOCOL_ - 40)) | (1 << (ObjectiveCParser.SEL - 40)) | (1 << (ObjectiveCParser.SELF - 40)) | (1 << (ObjectiveCParser.SUPER - 40)) | (1 << (ObjectiveCParser.ATOMIC - 40)) | (1 << (ObjectiveCParser.NONATOMIC - 40)) | (1 << (ObjectiveCParser.RETAIN - 40)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 40)) | (1 << (ObjectiveCParser.BLOCK - 40)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 40)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 40)) | (1 << (ObjectiveCParser.COVARIANT - 40)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 40)) | (1 << (ObjectiveCParser.DEPRECATED - 40)) | (1 << (ObjectiveCParser.KINDOF - 40)) | (1 << (ObjectiveCParser.UNUSED - 40)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 40)) | (1 << (ObjectiveCParser.NULLABLE - 40)) | (1 << (ObjectiveCParser.NONNULL - 40)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 40)) | (1 << (ObjectiveCParser.NS_INLINE - 40)))) != 0) or ((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & ((1 << (ObjectiveCParser.NS_ENUM - 104)) | (1 << (ObjectiveCParser.NS_OPTIONS - 104)) | (1 << (ObjectiveCParser.ASSIGN - 104)) | (1 << (ObjectiveCParser.COPY - 104)) | (1 << (ObjectiveCParser.GETTER - 104)) | (1 << (ObjectiveCParser.SETTER - 104)) | (1 << (ObjectiveCParser.STRONG - 104)) | (1 << (ObjectiveCParser.READONLY - 104)) | (1 << (ObjectiveCParser.READWRITE - 104)) | (1 << (ObjectiveCParser.WEAK - 104)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 104)) | (1 << (ObjectiveCParser.IB_OUTLET - 104)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 104)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 104)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 104)) | (1 << (ObjectiveCParser.IDENTIFIER - 104)) | (1 << (ObjectiveCParser.LP - 104)) | (1 << (ObjectiveCParser.MUL - 104)))) != 0):
                    self.state = 1093
                    self.declarator()


                self.state = 1096
                self.match(ObjectiveCParser.COLON)
                self.state = 1097
                self.constant()
                pass


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

    class EnumSpecifierContext(ParserRuleContext):

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

        def identifier(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,i)


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


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


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

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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_enumSpecifier

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

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




    def enumSpecifier(self):

        localctx = ObjectiveCParser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1131
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.ENUM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1100
                self.match(ObjectiveCParser.ENUM)
                self.state = 1106
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
                if la_ == 1:
                    self.state = 1102
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                        self.state = 1101
                        self.identifier()


                    self.state = 1104
                    self.match(ObjectiveCParser.COLON)
                    self.state = 1105
                    self.typeName()


                self.state = 1119
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                    self.state = 1108
                    self.identifier()
                    self.state = 1113
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
                    if la_ == 1:
                        self.state = 1109
                        self.match(ObjectiveCParser.LBRACE)
                        self.state = 1110
                        self.enumeratorList()
                        self.state = 1111
                        self.match(ObjectiveCParser.RBRACE)


                    pass
                elif token in [ObjectiveCParser.LBRACE]:
                    self.state = 1115
                    self.match(ObjectiveCParser.LBRACE)
                    self.state = 1116
                    self.enumeratorList()
                    self.state = 1117
                    self.match(ObjectiveCParser.RBRACE)
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1121
                _la = self._input.LA(1)
                if not(_la==ObjectiveCParser.NS_ENUM or _la==ObjectiveCParser.NS_OPTIONS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1122
                self.match(ObjectiveCParser.LP)
                self.state = 1123
                self.typeName()
                self.state = 1124
                self.match(ObjectiveCParser.COMMA)
                self.state = 1125
                self.identifier()
                self.state = 1126
                self.match(ObjectiveCParser.RP)
                self.state = 1127
                self.match(ObjectiveCParser.LBRACE)
                self.state = 1128
                self.enumeratorList()
                self.state = 1129
                self.match(ObjectiveCParser.RBRACE)
                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 EnumeratorListContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_enumeratorList

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

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




    def enumeratorList(self):

        localctx = ObjectiveCParser.EnumeratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_enumeratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1133
            self.enumerator()
            self.state = 1138
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,130,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1134
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 1135
                    self.enumerator() 
                self.state = 1140
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,130,self._ctx)

            self.state = 1142
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.COMMA:
                self.state = 1141
                self.match(ObjectiveCParser.COMMA)


        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):

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

        def enumeratorIdentifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.EnumeratorIdentifierContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_enumerator

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

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




    def enumerator(self):

        localctx = ObjectiveCParser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_enumerator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1144
            self.enumeratorIdentifier()
            self.state = 1147
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ASSIGNMENT:
                self.state = 1145
                self.match(ObjectiveCParser.ASSIGNMENT)
                self.state = 1146
                self.expression(0)


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

    class EnumeratorIdentifierContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_enumeratorIdentifier

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

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




    def enumeratorIdentifier(self):

        localctx = ObjectiveCParser.EnumeratorIdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_enumeratorIdentifier)
        try:
            self.state = 1151
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1149
                self.identifier()
                pass
            elif token in [ObjectiveCParser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1150
                self.match(ObjectiveCParser.DEFAULT)
                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 DirectDeclaratorContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

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


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

        def declaratorSuffix(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.DeclaratorSuffixContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.DeclaratorSuffixContext,i)


        def blockParameters(self):
            return self.getTypedRuleContext(ObjectiveCParser.BlockParametersContext,0)


        def nullabilitySpecifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.NullabilitySpecifierContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_directDeclarator

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

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




    def directDeclarator(self):

        localctx = ObjectiveCParser.DirectDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_directDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1176
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1158
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                    self.state = 1153
                    self.identifier()
                    pass
                elif token in [ObjectiveCParser.LP]:
                    self.state = 1154
                    self.match(ObjectiveCParser.LP)
                    self.state = 1155
                    self.declarator()
                    self.state = 1156
                    self.match(ObjectiveCParser.RP)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ObjectiveCParser.LBRACK:
                    self.state = 1160
                    self.declaratorSuffix()
                    self.state = 1165
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1166
                self.match(ObjectiveCParser.LP)
                self.state = 1167
                self.match(ObjectiveCParser.BITXOR)
                self.state = 1169
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                if la_ == 1:
                    self.state = 1168
                    self.nullabilitySpecifier()


                self.state = 1172
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                    self.state = 1171
                    self.identifier()


                self.state = 1174
                self.match(ObjectiveCParser.RP)
                self.state = 1175
                self.blockParameters()
                pass


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

    class DeclaratorSuffixContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_declaratorSuffix

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

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




    def declaratorSuffix(self):

        localctx = ObjectiveCParser.DeclaratorSuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_declaratorSuffix)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1178
            self.match(ObjectiveCParser.LBRACK)
            self.state = 1180
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (ObjectiveCParser.ADD - 152)) | (1 << (ObjectiveCParser.SUB - 152)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 152)) | (1 << (ObjectiveCParser.HEX_LITERAL - 152)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 152)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 152)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 152)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 152)))) != 0):
                self.state = 1179
                self.constantExpression()


            self.state = 1182
            self.match(ObjectiveCParser.RBRACK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParameterListContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_parameterList

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

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




    def parameterList(self):

        localctx = ObjectiveCParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_parameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1184
            self.parameterDeclarationList()
            self.state = 1187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.COMMA:
                self.state = 1185
                self.match(ObjectiveCParser.COMMA)
                self.state = 1186
                self.match(ObjectiveCParser.ELIPSIS)


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

    class PointerContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_pointer

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

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




    def pointer(self):

        localctx = ObjectiveCParser.PointerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_pointer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1189
            self.match(ObjectiveCParser.MUL)
            self.state = 1191
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
            if la_ == 1:
                self.state = 1190
                self.declarationSpecifiers()


            self.state = 1194
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
            if la_ == 1:
                self.state = 1193
                self.pointer()


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

    class MacroContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

        def primaryExpression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.PrimaryExpressionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.PrimaryExpressionContext,i)


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_macro

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

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




    def macro(self):

        localctx = ObjectiveCParser.MacroContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_macro)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1196
            self.identifier()
            self.state = 1208
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.LP:
                self.state = 1197
                self.match(ObjectiveCParser.LP)
                self.state = 1198
                self.primaryExpression()
                self.state = 1203
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ObjectiveCParser.COMMA:
                    self.state = 1199
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 1200
                    self.primaryExpression()
                    self.state = 1205
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1206
                self.match(ObjectiveCParser.RP)


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

    class ArrayInitializerContext(ParserRuleContext):

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

        def expressions(self):
            return self.getTypedRuleContext(ObjectiveCParser.ExpressionsContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_arrayInitializer

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

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




    def arrayInitializer(self):

        localctx = ObjectiveCParser.ArrayInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_arrayInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1210
            self.match(ObjectiveCParser.LBRACE)
            self.state = 1215
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 1211
                self.expressions()
                self.state = 1213
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.COMMA:
                    self.state = 1212
                    self.match(ObjectiveCParser.COMMA)




            self.state = 1217
            self.match(ObjectiveCParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructInitializerContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_structInitializer

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

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




    def structInitializer(self):

        localctx = ObjectiveCParser.StructInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_structInitializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1219
            self.match(ObjectiveCParser.LBRACE)
            self.state = 1233
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.DOT:
                self.state = 1220
                self.match(ObjectiveCParser.DOT)
                self.state = 1221
                self.expression(0)
                self.state = 1227
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,147,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1222
                        self.match(ObjectiveCParser.COMMA)
                        self.state = 1223
                        self.match(ObjectiveCParser.DOT)
                        self.state = 1224
                        self.expression(0) 
                    self.state = 1229
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,147,self._ctx)

                self.state = 1231
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.COMMA:
                    self.state = 1230
                    self.match(ObjectiveCParser.COMMA)




            self.state = 1235
            self.match(ObjectiveCParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InitializerListContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_initializerList

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

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




    def initializerList(self):

        localctx = ObjectiveCParser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1237
            self.initializer()
            self.state = 1242
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,150,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1238
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 1239
                    self.initializer() 
                self.state = 1244
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,150,self._ctx)

            self.state = 1246
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.COMMA:
                self.state = 1245
                self.match(ObjectiveCParser.COMMA)


        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):

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

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


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


        def blockType(self):
            return self.getTypedRuleContext(ObjectiveCParser.BlockTypeContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_typeName

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

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




    def typeName(self):

        localctx = ObjectiveCParser.TypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_typeName)
        self._la = 0 # Token type
        try:
            self.state = 1253
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,153,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1248
                self.specifierQualifierList()
                self.state = 1250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 126)) & ~0x3f) == 0 and ((1 << (_la - 126)) & ((1 << (ObjectiveCParser.LP - 126)) | (1 << (ObjectiveCParser.LBRACK - 126)) | (1 << (ObjectiveCParser.MUL - 126)))) != 0):
                    self.state = 1249
                    self.abstractDeclarator()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1252
                self.blockType()
                pass


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

    class AbstractDeclaratorContext(ParserRuleContext):

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

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


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


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

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

        def abstractDeclaratorSuffix(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.AbstractDeclaratorSuffixContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.AbstractDeclaratorSuffixContext,i)


        def constantExpression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ConstantExpressionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ConstantExpressionContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_abstractDeclarator

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

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




    def abstractDeclarator(self):

        localctx = ObjectiveCParser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_abstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1278
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.MUL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1255
                self.pointer()
                self.state = 1257
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 126)) & ~0x3f) == 0 and ((1 << (_la - 126)) & ((1 << (ObjectiveCParser.LP - 126)) | (1 << (ObjectiveCParser.LBRACK - 126)) | (1 << (ObjectiveCParser.MUL - 126)))) != 0):
                    self.state = 1256
                    self.abstractDeclarator()


                pass
            elif token in [ObjectiveCParser.LP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1259
                self.match(ObjectiveCParser.LP)
                self.state = 1261
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 126)) & ~0x3f) == 0 and ((1 << (_la - 126)) & ((1 << (ObjectiveCParser.LP - 126)) | (1 << (ObjectiveCParser.LBRACK - 126)) | (1 << (ObjectiveCParser.MUL - 126)))) != 0):
                    self.state = 1260
                    self.abstractDeclarator()


                self.state = 1263
                self.match(ObjectiveCParser.RP)
                self.state = 1265 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1264
                    self.abstractDeclaratorSuffix()
                    self.state = 1267 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==ObjectiveCParser.LP or _la==ObjectiveCParser.LBRACK):
                        break

                pass
            elif token in [ObjectiveCParser.LBRACK]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1274 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1269
                    self.match(ObjectiveCParser.LBRACK)
                    self.state = 1271
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (ObjectiveCParser.ADD - 152)) | (1 << (ObjectiveCParser.SUB - 152)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 152)) | (1 << (ObjectiveCParser.HEX_LITERAL - 152)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 152)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 152)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 152)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 152)))) != 0):
                        self.state = 1270
                        self.constantExpression()


                    self.state = 1273
                    self.match(ObjectiveCParser.RBRACK)
                    self.state = 1276 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==ObjectiveCParser.LBRACK):
                        break

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

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

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


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

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_abstractDeclaratorSuffix

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

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




    def abstractDeclaratorSuffix(self):

        localctx = ObjectiveCParser.AbstractDeclaratorSuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_abstractDeclaratorSuffix)
        self._la = 0 # Token type
        try:
            self.state = 1290
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.LBRACK]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1280
                self.match(ObjectiveCParser.LBRACK)
                self.state = 1282
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0) or ((((_la - 152)) & ~0x3f) == 0 and ((1 << (_la - 152)) & ((1 << (ObjectiveCParser.ADD - 152)) | (1 << (ObjectiveCParser.SUB - 152)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 152)) | (1 << (ObjectiveCParser.HEX_LITERAL - 152)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 152)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 152)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 152)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 152)))) != 0):
                    self.state = 1281
                    self.constantExpression()


                self.state = 1284
                self.match(ObjectiveCParser.RBRACK)
                pass
            elif token in [ObjectiveCParser.LP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1285
                self.match(ObjectiveCParser.LP)
                self.state = 1287
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.ATTRIBUTE - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 81)) | (1 << (ObjectiveCParser.TYPEOF - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 0):
                    self.state = 1286
                    self.parameterDeclarationList()


                self.state = 1289
                self.match(ObjectiveCParser.RP)
                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 ParameterDeclarationListContext(ParserRuleContext):

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_parameterDeclarationList

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

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




    def parameterDeclarationList(self):

        localctx = ObjectiveCParser.ParameterDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_parameterDeclarationList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1292
            self.parameterDeclaration()
            self.state = 1297
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,163,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1293
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 1294
                    self.parameterDeclaration() 
                self.state = 1299
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,163,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):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_parameterDeclaration

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

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




    def parameterDeclaration(self):

        localctx = ObjectiveCParser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_parameterDeclaration)
        try:
            self.state = 1304
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,164,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1300
                self.declarationSpecifiers()
                self.state = 1301
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1303
                self.match(ObjectiveCParser.VOID)
                pass


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

    class DeclaratorContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_declarator

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

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




    def declarator(self):

        localctx = ObjectiveCParser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1307
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.MUL:
                self.state = 1306
                self.pointer()


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

    class StatementContext(ParserRuleContext):

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

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


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


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


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


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


        def synchronizedStatement(self):
            return self.getTypedRuleContext(ObjectiveCParser.SynchronizedStatementContext,0)


        def autoreleaseStatement(self):
            return self.getTypedRuleContext(ObjectiveCParser.AutoreleaseStatementContext,0)


        def throwStatement(self):
            return self.getTypedRuleContext(ObjectiveCParser.ThrowStatementContext,0)


        def tryBlock(self):
            return self.getTypedRuleContext(ObjectiveCParser.TryBlockContext,0)


        def expressions(self):
            return self.getTypedRuleContext(ObjectiveCParser.ExpressionsContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_statement

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

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




    def statement(self):

        localctx = ObjectiveCParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_statement)
        try:
            self.state = 1352
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,176,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1311
                self.labeledStatement()
                self.state = 1313
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
                if la_ == 1:
                    self.state = 1312
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1315
                self.compoundStatement()
                self.state = 1317
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
                if la_ == 1:
                    self.state = 1316
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1319
                self.selectionStatement()
                self.state = 1321
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,168,self._ctx)
                if la_ == 1:
                    self.state = 1320
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1323
                self.iterationStatement()
                self.state = 1325
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
                if la_ == 1:
                    self.state = 1324
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1327
                self.jumpStatement()
                self.state = 1329
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
                if la_ == 1:
                    self.state = 1328
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1331
                self.synchronizedStatement()
                self.state = 1333
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
                if la_ == 1:
                    self.state = 1332
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1335
                self.autoreleaseStatement()
                self.state = 1337
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
                if la_ == 1:
                    self.state = 1336
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1339
                self.throwStatement()
                self.state = 1341
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
                if la_ == 1:
                    self.state = 1340
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1343
                self.tryBlock()
                self.state = 1345
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                if la_ == 1:
                    self.state = 1344
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1347
                self.expressions()
                self.state = 1349
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                if la_ == 1:
                    self.state = 1348
                    self.match(ObjectiveCParser.SEMI)


                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1351
                self.match(ObjectiveCParser.SEMI)
                pass


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

    class LabeledStatementContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_labeledStatement

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

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




    def labeledStatement(self):

        localctx = ObjectiveCParser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_labeledStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1354
            self.identifier()
            self.state = 1355
            self.match(ObjectiveCParser.COLON)
            self.state = 1356
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class RangeExpressionContext(ParserRuleContext):

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

        def constantExpression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ConstantExpressionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ConstantExpressionContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_rangeExpression

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

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




    def rangeExpression(self):

        localctx = ObjectiveCParser.RangeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_rangeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1358
            self.constantExpression()
            self.state = 1361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ObjectiveCParser.ELIPSIS:
                self.state = 1359
                self.match(ObjectiveCParser.ELIPSIS)
                self.state = 1360
                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 CompoundStatementContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_compoundStatement

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

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




    def compoundStatement(self):

        localctx = ObjectiveCParser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1363
            self.match(ObjectiveCParser.LBRACE)
            self.state = 1368
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.BREAK) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.CONTINUE) | (1 << ObjectiveCParser.DO) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.FOR) | (1 << ObjectiveCParser.GOTO) | (1 << ObjectiveCParser.IF) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.SWITCH) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.WHILE) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.AUTORELEASEPOOL) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.SYNCHRONIZED - 69)) | (1 << (ObjectiveCParser.THROW - 69)) | (1 << (ObjectiveCParser.TRY - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.ATTRIBUTE - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 69)) | (1 << (ObjectiveCParser.TYPEOF - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACE - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)) | (1 << (ObjectiveCParser.SEMI - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 1366
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
                if la_ == 1:
                    self.state = 1364
                    self.declaration()
                    pass

                elif la_ == 2:
                    self.state = 1365
                    self.statement()
                    pass


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

            self.state = 1371
            self.match(ObjectiveCParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SelectionStatementContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.SelectionStatementContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.ifBody = None # StatementContext
            self.elseBody = None # StatementContext

        def IF(self):
            return self.getToken(ObjectiveCParser.IF, 0)

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

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


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

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


        def ELSE(self):
            return self.getToken(ObjectiveCParser.ELSE, 0)

        def switchStatement(self):
            return self.getTypedRuleContext(ObjectiveCParser.SwitchStatementContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_selectionStatement

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

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




    def selectionStatement(self):

        localctx = ObjectiveCParser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_selectionStatement)
        try:
            self.state = 1383
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.IF]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1373
                self.match(ObjectiveCParser.IF)
                self.state = 1374
                self.match(ObjectiveCParser.LP)
                self.state = 1375
                self.expression(0)
                self.state = 1376
                self.match(ObjectiveCParser.RP)
                self.state = 1377
                localctx.ifBody = self.statement()
                self.state = 1380
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
                if la_ == 1:
                    self.state = 1378
                    self.match(ObjectiveCParser.ELSE)
                    self.state = 1379
                    localctx.elseBody = self.statement()


                pass
            elif token in [ObjectiveCParser.SWITCH]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1382
                self.switchStatement()
                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 SwitchStatementContext(ParserRuleContext):

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

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

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


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

        def switchBlock(self):
            return self.getTypedRuleContext(ObjectiveCParser.SwitchBlockContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_switchStatement

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

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




    def switchStatement(self):

        localctx = ObjectiveCParser.SwitchStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_switchStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1385
            self.match(ObjectiveCParser.SWITCH)
            self.state = 1386
            self.match(ObjectiveCParser.LP)
            self.state = 1387
            self.expression(0)
            self.state = 1388
            self.match(ObjectiveCParser.RP)
            self.state = 1389
            self.switchBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SwitchBlockContext(ParserRuleContext):

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

        def switchSection(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.SwitchSectionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.SwitchSectionContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_switchBlock

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

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




    def switchBlock(self):

        localctx = ObjectiveCParser.SwitchBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_switchBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1391
            self.match(ObjectiveCParser.LBRACE)
            self.state = 1395
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.CASE or _la==ObjectiveCParser.DEFAULT:
                self.state = 1392
                self.switchSection()
                self.state = 1397
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1398
            self.match(ObjectiveCParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SwitchSectionContext(ParserRuleContext):

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

        def switchLabel(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.SwitchLabelContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.SwitchLabelContext,i)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_switchSection

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

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




    def switchSection(self):

        localctx = ObjectiveCParser.SwitchSectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_switchSection)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1401 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1400
                self.switchLabel()
                self.state = 1403 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==ObjectiveCParser.CASE or _la==ObjectiveCParser.DEFAULT):
                    break

            self.state = 1406 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1405
                self.statement()
                self.state = 1408 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BREAK) | (1 << ObjectiveCParser.CONTINUE) | (1 << ObjectiveCParser.DO) | (1 << ObjectiveCParser.FOR) | (1 << ObjectiveCParser.GOTO) | (1 << ObjectiveCParser.IF) | (1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.SWITCH) | (1 << ObjectiveCParser.WHILE) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.AUTORELEASEPOOL) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.SYNCHRONIZED - 69)) | (1 << (ObjectiveCParser.THROW - 69)) | (1 << (ObjectiveCParser.TRY - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACE - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)) | (1 << (ObjectiveCParser.SEMI - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 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 SwitchLabelContext(ParserRuleContext):

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

        def rangeExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.RangeExpressionContext,0)


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

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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_switchLabel

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

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




    def switchLabel(self):

        localctx = ObjectiveCParser.SwitchLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_switchLabel)
        try:
            self.state = 1422
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.CASE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1410
                self.match(ObjectiveCParser.CASE)
                self.state = 1416
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [ObjectiveCParser.TRUE, ObjectiveCParser.FALSE, ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.NIL, ObjectiveCParser.NO, ObjectiveCParser.NULL, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.YES, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER, ObjectiveCParser.ADD, ObjectiveCParser.SUB, ObjectiveCParser.CHARACTER_LITERAL, ObjectiveCParser.HEX_LITERAL, ObjectiveCParser.OCTAL_LITERAL, ObjectiveCParser.BINARY_LITERAL, ObjectiveCParser.DECIMAL_LITERAL, ObjectiveCParser.FLOATING_POINT_LITERAL]:
                    self.state = 1411
                    self.rangeExpression()
                    pass
                elif token in [ObjectiveCParser.LP]:
                    self.state = 1412
                    self.match(ObjectiveCParser.LP)
                    self.state = 1413
                    self.rangeExpression()
                    self.state = 1414
                    self.match(ObjectiveCParser.RP)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1418
                self.match(ObjectiveCParser.COLON)
                pass
            elif token in [ObjectiveCParser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1420
                self.match(ObjectiveCParser.DEFAULT)
                self.state = 1421
                self.match(ObjectiveCParser.COLON)
                pass
            else:
                raise NoViableAltException(self)

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

    class IterationStatementContext(ParserRuleContext):

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

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


        def doStatement(self):
            return self.getTypedRuleContext(ObjectiveCParser.DoStatementContext,0)


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


        def forInStatement(self):
            return self.getTypedRuleContext(ObjectiveCParser.ForInStatementContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_iterationStatement

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

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




    def iterationStatement(self):

        localctx = ObjectiveCParser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_iterationStatement)
        try:
            self.state = 1428
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1424
                self.whileStatement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1425
                self.doStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1426
                self.forStatement()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1427
                self.forInStatement()
                pass


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

    class WhileStatementContext(ParserRuleContext):

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

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

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


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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_whileStatement

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

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




    def whileStatement(self):

        localctx = ObjectiveCParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1430
            self.match(ObjectiveCParser.WHILE)
            self.state = 1431
            self.match(ObjectiveCParser.LP)
            self.state = 1432
            self.expression(0)
            self.state = 1433
            self.match(ObjectiveCParser.RP)
            self.state = 1434
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DoStatementContext(ParserRuleContext):

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

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


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

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


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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_doStatement

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

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




    def doStatement(self):

        localctx = ObjectiveCParser.DoStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_doStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1436
            self.match(ObjectiveCParser.DO)
            self.state = 1437
            self.statement()
            self.state = 1438
            self.match(ObjectiveCParser.WHILE)
            self.state = 1439
            self.match(ObjectiveCParser.LP)
            self.state = 1440
            self.expression(0)
            self.state = 1441
            self.match(ObjectiveCParser.RP)
            self.state = 1442
            self.match(ObjectiveCParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForStatementContext(ParserRuleContext):

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

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

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

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


        def forLoopInitializer(self):
            return self.getTypedRuleContext(ObjectiveCParser.ForLoopInitializerContext,0)


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


        def expressions(self):
            return self.getTypedRuleContext(ObjectiveCParser.ExpressionsContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_forStatement

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

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




    def forStatement(self):

        localctx = ObjectiveCParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1444
            self.match(ObjectiveCParser.FOR)
            self.state = 1445
            self.match(ObjectiveCParser.LP)
            self.state = 1447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.ATTRIBUTE - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 69)) | (1 << (ObjectiveCParser.TYPEOF - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 1446
                self.forLoopInitializer()


            self.state = 1449
            self.match(ObjectiveCParser.SEMI)
            self.state = 1451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 1450
                self.expression(0)


            self.state = 1453
            self.match(ObjectiveCParser.SEMI)
            self.state = 1455
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 1454
                self.expressions()


            self.state = 1457
            self.match(ObjectiveCParser.RP)
            self.state = 1458
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForLoopInitializerContext(ParserRuleContext):

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

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


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


        def expressions(self):
            return self.getTypedRuleContext(ObjectiveCParser.ExpressionsContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_forLoopInitializer

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

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




    def forLoopInitializer(self):

        localctx = ObjectiveCParser.ForLoopInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_forLoopInitializer)
        try:
            self.state = 1464
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,191,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1460
                self.declarationSpecifiers()
                self.state = 1461
                self.initDeclaratorList()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1463
                self.expressions()
                pass


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

    class ForInStatementContext(ParserRuleContext):

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

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

        def typeVariableDeclarator(self):
            return self.getTypedRuleContext(ObjectiveCParser.TypeVariableDeclaratorContext,0)


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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_forInStatement

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

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




    def forInStatement(self):

        localctx = ObjectiveCParser.ForInStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_forInStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1466
            self.match(ObjectiveCParser.FOR)
            self.state = 1467
            self.match(ObjectiveCParser.LP)
            self.state = 1468
            self.typeVariableDeclarator()
            self.state = 1469
            self.match(ObjectiveCParser.IN)
            self.state = 1471
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                self.state = 1470
                self.expression(0)


            self.state = 1473
            self.match(ObjectiveCParser.RP)
            self.state = 1474
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class JumpStatementContext(ParserRuleContext):

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

        def GOTO(self):
            return self.getToken(ObjectiveCParser.GOTO, 0)

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


        def CONTINUE(self):
            return self.getToken(ObjectiveCParser.CONTINUE, 0)

        def BREAK(self):
            return self.getToken(ObjectiveCParser.BREAK, 0)

        def RETURN(self):
            return self.getToken(ObjectiveCParser.RETURN, 0)

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_jumpStatement

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

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




    def jumpStatement(self):

        localctx = ObjectiveCParser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_jumpStatement)
        try:
            self.state = 1484
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.GOTO]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1476
                self.match(ObjectiveCParser.GOTO)
                self.state = 1477
                self.identifier()
                pass
            elif token in [ObjectiveCParser.CONTINUE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1478
                self.match(ObjectiveCParser.CONTINUE)
                pass
            elif token in [ObjectiveCParser.BREAK]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1479
                self.match(ObjectiveCParser.BREAK)
                pass
            elif token in [ObjectiveCParser.RETURN]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1480
                self.match(ObjectiveCParser.RETURN)
                self.state = 1482
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
                if la_ == 1:
                    self.state = 1481
                    self.expression(0)


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

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

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_expressions

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

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




    def expressions(self):

        localctx = ObjectiveCParser.ExpressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_expressions)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1486
            self.expression(0)
            self.state = 1491
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,195,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1487
                    self.match(ObjectiveCParser.COMMA)
                    self.state = 1488
                    self.expression(0) 
                self.state = 1493
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,195,self._ctx)

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

    class ExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.ExpressionContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.assignmentExpression = None # ExpressionContext
            self.op = None # Token
            self.trueExpression = None # ExpressionContext
            self.falseExpression = None # ExpressionContext

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


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


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


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


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

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

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

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

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

        def LT(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.LT)
            else:
                return self.getToken(ObjectiveCParser.LT, i)

        def GT(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.GT)
            else:
                return self.getToken(ObjectiveCParser.GT, i)

        def LE(self):
            return self.getToken(ObjectiveCParser.LE, 0)

        def GE(self):
            return self.getToken(ObjectiveCParser.GE, 0)

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

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

        def BITAND(self):
            return self.getToken(ObjectiveCParser.BITAND, 0)

        def BITXOR(self):
            return self.getToken(ObjectiveCParser.BITXOR, 0)

        def BITOR(self):
            return self.getToken(ObjectiveCParser.BITOR, 0)

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

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

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

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

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_expression

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

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



    def expression(self, _p=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ObjectiveCParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 258
        self.enterRecursionRule(localctx, 258, self.RULE_expression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1500
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
            if la_ == 1:
                self.state = 1495
                self.castExpression()
                pass

            elif la_ == 2:
                self.state = 1496
                self.unaryExpression()
                self.state = 1497
                self.assignmentOperator()
                self.state = 1498
                localctx.assignmentExpression = self.expression(1)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1546
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,200,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 = 1544
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
                    if la_ == 1:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1502
                        if not self.precpred(self._ctx, 12):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1503
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 154)) & ~0x3f) == 0 and ((1 << (_la - 154)) & ((1 << (ObjectiveCParser.MUL - 154)) | (1 << (ObjectiveCParser.DIV - 154)) | (1 << (ObjectiveCParser.MOD - 154)))) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1504
                        self.expression(13)
                        pass

                    elif la_ == 2:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1505
                        if not self.precpred(self._ctx, 11):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1506
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1507
                        self.expression(12)
                        pass

                    elif la_ == 3:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1508
                        if not self.precpred(self._ctx, 10):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1513
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [ObjectiveCParser.LT]:
                            self.state = 1509
                            self.match(ObjectiveCParser.LT)
                            self.state = 1510
                            self.match(ObjectiveCParser.LT)
                            pass
                        elif token in [ObjectiveCParser.GT]:
                            self.state = 1511
                            self.match(ObjectiveCParser.GT)
                            self.state = 1512
                            self.match(ObjectiveCParser.GT)
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 1515
                        self.expression(11)
                        pass

                    elif la_ == 4:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1516
                        if not self.precpred(self._ctx, 9):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1517
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & ((1 << (ObjectiveCParser.GT - 138)) | (1 << (ObjectiveCParser.LT - 138)) | (1 << (ObjectiveCParser.LE - 138)) | (1 << (ObjectiveCParser.GE - 138)))) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1518
                        self.expression(10)
                        pass

                    elif la_ == 5:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1519
                        if not self.precpred(self._ctx, 8):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1520
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==ObjectiveCParser.EQUAL or _la==ObjectiveCParser.NOTEQUAL):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1521
                        self.expression(9)
                        pass

                    elif la_ == 6:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1522
                        if not self.precpred(self._ctx, 7):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1523
                        localctx.op = self.match(ObjectiveCParser.BITAND)
                        self.state = 1524
                        self.expression(8)
                        pass

                    elif la_ == 7:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1525
                        if not self.precpred(self._ctx, 6):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1526
                        localctx.op = self.match(ObjectiveCParser.BITXOR)
                        self.state = 1527
                        self.expression(7)
                        pass

                    elif la_ == 8:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1528
                        if not self.precpred(self._ctx, 5):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1529
                        localctx.op = self.match(ObjectiveCParser.BITOR)
                        self.state = 1530
                        self.expression(6)
                        pass

                    elif la_ == 9:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1531
                        if not self.precpred(self._ctx, 4):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1532
                        localctx.op = self.match(ObjectiveCParser.AND)
                        self.state = 1533
                        self.expression(5)
                        pass

                    elif la_ == 10:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1534
                        if not self.precpred(self._ctx, 3):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1535
                        localctx.op = self.match(ObjectiveCParser.OR)
                        self.state = 1536
                        self.expression(4)
                        pass

                    elif la_ == 11:
                        localctx = ObjectiveCParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1537
                        if not self.precpred(self._ctx, 2):
                            from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1538
                        self.match(ObjectiveCParser.QUESTION)
                        self.state = 1540
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                            self.state = 1539
                            localctx.trueExpression = self.expression(0)


                        self.state = 1542
                        self.match(ObjectiveCParser.COLON)
                        self.state = 1543
                        localctx.falseExpression = self.expression(3)
                        pass

             
                self.state = 1548
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,200,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 AssignmentOperatorContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_assignmentOperator

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

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




    def assignmentOperator(self):

        localctx = ObjectiveCParser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1549
            _la = self._input.LA(1)
            if not(((((_la - 137)) & ~0x3f) == 0 and ((1 << (_la - 137)) & ((1 << (ObjectiveCParser.ASSIGNMENT - 137)) | (1 << (ObjectiveCParser.ADD_ASSIGN - 137)) | (1 << (ObjectiveCParser.SUB_ASSIGN - 137)) | (1 << (ObjectiveCParser.MUL_ASSIGN - 137)) | (1 << (ObjectiveCParser.DIV_ASSIGN - 137)) | (1 << (ObjectiveCParser.AND_ASSIGN - 137)) | (1 << (ObjectiveCParser.OR_ASSIGN - 137)) | (1 << (ObjectiveCParser.XOR_ASSIGN - 137)) | (1 << (ObjectiveCParser.MOD_ASSIGN - 137)) | (1 << (ObjectiveCParser.LSHIFT_ASSIGN - 137)) | (1 << (ObjectiveCParser.RSHIFT_ASSIGN - 137)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CastExpressionContext(ParserRuleContext):

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

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


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

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


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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_castExpression

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

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




    def castExpression(self):

        localctx = ObjectiveCParser.CastExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_castExpression)
        try:
            self.state = 1560
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1551
                self.unaryExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1552
                self.match(ObjectiveCParser.LP)
                self.state = 1553
                self.typeName()
                self.state = 1554
                self.match(ObjectiveCParser.RP)
                self.state = 1558
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
                if la_ == 1:
                    self.state = 1556
                    self.castExpression()
                    pass

                elif la_ == 2:
                    self.state = 1557
                    self.initializer()
                    pass


                pass


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

    class InitializerContext(ParserRuleContext):

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

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


        def arrayInitializer(self):
            return self.getTypedRuleContext(ObjectiveCParser.ArrayInitializerContext,0)


        def structInitializer(self):
            return self.getTypedRuleContext(ObjectiveCParser.StructInitializerContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_initializer

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

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




    def initializer(self):

        localctx = ObjectiveCParser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_initializer)
        try:
            self.state = 1565
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,203,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1562
                self.expression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1563
                self.arrayInitializer()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1564
                self.structInitializer()
                pass


        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):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_constantExpression

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

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




    def constantExpression(self):

        localctx = ObjectiveCParser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_constantExpression)
        try:
            self.state = 1569
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ObjectiveCParser.BOOL, ObjectiveCParser.Class, ObjectiveCParser.BYCOPY, ObjectiveCParser.BYREF, ObjectiveCParser.ID, ObjectiveCParser.IMP, ObjectiveCParser.IN, ObjectiveCParser.INOUT, ObjectiveCParser.ONEWAY, ObjectiveCParser.OUT, ObjectiveCParser.PROTOCOL_, ObjectiveCParser.SEL, ObjectiveCParser.SELF, ObjectiveCParser.SUPER, ObjectiveCParser.ATOMIC, ObjectiveCParser.NONATOMIC, ObjectiveCParser.RETAIN, ObjectiveCParser.AUTORELEASING_QUALIFIER, ObjectiveCParser.BLOCK, ObjectiveCParser.BRIDGE_RETAINED, ObjectiveCParser.BRIDGE_TRANSFER, ObjectiveCParser.COVARIANT, ObjectiveCParser.CONTRAVARIANT, ObjectiveCParser.DEPRECATED, ObjectiveCParser.KINDOF, ObjectiveCParser.UNUSED, ObjectiveCParser.NULL_UNSPECIFIED, ObjectiveCParser.NULLABLE, ObjectiveCParser.NONNULL, ObjectiveCParser.NULL_RESETTABLE, ObjectiveCParser.NS_INLINE, ObjectiveCParser.NS_ENUM, ObjectiveCParser.NS_OPTIONS, ObjectiveCParser.ASSIGN, ObjectiveCParser.COPY, ObjectiveCParser.GETTER, ObjectiveCParser.SETTER, ObjectiveCParser.STRONG, ObjectiveCParser.READONLY, ObjectiveCParser.READWRITE, ObjectiveCParser.WEAK, ObjectiveCParser.UNSAFE_UNRETAINED, ObjectiveCParser.IB_OUTLET, ObjectiveCParser.IB_OUTLET_COLLECTION, ObjectiveCParser.IB_INSPECTABLE, ObjectiveCParser.IB_DESIGNABLE, ObjectiveCParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1567
                self.identifier()
                pass
            elif token in [ObjectiveCParser.TRUE, ObjectiveCParser.FALSE, ObjectiveCParser.NIL, ObjectiveCParser.NO, ObjectiveCParser.NULL, ObjectiveCParser.YES, ObjectiveCParser.ADD, ObjectiveCParser.SUB, ObjectiveCParser.CHARACTER_LITERAL, ObjectiveCParser.HEX_LITERAL, ObjectiveCParser.OCTAL_LITERAL, ObjectiveCParser.BINARY_LITERAL, ObjectiveCParser.DECIMAL_LITERAL, ObjectiveCParser.FLOATING_POINT_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1568
                self.constant()
                pass
            else:
                raise NoViableAltException(self)

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

    class UnaryExpressionContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.UnaryExpressionContext, self).__init__(parent, invokingState)
            self.parser = parser
            self.op = None # Token

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


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

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


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

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


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

        def INC(self):
            return self.getToken(ObjectiveCParser.INC, 0)

        def DEC(self):
            return self.getToken(ObjectiveCParser.DEC, 0)

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_unaryExpression

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

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




    def unaryExpression(self):

        localctx = ObjectiveCParser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_unaryExpression)
        self._la = 0 # Token type
        try:
            self.state = 1585
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1571
                self.postfixExpression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1572
                self.match(ObjectiveCParser.SIZEOF)
                self.state = 1578
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,205,self._ctx)
                if la_ == 1:
                    self.state = 1573
                    self.unaryExpression()
                    pass

                elif la_ == 2:
                    self.state = 1574
                    self.match(ObjectiveCParser.LP)
                    self.state = 1575
                    self.typeSpecifier()
                    self.state = 1576
                    self.match(ObjectiveCParser.RP)
                    pass


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1580
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==ObjectiveCParser.INC or _la==ObjectiveCParser.DEC):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1581
                self.unaryExpression()
                pass

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


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

    class UnaryOperatorContext(ParserRuleContext):

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

        def BANG(self):
            return self.getToken(ObjectiveCParser.BANG, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_unaryOperator

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

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




    def unaryOperator(self):

        localctx = ObjectiveCParser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1587
            _la = self._input.LA(1)
            if not(((((_la - 140)) & ~0x3f) == 0 and ((1 << (_la - 140)) & ((1 << (ObjectiveCParser.BANG - 140)) | (1 << (ObjectiveCParser.TILDE - 140)) | (1 << (ObjectiveCParser.ADD - 140)) | (1 << (ObjectiveCParser.SUB - 140)) | (1 << (ObjectiveCParser.MUL - 140)) | (1 << (ObjectiveCParser.BITAND - 140)))) != 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 PostfixExpressionContext(ParserRuleContext):

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

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


        def postfix(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.PostfixContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.PostfixContext,i)


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


        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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

        def STRUCTACCESS(self):
            return self.getToken(ObjectiveCParser.STRUCTACCESS, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_postfixExpression

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

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



    def postfixExpression(self, _p=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ObjectiveCParser.PostfixExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 272
        self.enterRecursionRule(localctx, 272, self.RULE_postfixExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1590
            self.primaryExpression()
            self.state = 1594
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,207,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1591
                    self.postfix() 
                self.state = 1596
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,207,self._ctx)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1608
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,209,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 = ObjectiveCParser.PostfixExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_postfixExpression)
                    self.state = 1597
                    if not self.precpred(self._ctx, 1):
                        from QBCodeSpecs.antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1598
                    _la = self._input.LA(1)
                    if not(_la==ObjectiveCParser.DOT or _la==ObjectiveCParser.STRUCTACCESS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1599
                    self.identifier()
                    self.state = 1603
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,208,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1600
                            self.postfix() 
                        self.state = 1605
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,208,self._ctx)
             
                self.state = 1610
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,209,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 PostfixContext(ParserRuleContext):

        def __init__(self, parser, parent=None, invokingState=-1):
            super(ObjectiveCParser.PostfixContext, self).__init__(parent, invokingState)
            self.parser = parser
            self._RP = None # Token
            self.macroArguments = list() # of Tokens
            self._tset3098 = None # Token
            self.op = None # Token

        def LBRACK(self):
            return self.getToken(ObjectiveCParser.LBRACK, 0)

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


        def RBRACK(self):
            return self.getToken(ObjectiveCParser.RBRACK, 0)

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

        def RP(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.RP)
            else:
                return self.getToken(ObjectiveCParser.RP, i)

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


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

        def INC(self):
            return self.getToken(ObjectiveCParser.INC, 0)

        def DEC(self):
            return self.getToken(ObjectiveCParser.DEC, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_postfix

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

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




    def postfix(self):

        localctx = ObjectiveCParser.PostfixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_postfix)
        self._la = 0 # Token type
        try:
            self.state = 1629
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1611
                self.match(ObjectiveCParser.LBRACK)
                self.state = 1612
                self.expression(0)
                self.state = 1613
                self.match(ObjectiveCParser.RBRACK)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1615
                self.match(ObjectiveCParser.LP)
                self.state = 1617
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.ENCODE))) != 0) or ((((_la - 69)) & ~0x3f) == 0 and ((1 << (_la - 69)) & ((1 << (ObjectiveCParser.PROTOCOL - 69)) | (1 << (ObjectiveCParser.SELECTOR - 69)) | (1 << (ObjectiveCParser.ATOMIC - 69)) | (1 << (ObjectiveCParser.NONATOMIC - 69)) | (1 << (ObjectiveCParser.RETAIN - 69)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 69)) | (1 << (ObjectiveCParser.BLOCK - 69)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 69)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 69)) | (1 << (ObjectiveCParser.COVARIANT - 69)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 69)) | (1 << (ObjectiveCParser.DEPRECATED - 69)) | (1 << (ObjectiveCParser.KINDOF - 69)) | (1 << (ObjectiveCParser.TYPEOF - 69)) | (1 << (ObjectiveCParser.UNUSED - 69)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 69)) | (1 << (ObjectiveCParser.NULLABLE - 69)) | (1 << (ObjectiveCParser.NONNULL - 69)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 69)) | (1 << (ObjectiveCParser.NS_INLINE - 69)) | (1 << (ObjectiveCParser.NS_ENUM - 69)) | (1 << (ObjectiveCParser.NS_OPTIONS - 69)) | (1 << (ObjectiveCParser.ASSIGN - 69)) | (1 << (ObjectiveCParser.COPY - 69)) | (1 << (ObjectiveCParser.GETTER - 69)) | (1 << (ObjectiveCParser.SETTER - 69)) | (1 << (ObjectiveCParser.STRONG - 69)) | (1 << (ObjectiveCParser.READONLY - 69)) | (1 << (ObjectiveCParser.READWRITE - 69)) | (1 << (ObjectiveCParser.WEAK - 69)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 69)) | (1 << (ObjectiveCParser.IB_OUTLET - 69)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 69)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 69)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 69)) | (1 << (ObjectiveCParser.IDENTIFIER - 69)) | (1 << (ObjectiveCParser.LP - 69)) | (1 << (ObjectiveCParser.LBRACK - 69)))) != 0) or ((((_la - 136)) & ~0x3f) == 0 and ((1 << (_la - 136)) & ((1 << (ObjectiveCParser.AT - 136)) | (1 << (ObjectiveCParser.BANG - 136)) | (1 << (ObjectiveCParser.TILDE - 136)) | (1 << (ObjectiveCParser.INC - 136)) | (1 << (ObjectiveCParser.DEC - 136)) | (1 << (ObjectiveCParser.ADD - 136)) | (1 << (ObjectiveCParser.SUB - 136)) | (1 << (ObjectiveCParser.MUL - 136)) | (1 << (ObjectiveCParser.BITAND - 136)) | (1 << (ObjectiveCParser.BITXOR - 136)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 136)) | (1 << (ObjectiveCParser.STRING_START - 136)) | (1 << (ObjectiveCParser.HEX_LITERAL - 136)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 136)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 136)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 136)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 136)))) != 0):
                    self.state = 1616
                    self.argumentExpressionList()


                self.state = 1619
                self.match(ObjectiveCParser.RP)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1620
                self.match(ObjectiveCParser.LP)
                self.state = 1623 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1623
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
                    if la_ == 1:
                        self.state = 1621
                        self.match(ObjectiveCParser.COMMA)
                        pass

                    elif la_ == 2:
                        self.state = 1622
                        localctx._tset3098 = self._input.LT(1)
                        _la = self._input.LA(1)
                        if _la <= 0 or _la==ObjectiveCParser.RP:
                            localctx._tset3098 = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        localctx.macroArguments.append(localctx._tset3098)
                        pass


                    self.state = 1625 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.AUTO) | (1 << ObjectiveCParser.BREAK) | (1 << ObjectiveCParser.CASE) | (1 << ObjectiveCParser.CHAR) | (1 << ObjectiveCParser.CONST) | (1 << ObjectiveCParser.CONTINUE) | (1 << ObjectiveCParser.DEFAULT) | (1 << ObjectiveCParser.DO) | (1 << ObjectiveCParser.DOUBLE) | (1 << ObjectiveCParser.ELSE) | (1 << ObjectiveCParser.ENUM) | (1 << ObjectiveCParser.EXTERN) | (1 << ObjectiveCParser.FLOAT) | (1 << ObjectiveCParser.FOR) | (1 << ObjectiveCParser.GOTO) | (1 << ObjectiveCParser.IF) | (1 << ObjectiveCParser.INLINE) | (1 << ObjectiveCParser.INT) | (1 << ObjectiveCParser.LONG) | (1 << ObjectiveCParser.REGISTER) | (1 << ObjectiveCParser.RESTRICT) | (1 << ObjectiveCParser.RETURN) | (1 << ObjectiveCParser.SHORT) | (1 << ObjectiveCParser.SIGNED) | (1 << ObjectiveCParser.SIZEOF) | (1 << ObjectiveCParser.STATIC) | (1 << ObjectiveCParser.STRUCT) | (1 << ObjectiveCParser.SWITCH) | (1 << ObjectiveCParser.TYPEDEF) | (1 << ObjectiveCParser.UNION) | (1 << ObjectiveCParser.UNSIGNED) | (1 << ObjectiveCParser.VOID) | (1 << ObjectiveCParser.VOLATILE) | (1 << ObjectiveCParser.WHILE) | (1 << ObjectiveCParser.BOOL_) | (1 << ObjectiveCParser.COMPLEX) | (1 << ObjectiveCParser.IMAGINERY) | (1 << ObjectiveCParser.TRUE) | (1 << ObjectiveCParser.FALSE) | (1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.NIL) | (1 << ObjectiveCParser.NO) | (1 << ObjectiveCParser.NULL) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER) | (1 << ObjectiveCParser.YES) | (1 << ObjectiveCParser.AUTORELEASEPOOL) | (1 << ObjectiveCParser.CATCH) | (1 << ObjectiveCParser.CLASS) | (1 << ObjectiveCParser.DYNAMIC) | (1 << ObjectiveCParser.ENCODE) | (1 << ObjectiveCParser.END))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (ObjectiveCParser.FINALLY - 64)) | (1 << (ObjectiveCParser.IMPLEMENTATION - 64)) | (1 << (ObjectiveCParser.INTERFACE - 64)) | (1 << (ObjectiveCParser.IMPORT - 64)) | (1 << (ObjectiveCParser.PACKAGE - 64)) | (1 << (ObjectiveCParser.PROTOCOL - 64)) | (1 << (ObjectiveCParser.OPTIONAL - 64)) | (1 << (ObjectiveCParser.PRIVATE - 64)) | (1 << (ObjectiveCParser.PROPERTY - 64)) | (1 << (ObjectiveCParser.PROTECTED - 64)) | (1 << (ObjectiveCParser.PUBLIC - 64)) | (1 << (ObjectiveCParser.REQUIRED - 64)) | (1 << (ObjectiveCParser.SELECTOR - 64)) | (1 << (ObjectiveCParser.SYNCHRONIZED - 64)) | (1 << (ObjectiveCParser.SYNTHESIZE - 64)) | (1 << (ObjectiveCParser.THROW - 64)) | (1 << (ObjectiveCParser.TRY - 64)) | (1 << (ObjectiveCParser.ATOMIC - 64)) | (1 << (ObjectiveCParser.NONATOMIC - 64)) | (1 << (ObjectiveCParser.RETAIN - 64)) | (1 << (ObjectiveCParser.ATTRIBUTE - 64)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 64)) | (1 << (ObjectiveCParser.BLOCK - 64)) | (1 << (ObjectiveCParser.BRIDGE - 64)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 64)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 64)) | (1 << (ObjectiveCParser.COVARIANT - 64)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 64)) | (1 << (ObjectiveCParser.DEPRECATED - 64)) | (1 << (ObjectiveCParser.KINDOF - 64)) | (1 << (ObjectiveCParser.STRONG_QUALIFIER - 64)) | (1 << (ObjectiveCParser.TYPEOF - 64)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED_QUALIFIER - 64)) | (1 << (ObjectiveCParser.UNUSED - 64)) | (1 << (ObjectiveCParser.WEAK_QUALIFIER - 64)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 64)) | (1 << (ObjectiveCParser.NULLABLE - 64)) | (1 << (ObjectiveCParser.NONNULL - 64)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 64)) | (1 << (ObjectiveCParser.NS_INLINE - 64)) | (1 << (ObjectiveCParser.NS_ENUM - 64)) | (1 << (ObjectiveCParser.NS_OPTIONS - 64)) | (1 << (ObjectiveCParser.ASSIGN - 64)) | (1 << (ObjectiveCParser.COPY - 64)) | (1 << (ObjectiveCParser.GETTER - 64)) | (1 << (ObjectiveCParser.SETTER - 64)) | (1 << (ObjectiveCParser.STRONG - 64)) | (1 << (ObjectiveCParser.READONLY - 64)) | (1 << (ObjectiveCParser.READWRITE - 64)) | (1 << (ObjectiveCParser.WEAK - 64)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 64)) | (1 << (ObjectiveCParser.IB_OUTLET - 64)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 64)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 64)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 64)) | (1 << (ObjectiveCParser.NS_ASSUME_NONNULL_BEGIN - 64)) | (1 << (ObjectiveCParser.NS_ASSUME_NONNULL_END - 64)) | (1 << (ObjectiveCParser.EXTERN_SUFFIX - 64)) | (1 << (ObjectiveCParser.IOS_SUFFIX - 64)) | (1 << (ObjectiveCParser.MAC_SUFFIX - 64)) | (1 << (ObjectiveCParser.TVOS_PROHIBITED - 64)) | (1 << (ObjectiveCParser.IDENTIFIER - 64)) | (1 << (ObjectiveCParser.LP - 64)))) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & ((1 << (ObjectiveCParser.LBRACE - 128)) | (1 << (ObjectiveCParser.RBRACE - 128)) | (1 << (ObjectiveCParser.LBRACK - 128)) | (1 << (ObjectiveCParser.RBRACK - 128)) | (1 << (ObjectiveCParser.SEMI - 128)) | (1 << (ObjectiveCParser.COMMA - 128)) | (1 << (ObjectiveCParser.DOT - 128)) | (1 << (ObjectiveCParser.STRUCTACCESS - 128)) | (1 << (ObjectiveCParser.AT - 128)) | (1 << (ObjectiveCParser.ASSIGNMENT - 128)) | (1 << (ObjectiveCParser.GT - 128)) | (1 << (ObjectiveCParser.LT - 128)) | (1 << (ObjectiveCParser.BANG - 128)) | (1 << (ObjectiveCParser.TILDE - 128)) | (1 << (ObjectiveCParser.QUESTION - 128)) | (1 << (ObjectiveCParser.COLON - 128)) | (1 << (ObjectiveCParser.EQUAL - 128)) | (1 << (ObjectiveCParser.LE - 128)) | (1 << (ObjectiveCParser.GE - 128)) | (1 << (ObjectiveCParser.NOTEQUAL - 128)) | (1 << (ObjectiveCParser.AND - 128)) | (1 << (ObjectiveCParser.OR - 128)) | (1 << (ObjectiveCParser.INC - 128)) | (1 << (ObjectiveCParser.DEC - 128)) | (1 << (ObjectiveCParser.ADD - 128)) | (1 << (ObjectiveCParser.SUB - 128)) | (1 << (ObjectiveCParser.MUL - 128)) | (1 << (ObjectiveCParser.DIV - 128)) | (1 << (ObjectiveCParser.BITAND - 128)) | (1 << (ObjectiveCParser.BITOR - 128)) | (1 << (ObjectiveCParser.BITXOR - 128)) | (1 << (ObjectiveCParser.MOD - 128)) | (1 << (ObjectiveCParser.ADD_ASSIGN - 128)) | (1 << (ObjectiveCParser.SUB_ASSIGN - 128)) | (1 << (ObjectiveCParser.MUL_ASSIGN - 128)) | (1 << (ObjectiveCParser.DIV_ASSIGN - 128)) | (1 << (ObjectiveCParser.AND_ASSIGN - 128)) | (1 << (ObjectiveCParser.OR_ASSIGN - 128)) | (1 << (ObjectiveCParser.XOR_ASSIGN - 128)) | (1 << (ObjectiveCParser.MOD_ASSIGN - 128)) | (1 << (ObjectiveCParser.LSHIFT_ASSIGN - 128)) | (1 << (ObjectiveCParser.RSHIFT_ASSIGN - 128)) | (1 << (ObjectiveCParser.ELIPSIS - 128)) | (1 << (ObjectiveCParser.CHARACTER_LITERAL - 128)) | (1 << (ObjectiveCParser.STRING_START - 128)) | (1 << (ObjectiveCParser.HEX_LITERAL - 128)) | (1 << (ObjectiveCParser.OCTAL_LITERAL - 128)) | (1 << (ObjectiveCParser.BINARY_LITERAL - 128)) | (1 << (ObjectiveCParser.DECIMAL_LITERAL - 128)) | (1 << (ObjectiveCParser.FLOATING_POINT_LITERAL - 128)) | (1 << (ObjectiveCParser.WS - 128)) | (1 << (ObjectiveCParser.MULTI_COMMENT - 128)) | (1 << (ObjectiveCParser.SINGLE_COMMENT - 128)) | (1 << (ObjectiveCParser.BACKSLASH - 128)) | (1 << (ObjectiveCParser.SHARP - 128)) | (1 << (ObjectiveCParser.STRING_NEWLINE - 128)) | (1 << (ObjectiveCParser.STRING_END - 128)) | (1 << (ObjectiveCParser.STRING_VALUE - 128)) | (1 << (ObjectiveCParser.DIRECTIVE_IMPORT - 128)) | (1 << (ObjectiveCParser.DIRECTIVE_INCLUDE - 128)) | (1 << (ObjectiveCParser.DIRECTIVE_PRAGMA - 128)) | (1 << (ObjectiveCParser.DIRECTIVE_DEFINE - 128)) | (1 << (ObjectiveCParser.DIRECTIVE_DEFINED - 128)) | (1 << (ObjectiveCParser.DIRECTIVE_IF - 128)))) != 0) or ((((_la - 192)) & ~0x3f) == 0 and ((1 << (_la - 192)) & ((1 << (ObjectiveCParser.DIRECTIVE_ELIF - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_ELSE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_UNDEF - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_IFDEF - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_IFNDEF - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_ENDIF - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_TRUE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_FALSE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_ERROR - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_WARNING - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_BANG - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_LP - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_RP - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_EQUAL - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_NOTEQUAL - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_AND - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_OR - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_LT - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_GT - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_LE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_GE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_STRING - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_ID - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_DECIMAL_LITERAL - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_FLOAT - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_NEWLINE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_MULTI_COMMENT - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_SINGLE_COMMENT - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_BACKSLASH_NEWLINE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_TEXT_NEWLINE - 192)) | (1 << (ObjectiveCParser.DIRECTIVE_TEXT - 192)))) != 0)):
                        break

                self.state = 1627
                self.match(ObjectiveCParser.RP)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1628
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==ObjectiveCParser.INC or _la==ObjectiveCParser.DEC):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass


        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):

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

        def argumentExpression(self, i=None):
            if i is None:
                return self.getTypedRuleContexts(ObjectiveCParser.ArgumentExpressionContext)
            else:
                return self.getTypedRuleContext(ObjectiveCParser.ArgumentExpressionContext,i)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_argumentExpressionList

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

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




    def argumentExpressionList(self):

        localctx = ObjectiveCParser.ArgumentExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_argumentExpressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1631
            self.argumentExpression()
            self.state = 1636
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ObjectiveCParser.COMMA:
                self.state = 1632
                self.match(ObjectiveCParser.COMMA)
                self.state = 1633
                self.argumentExpression()
                self.state = 1638
                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 ArgumentExpressionContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_argumentExpression

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

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




    def argumentExpression(self):

        localctx = ObjectiveCParser.ArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_argumentExpression)
        try:
            self.state = 1641
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,215,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1639
                self.expression(0)
                pass

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


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

    class PrimaryExpressionContext(ParserRuleContext):

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

        def identifier(self):
            return self.getTypedRuleContext(ObjectiveCParser.IdentifierContext,0)


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


        def stringLiteral(self):
            return self.getTypedRuleContext(ObjectiveCParser.StringLiteralContext,0)


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

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


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

        def messageExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.MessageExpressionContext,0)


        def selectorExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.SelectorExpressionContext,0)


        def protocolExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.ProtocolExpressionContext,0)


        def encodeExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.EncodeExpressionContext,0)


        def dictionaryExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.DictionaryExpressionContext,0)


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


        def boxExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.BoxExpressionContext,0)


        def blockExpression(self):
            return self.getTypedRuleContext(ObjectiveCParser.BlockExpressionContext,0)


        def getRuleIndex(self):
            return ObjectiveCParser.RULE_primaryExpression

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

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




    def primaryExpression(self):

        localctx = ObjectiveCParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_primaryExpression)
        try:
            self.state = 1658
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1643
                self.identifier()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1644
                self.constant()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1645
                self.stringLiteral()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1646
                self.match(ObjectiveCParser.LP)
                self.state = 1647
                self.expression(0)
                self.state = 1648
                self.match(ObjectiveCParser.RP)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1650
                self.messageExpression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1651
                self.selectorExpression()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1652
                self.protocolExpression()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1653
                self.encodeExpression()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1654
                self.dictionaryExpression()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1655
                self.arrayExpression()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1656
                self.boxExpression()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1657
                self.blockExpression()
                pass


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

    class ConstantContext(ParserRuleContext):

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

        def HEX_LITERAL(self):
            return self.getToken(ObjectiveCParser.HEX_LITERAL, 0)

        def OCTAL_LITERAL(self):
            return self.getToken(ObjectiveCParser.OCTAL_LITERAL, 0)

        def BINARY_LITERAL(self):
            return self.getToken(ObjectiveCParser.BINARY_LITERAL, 0)

        def DECIMAL_LITERAL(self):
            return self.getToken(ObjectiveCParser.DECIMAL_LITERAL, 0)

        def FLOATING_POINT_LITERAL(self):
            return self.getToken(ObjectiveCParser.FLOATING_POINT_LITERAL, 0)

        def CHARACTER_LITERAL(self):
            return self.getToken(ObjectiveCParser.CHARACTER_LITERAL, 0)

        def NIL(self):
            return self.getToken(ObjectiveCParser.NIL, 0)

        def NULL(self):
            return self.getToken(ObjectiveCParser.NULL, 0)

        def YES(self):
            return self.getToken(ObjectiveCParser.YES, 0)

        def NO(self):
            return self.getToken(ObjectiveCParser.NO, 0)

        def TRUE(self):
            return self.getToken(ObjectiveCParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(ObjectiveCParser.FALSE, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_constant

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

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




    def constant(self):

        localctx = ObjectiveCParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_constant)
        self._la = 0 # Token type
        try:
            self.state = 1678
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1660
                self.match(ObjectiveCParser.HEX_LITERAL)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1661
                self.match(ObjectiveCParser.OCTAL_LITERAL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1662
                self.match(ObjectiveCParser.BINARY_LITERAL)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1664
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                    self.state = 1663
                    _la = self._input.LA(1)
                    if not(_la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1666
                self.match(ObjectiveCParser.DECIMAL_LITERAL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1668
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB:
                    self.state = 1667
                    _la = self._input.LA(1)
                    if not(_la==ObjectiveCParser.ADD or _la==ObjectiveCParser.SUB):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1670
                self.match(ObjectiveCParser.FLOATING_POINT_LITERAL)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1671
                self.match(ObjectiveCParser.CHARACTER_LITERAL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1672
                self.match(ObjectiveCParser.NIL)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1673
                self.match(ObjectiveCParser.NULL)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1674
                self.match(ObjectiveCParser.YES)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1675
                self.match(ObjectiveCParser.NO)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1676
                self.match(ObjectiveCParser.TRUE)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1677
                self.match(ObjectiveCParser.FALSE)
                pass


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

    class StringLiteralContext(ParserRuleContext):

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

        def STRING_START(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.STRING_START)
            else:
                return self.getToken(ObjectiveCParser.STRING_START, i)

        def STRING_END(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.STRING_END)
            else:
                return self.getToken(ObjectiveCParser.STRING_END, i)

        def STRING_VALUE(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.STRING_VALUE)
            else:
                return self.getToken(ObjectiveCParser.STRING_VALUE, i)

        def STRING_NEWLINE(self, i=None):
            if i is None:
                return self.getTokens(ObjectiveCParser.STRING_NEWLINE)
            else:
                return self.getToken(ObjectiveCParser.STRING_NEWLINE, i)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_stringLiteral

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

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




    def stringLiteral(self):

        localctx = ObjectiveCParser.StringLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_stringLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1688 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1680
                    self.match(ObjectiveCParser.STRING_START)
                    self.state = 1684
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ObjectiveCParser.STRING_NEWLINE or _la==ObjectiveCParser.STRING_VALUE:
                        self.state = 1681
                        _la = self._input.LA(1)
                        if not(_la==ObjectiveCParser.STRING_NEWLINE or _la==ObjectiveCParser.STRING_VALUE):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1686
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1687
                    self.match(ObjectiveCParser.STRING_END)

                else:
                    raise NoViableAltException(self)
                self.state = 1690 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,221,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 IdentifierContext(ParserRuleContext):

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

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

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

        def Class(self):
            return self.getToken(ObjectiveCParser.Class, 0)

        def BYCOPY(self):
            return self.getToken(ObjectiveCParser.BYCOPY, 0)

        def BYREF(self):
            return self.getToken(ObjectiveCParser.BYREF, 0)

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

        def IMP(self):
            return self.getToken(ObjectiveCParser.IMP, 0)

        def IN(self):
            return self.getToken(ObjectiveCParser.IN, 0)

        def INOUT(self):
            return self.getToken(ObjectiveCParser.INOUT, 0)

        def ONEWAY(self):
            return self.getToken(ObjectiveCParser.ONEWAY, 0)

        def OUT(self):
            return self.getToken(ObjectiveCParser.OUT, 0)

        def PROTOCOL_(self):
            return self.getToken(ObjectiveCParser.PROTOCOL_, 0)

        def SEL(self):
            return self.getToken(ObjectiveCParser.SEL, 0)

        def SELF(self):
            return self.getToken(ObjectiveCParser.SELF, 0)

        def SUPER(self):
            return self.getToken(ObjectiveCParser.SUPER, 0)

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

        def NONATOMIC(self):
            return self.getToken(ObjectiveCParser.NONATOMIC, 0)

        def RETAIN(self):
            return self.getToken(ObjectiveCParser.RETAIN, 0)

        def AUTORELEASING_QUALIFIER(self):
            return self.getToken(ObjectiveCParser.AUTORELEASING_QUALIFIER, 0)

        def BLOCK(self):
            return self.getToken(ObjectiveCParser.BLOCK, 0)

        def BRIDGE_RETAINED(self):
            return self.getToken(ObjectiveCParser.BRIDGE_RETAINED, 0)

        def BRIDGE_TRANSFER(self):
            return self.getToken(ObjectiveCParser.BRIDGE_TRANSFER, 0)

        def COVARIANT(self):
            return self.getToken(ObjectiveCParser.COVARIANT, 0)

        def CONTRAVARIANT(self):
            return self.getToken(ObjectiveCParser.CONTRAVARIANT, 0)

        def DEPRECATED(self):
            return self.getToken(ObjectiveCParser.DEPRECATED, 0)

        def KINDOF(self):
            return self.getToken(ObjectiveCParser.KINDOF, 0)

        def UNUSED(self):
            return self.getToken(ObjectiveCParser.UNUSED, 0)

        def NS_INLINE(self):
            return self.getToken(ObjectiveCParser.NS_INLINE, 0)

        def NS_ENUM(self):
            return self.getToken(ObjectiveCParser.NS_ENUM, 0)

        def NS_OPTIONS(self):
            return self.getToken(ObjectiveCParser.NS_OPTIONS, 0)

        def NULL_UNSPECIFIED(self):
            return self.getToken(ObjectiveCParser.NULL_UNSPECIFIED, 0)

        def NULLABLE(self):
            return self.getToken(ObjectiveCParser.NULLABLE, 0)

        def NONNULL(self):
            return self.getToken(ObjectiveCParser.NONNULL, 0)

        def NULL_RESETTABLE(self):
            return self.getToken(ObjectiveCParser.NULL_RESETTABLE, 0)

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

        def COPY(self):
            return self.getToken(ObjectiveCParser.COPY, 0)

        def GETTER(self):
            return self.getToken(ObjectiveCParser.GETTER, 0)

        def SETTER(self):
            return self.getToken(ObjectiveCParser.SETTER, 0)

        def STRONG(self):
            return self.getToken(ObjectiveCParser.STRONG, 0)

        def READONLY(self):
            return self.getToken(ObjectiveCParser.READONLY, 0)

        def READWRITE(self):
            return self.getToken(ObjectiveCParser.READWRITE, 0)

        def WEAK(self):
            return self.getToken(ObjectiveCParser.WEAK, 0)

        def UNSAFE_UNRETAINED(self):
            return self.getToken(ObjectiveCParser.UNSAFE_UNRETAINED, 0)

        def IB_OUTLET(self):
            return self.getToken(ObjectiveCParser.IB_OUTLET, 0)

        def IB_OUTLET_COLLECTION(self):
            return self.getToken(ObjectiveCParser.IB_OUTLET_COLLECTION, 0)

        def IB_INSPECTABLE(self):
            return self.getToken(ObjectiveCParser.IB_INSPECTABLE, 0)

        def IB_DESIGNABLE(self):
            return self.getToken(ObjectiveCParser.IB_DESIGNABLE, 0)

        def getRuleIndex(self):
            return ObjectiveCParser.RULE_identifier

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

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




    def identifier(self):

        localctx = ObjectiveCParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1692
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ObjectiveCParser.BOOL) | (1 << ObjectiveCParser.Class) | (1 << ObjectiveCParser.BYCOPY) | (1 << ObjectiveCParser.BYREF) | (1 << ObjectiveCParser.ID) | (1 << ObjectiveCParser.IMP) | (1 << ObjectiveCParser.IN) | (1 << ObjectiveCParser.INOUT) | (1 << ObjectiveCParser.ONEWAY) | (1 << ObjectiveCParser.OUT) | (1 << ObjectiveCParser.PROTOCOL_) | (1 << ObjectiveCParser.SEL) | (1 << ObjectiveCParser.SELF) | (1 << ObjectiveCParser.SUPER))) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ObjectiveCParser.ATOMIC - 81)) | (1 << (ObjectiveCParser.NONATOMIC - 81)) | (1 << (ObjectiveCParser.RETAIN - 81)) | (1 << (ObjectiveCParser.AUTORELEASING_QUALIFIER - 81)) | (1 << (ObjectiveCParser.BLOCK - 81)) | (1 << (ObjectiveCParser.BRIDGE_RETAINED - 81)) | (1 << (ObjectiveCParser.BRIDGE_TRANSFER - 81)) | (1 << (ObjectiveCParser.COVARIANT - 81)) | (1 << (ObjectiveCParser.CONTRAVARIANT - 81)) | (1 << (ObjectiveCParser.DEPRECATED - 81)) | (1 << (ObjectiveCParser.KINDOF - 81)) | (1 << (ObjectiveCParser.UNUSED - 81)) | (1 << (ObjectiveCParser.NULL_UNSPECIFIED - 81)) | (1 << (ObjectiveCParser.NULLABLE - 81)) | (1 << (ObjectiveCParser.NONNULL - 81)) | (1 << (ObjectiveCParser.NULL_RESETTABLE - 81)) | (1 << (ObjectiveCParser.NS_INLINE - 81)) | (1 << (ObjectiveCParser.NS_ENUM - 81)) | (1 << (ObjectiveCParser.NS_OPTIONS - 81)) | (1 << (ObjectiveCParser.ASSIGN - 81)) | (1 << (ObjectiveCParser.COPY - 81)) | (1 << (ObjectiveCParser.GETTER - 81)) | (1 << (ObjectiveCParser.SETTER - 81)) | (1 << (ObjectiveCParser.STRONG - 81)) | (1 << (ObjectiveCParser.READONLY - 81)) | (1 << (ObjectiveCParser.READWRITE - 81)) | (1 << (ObjectiveCParser.WEAK - 81)) | (1 << (ObjectiveCParser.UNSAFE_UNRETAINED - 81)) | (1 << (ObjectiveCParser.IB_OUTLET - 81)) | (1 << (ObjectiveCParser.IB_OUTLET_COLLECTION - 81)) | (1 << (ObjectiveCParser.IB_INSPECTABLE - 81)) | (1 << (ObjectiveCParser.IB_DESIGNABLE - 81)) | (1 << (ObjectiveCParser.IDENTIFIER - 81)))) != 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



    def sempred(self, localctx, ruleIndex, predIndex):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[129] = self.expression_sempred
        self._predicates[136] = self.postfixExpression_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 expression_sempred(self, localctx, predIndex):
            if predIndex == 0:
                return self.precpred(self._ctx, 12)
         

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

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

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

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

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

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

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

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

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

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

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




