# Generated from ./Para.g4 by ANTLR 4.9.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3o")
        buf.write("\u0b57\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\3\2\3\2\3\2\6\2\u00c2\n\2\r\2\16\2\u00c3\3\2\3\2")
        buf.write("\3\2\3\2\3\2\5\2\u00cb\n\2\3\3\3\3\7\3\u00cf\n\3\f\3\16")
        buf.write("\3\u00d2\13\3\3\3\5\3\u00d5\n\3\3\3\7\3\u00d8\n\3\f\3")
        buf.write("\16\3\u00db\13\3\3\3\3\3\7\3\u00df\n\3\f\3\16\3\u00e2")
        buf.write("\13\3\3\3\3\3\3\4\3\4\5\4\u00e8\n\4\3\5\3\5\7\5\u00ec")
        buf.write("\n\5\f\5\16\5\u00ef\13\5\3\5\3\5\3\6\3\6\7\6\u00f5\n\6")
        buf.write("\f\6\16\6\u00f8\13\6\3\6\3\6\3\7\5\7\u00fd\n\7\3\7\7\7")
        buf.write("\u0100\n\7\f\7\16\7\u0103\13\7\3\7\3\7\3\7\7\7\u0108\n")
        buf.write("\7\f\7\16\7\u010b\13\7\3\7\3\7\7\7\u010f\n\7\f\7\16\7")
        buf.write("\u0112\13\7\3\7\3\7\7\7\u0116\n\7\f\7\16\7\u0119\13\7")
        buf.write("\3\7\3\7\7\7\u011d\n\7\f\7\16\7\u0120\13\7\3\7\3\7\7\7")
        buf.write("\u0124\n\7\f\7\16\7\u0127\13\7\3\7\5\7\u012a\n\7\3\7\7")
        buf.write("\7\u012d\n\7\f\7\16\7\u0130\13\7\3\7\3\7\5\7\u0134\n\7")
        buf.write("\3\7\7\7\u0137\n\7\f\7\16\7\u013a\13\7\3\7\3\7\7\7\u013e")
        buf.write("\n\7\f\7\16\7\u0141\13\7\3\7\3\7\7\7\u0145\n\7\f\7\16")
        buf.write("\7\u0148\13\7\3\7\3\7\3\7\3\7\7\7\u014e\n\7\f\7\16\7\u0151")
        buf.write("\13\7\3\7\5\7\u0154\n\7\3\7\7\7\u0157\n\7\f\7\16\7\u015a")
        buf.write("\13\7\3\7\3\7\3\7\7\7\u015f\n\7\f\7\16\7\u0162\13\7\3")
        buf.write("\7\3\7\7\7\u0166\n\7\f\7\16\7\u0169\13\7\3\b\3\b\7\b\u016d")
        buf.write("\n\b\f\b\16\b\u0170\13\b\3\b\3\b\7\b\u0174\n\b\f\b\16")
        buf.write("\b\u0177\13\b\3\b\3\b\7\b\u017b\n\b\f\b\16\b\u017e\13")
        buf.write("\b\7\b\u0180\n\b\f\b\16\b\u0183\13\b\3\t\7\t\u0186\n\t")
        buf.write("\f\t\16\t\u0189\13\t\3\t\7\t\u018c\n\t\f\t\16\t\u018f")
        buf.write("\13\t\3\t\3\t\3\t\7\t\u0194\n\t\f\t\16\t\u0197\13\t\3")
        buf.write("\t\3\t\3\t\3\t\7\t\u019d\n\t\f\t\16\t\u01a0\13\t\3\t\3")
        buf.write("\t\7\t\u01a4\n\t\f\t\16\t\u01a7\13\t\3\t\3\t\7\t\u01ab")
        buf.write("\n\t\f\t\16\t\u01ae\13\t\3\t\3\t\5\t\u01b2\n\t\3\n\3\n")
        buf.write("\3\13\3\13\3\13\7\13\u01b9\n\13\f\13\16\13\u01bc\13\13")
        buf.write("\3\13\3\13\7\13\u01c0\n\13\f\13\16\13\u01c3\13\13\3\13")
        buf.write("\3\13\7\13\u01c7\n\13\f\13\16\13\u01ca\13\13\3\13\3\13")
        buf.write("\3\13\3\13\5\13\u01d0\n\13\3\13\3\13\7\13\u01d4\n\13\f")
        buf.write("\13\16\13\u01d7\13\13\3\13\3\13\7\13\u01db\n\13\f\13\16")
        buf.write("\13\u01de\13\13\3\13\7\13\u01e1\n\13\f\13\16\13\u01e4")
        buf.write("\13\13\3\f\3\f\7\f\u01e8\n\f\f\f\16\f\u01eb\13\f\3\f\3")
        buf.write("\f\7\f\u01ef\n\f\f\f\16\f\u01f2\13\f\3\f\3\f\7\f\u01f6")
        buf.write("\n\f\f\f\16\f\u01f9\13\f\7\f\u01fb\n\f\f\f\16\f\u01fe")
        buf.write("\13\f\3\r\3\r\7\r\u0202\n\r\f\r\16\r\u0205\13\r\3\r\3")
        buf.write("\r\7\r\u0209\n\r\f\r\16\r\u020c\13\r\3\r\3\r\7\r\u0210")
        buf.write("\n\r\f\r\16\r\u0213\13\r\7\r\u0215\n\r\f\r\16\r\u0218")
        buf.write("\13\r\3\16\3\16\7\16\u021c\n\16\f\16\16\16\u021f\13\16")
        buf.write("\3\16\3\16\7\16\u0223\n\16\f\16\16\16\u0226\13\16\3\16")
        buf.write("\3\16\7\16\u022a\n\16\f\16\16\16\u022d\13\16\7\16\u022f")
        buf.write("\n\16\f\16\16\16\u0232\13\16\3\17\3\17\7\17\u0236\n\17")
        buf.write("\f\17\16\17\u0239\13\17\3\17\3\17\7\17\u023d\n\17\f\17")
        buf.write("\16\17\u0240\13\17\3\17\3\17\7\17\u0244\n\17\f\17\16\17")
        buf.write("\u0247\13\17\7\17\u0249\n\17\f\17\16\17\u024c\13\17\3")
        buf.write("\20\3\20\7\20\u0250\n\20\f\20\16\20\u0253\13\20\3\20\3")
        buf.write("\20\7\20\u0257\n\20\f\20\16\20\u025a\13\20\3\20\3\20\7")
        buf.write("\20\u025e\n\20\f\20\16\20\u0261\13\20\7\20\u0263\n\20")
        buf.write("\f\20\16\20\u0266\13\20\3\21\3\21\7\21\u026a\n\21\f\21")
        buf.write("\16\21\u026d\13\21\3\21\3\21\7\21\u0271\n\21\f\21\16\21")
        buf.write("\u0274\13\21\3\21\3\21\7\21\u0278\n\21\f\21\16\21\u027b")
        buf.write("\13\21\7\21\u027d\n\21\f\21\16\21\u0280\13\21\3\22\3\22")
        buf.write("\7\22\u0284\n\22\f\22\16\22\u0287\13\22\3\22\3\22\7\22")
        buf.write("\u028b\n\22\f\22\16\22\u028e\13\22\3\22\3\22\7\22\u0292")
        buf.write("\n\22\f\22\16\22\u0295\13\22\7\22\u0297\n\22\f\22\16\22")
        buf.write("\u029a\13\22\3\23\3\23\7\23\u029e\n\23\f\23\16\23\u02a1")
        buf.write("\13\23\3\23\3\23\7\23\u02a5\n\23\f\23\16\23\u02a8\13\23")
        buf.write("\3\23\3\23\7\23\u02ac\n\23\f\23\16\23\u02af\13\23\7\23")
        buf.write("\u02b1\n\23\f\23\16\23\u02b4\13\23\3\24\3\24\7\24\u02b8")
        buf.write("\n\24\f\24\16\24\u02bb\13\24\3\24\3\24\7\24\u02bf\n\24")
        buf.write("\f\24\16\24\u02c2\13\24\3\24\3\24\7\24\u02c6\n\24\f\24")
        buf.write("\16\24\u02c9\13\24\7\24\u02cb\n\24\f\24\16\24\u02ce\13")
        buf.write("\24\3\25\3\25\7\25\u02d2\n\25\f\25\16\25\u02d5\13\25\3")
        buf.write("\25\3\25\7\25\u02d9\n\25\f\25\16\25\u02dc\13\25\3\25\3")
        buf.write("\25\7\25\u02e0\n\25\f\25\16\25\u02e3\13\25\7\25\u02e5")
        buf.write("\n\25\f\25\16\25\u02e8\13\25\3\26\3\26\7\26\u02ec\n\26")
        buf.write("\f\26\16\26\u02ef\13\26\3\26\3\26\7\26\u02f3\n\26\f\26")
        buf.write("\16\26\u02f6\13\26\3\26\3\26\7\26\u02fa\n\26\f\26\16\26")
        buf.write("\u02fd\13\26\3\26\3\26\7\26\u0301\n\26\f\26\16\26\u0304")
        buf.write("\13\26\3\26\3\26\7\26\u0308\n\26\f\26\16\26\u030b\13\26")
        buf.write("\5\26\u030d\n\26\3\27\3\27\3\27\7\27\u0312\n\27\f\27\16")
        buf.write("\27\u0315\13\27\3\27\3\27\7\27\u0319\n\27\f\27\16\27\u031c")
        buf.write("\13\27\3\27\3\27\3\27\5\27\u0321\n\27\3\30\3\30\3\31\3")
        buf.write("\31\7\31\u0327\n\31\f\31\16\31\u032a\13\31\3\31\3\31\7")
        buf.write("\31\u032e\n\31\f\31\16\31\u0331\13\31\3\31\3\31\7\31\u0335")
        buf.write("\n\31\f\31\16\31\u0338\13\31\7\31\u033a\n\31\f\31\16\31")
        buf.write("\u033d\13\31\3\32\3\32\3\33\3\33\7\33\u0343\n\33\f\33")
        buf.write("\16\33\u0346\13\33\3\33\5\33\u0349\n\33\3\33\3\33\3\33")
        buf.write("\5\33\u034e\n\33\3\34\3\34\7\34\u0352\n\34\f\34\16\34")
        buf.write("\u0355\13\34\6\34\u0357\n\34\r\34\16\34\u0358\3\35\3\35")
        buf.write("\3\35\3\35\3\35\5\35\u0360\n\35\3\36\3\36\7\36\u0364\n")
        buf.write("\36\f\36\16\36\u0367\13\36\3\36\3\36\7\36\u036b\n\36\f")
        buf.write("\36\16\36\u036e\13\36\3\36\3\36\7\36\u0372\n\36\f\36\16")
        buf.write("\36\u0375\13\36\7\36\u0377\n\36\f\36\16\36\u037a\13\36")
        buf.write("\3\37\3\37\7\37\u037e\n\37\f\37\16\37\u0381\13\37\3\37")
        buf.write("\3\37\7\37\u0385\n\37\f\37\16\37\u0388\13\37\3\37\3\37")
        buf.write("\7\37\u038c\n\37\f\37\16\37\u038f\13\37\5\37\u0391\n\37")
        buf.write("\3 \3 \3!\3!\7!\u0397\n!\f!\16!\u039a\13!\3!\5!\u039d")
        buf.write("\n!\3!\7!\u03a0\n!\f!\16!\u03a3\13!\3!\5!\u03a6\n!\3!")
        buf.write("\7!\u03a9\n!\f!\16!\u03ac\13!\3!\3!\3!\7!\u03b1\n!\f!")
        buf.write("\16!\u03b4\13!\3!\3!\7!\u03b8\n!\f!\16!\u03bb\13!\3!\5")
        buf.write("!\u03be\n!\3!\7!\u03c1\n!\f!\16!\u03c4\13!\3!\3!\7!\u03c8")
        buf.write("\n!\f!\16!\u03cb\13!\3!\3!\3!\3!\7!\u03d1\n!\f!\16!\u03d4")
        buf.write("\13!\3!\3!\7!\u03d8\n!\f!\16!\u03db\13!\3!\3!\3!\7!\u03e0")
        buf.write("\n!\f!\16!\u03e3\13!\3!\3!\3!\3!\7!\u03e9\n!\f!\16!\u03ec")
        buf.write("\13!\3!\5!\u03ef\n!\3!\7!\u03f2\n!\f!\16!\u03f5\13!\3")
        buf.write("!\3!\7!\u03f9\n!\f!\16!\u03fc\13!\3!\5!\u03ff\n!\3\"\3")
        buf.write("\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u040d\n")
        buf.write("\"\f\"\16\"\u0410\13\"\3\"\3\"\7\"\u0414\n\"\f\"\16\"")
        buf.write("\u0417\13\"\3\"\3\"\7\"\u041b\n\"\f\"\16\"\u041e\13\"")
        buf.write("\3\"\3\"\3\"\3\"\3\"\5\"\u0425\n\"\3\"\7\"\u0428\n\"\f")
        buf.write("\"\16\"\u042b\13\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u0433\n")
        buf.write("\"\f\"\16\"\u0436\13\"\3\"\3\"\7\"\u043a\n\"\f\"\16\"")
        buf.write("\u043d\13\"\3\"\3\"\7\"\u0441\n\"\f\"\16\"\u0444\13\"")
        buf.write("\3\"\3\"\5\"\u0448\n\"\3\"\3\"\7\"\u044c\n\"\f\"\16\"")
        buf.write("\u044f\13\"\3\"\7\"\u0452\n\"\f\"\16\"\u0455\13\"\3#\3")
        buf.write("#\7#\u0459\n#\f#\16#\u045c\13#\3#\3#\7#\u0460\n#\f#\16")
        buf.write("#\u0463\13#\5#\u0465\n#\3#\3#\7#\u0469\n#\f#\16#\u046c")
        buf.write("\13#\3#\7#\u046f\n#\f#\16#\u0472\13#\3#\7#\u0475\n#\f")
        buf.write("#\16#\u0478\13#\3#\3#\3#\3#\7#\u047e\n#\f#\16#\u0481\13")
        buf.write("#\3#\3#\5#\u0485\n#\3$\3$\3%\7%\u048a\n%\f%\16%\u048d")
        buf.write("\13%\3%\3%\7%\u0491\n%\f%\16%\u0494\13%\6%\u0496\n%\r")
        buf.write("%\16%\u0497\3&\3&\7&\u049c\n&\f&\16&\u049f\13&\3&\5&\u04a2")
        buf.write("\n&\3&\3&\3&\5&\u04a7\n&\3\'\3\'\5\'\u04ab\n\'\3\'\7\'")
        buf.write("\u04ae\n\'\f\'\16\'\u04b1\13\'\3\'\5\'\u04b4\n\'\3(\3")
        buf.write("(\7(\u04b8\n(\f(\16(\u04bb\13(\3(\3(\7(\u04bf\n(\f(\16")
        buf.write("(\u04c2\13(\3(\7(\u04c5\n(\f(\16(\u04c8\13(\3)\3)\5)\u04cc")
        buf.write("\n)\3)\7)\u04cf\n)\f)\16)\u04d2\13)\3)\3)\7)\u04d6\n)")
        buf.write("\f)\16)\u04d9\13)\3)\5)\u04dc\n)\3*\3*\7*\u04e0\n*\f*")
        buf.write("\16*\u04e3\13*\3*\5*\u04e6\n*\3*\7*\u04e9\n*\f*\16*\u04ec")
        buf.write("\13*\3*\3*\7*\u04f0\n*\f*\16*\u04f3\13*\3*\3*\7*\u04f7")
        buf.write("\n*\f*\16*\u04fa\13*\3*\5*\u04fd\n*\3*\7*\u0500\n*\f*")
        buf.write("\16*\u0503\13*\3*\3*\3*\3*\7*\u0509\n*\f*\16*\u050c\13")
        buf.write("*\3*\5*\u050f\n*\3+\3+\7+\u0513\n+\f+\16+\u0516\13+\3")
        buf.write("+\3+\7+\u051a\n+\f+\16+\u051d\13+\3+\3+\7+\u0521\n+\f")
        buf.write("+\16+\u0524\13+\7+\u0526\n+\f+\16+\u0529\13+\3,\3,\7,")
        buf.write("\u052d\n,\f,\16,\u0530\13,\3,\3,\7,\u0534\n,\f,\16,\u0537")
        buf.write("\13,\3,\3,\7,\u053b\n,\f,\16,\u053e\13,\5,\u0540\n,\3")
        buf.write("-\3-\3.\3.\7.\u0546\n.\f.\16.\u0549\13.\3.\3.\7.\u054d")
        buf.write("\n.\f.\16.\u0550\13.\3.\3.\7.\u0554\n.\f.\16.\u0557\13")
        buf.write(".\3.\3.\7.\u055b\n.\f.\16.\u055e\13.\3/\3/\3\60\3\60\3")
        buf.write("\61\3\61\7\61\u0566\n\61\f\61\16\61\u0569\13\61\3\61\3")
        buf.write("\61\7\61\u056d\n\61\f\61\16\61\u0570\13\61\3\61\3\61\5")
        buf.write("\61\u0574\n\61\3\61\7\61\u0577\n\61\f\61\16\61\u057a\13")
        buf.write("\61\3\61\3\61\3\62\5\62\u057f\n\62\3\62\7\62\u0582\n\62")
        buf.write("\f\62\16\62\u0585\13\62\3\62\3\62\3\63\3\63\3\63\3\63")
        buf.write("\7\63\u058d\n\63\f\63\16\63\u0590\13\63\3\63\3\63\7\63")
        buf.write("\u0594\n\63\f\63\16\63\u0597\13\63\3\63\3\63\3\63\3\63")
        buf.write("\7\63\u059d\n\63\f\63\16\63\u05a0\13\63\3\63\3\63\7\63")
        buf.write("\u05a4\n\63\f\63\16\63\u05a7\13\63\3\63\3\63\3\63\7\63")
        buf.write("\u05ac\n\63\f\63\16\63\u05af\13\63\3\63\5\63\u05b2\n\63")
        buf.write("\3\63\7\63\u05b5\n\63\f\63\16\63\u05b8\13\63\3\63\3\63")
        buf.write("\7\63\u05bc\n\63\f\63\16\63\u05bf\13\63\3\63\3\63\7\63")
        buf.write("\u05c3\n\63\f\63\16\63\u05c6\13\63\3\63\3\63\5\63\u05ca")
        buf.write("\n\63\3\63\3\63\7\63\u05ce\n\63\f\63\16\63\u05d1\13\63")
        buf.write("\3\63\3\63\7\63\u05d5\n\63\f\63\16\63\u05d8\13\63\3\63")
        buf.write("\3\63\7\63\u05dc\n\63\f\63\16\63\u05df\13\63\3\63\3\63")
        buf.write("\3\63\3\63\7\63\u05e5\n\63\f\63\16\63\u05e8\13\63\3\63")
        buf.write("\3\63\7\63\u05ec\n\63\f\63\16\63\u05ef\13\63\3\63\5\63")
        buf.write("\u05f2\n\63\3\63\7\63\u05f5\n\63\f\63\16\63\u05f8\13\63")
        buf.write("\3\63\7\63\u05fb\n\63\f\63\16\63\u05fe\13\63\3\64\3\64")
        buf.write("\3\64\7\64\u0603\n\64\f\64\16\64\u0606\13\64\3\64\3\64")
        buf.write("\7\64\u060a\n\64\f\64\16\64\u060d\13\64\3\64\3\64\7\64")
        buf.write("\u0611\n\64\f\64\16\64\u0614\13\64\3\65\3\65\7\65\u0618")
        buf.write("\n\65\f\65\16\65\u061b\13\65\3\65\5\65\u061e\n\65\3\65")
        buf.write("\7\65\u0621\n\65\f\65\16\65\u0624\13\65\6\65\u0626\n\65")
        buf.write("\r\65\16\65\u0627\3\66\6\66\u062b\n\66\r\66\16\66\u062c")
        buf.write("\3\67\3\67\7\67\u0631\n\67\f\67\16\67\u0634\13\67\3\67")
        buf.write("\3\67\7\67\u0638\n\67\f\67\16\67\u063b\13\67\3\67\3\67")
        buf.write("\7\67\u063f\n\67\f\67\16\67\u0642\13\67\5\67\u0644\n\67")
        buf.write("\38\38\78\u0648\n8\f8\168\u064b\138\38\38\78\u064f\n8")
        buf.write("\f8\168\u0652\138\38\38\78\u0656\n8\f8\168\u0659\138\7")
        buf.write("8\u065b\n8\f8\168\u065e\138\39\39\79\u0662\n9\f9\169\u0665")
        buf.write("\139\39\39\39\39\79\u066b\n9\f9\169\u066e\139\39\59\u0671")
        buf.write("\n9\59\u0673\n9\3:\3:\7:\u0677\n:\f:\16:\u067a\13:\3:")
        buf.write("\3:\7:\u067e\n:\f:\16:\u0681\13:\3:\3:\7:\u0685\n:\f:")
        buf.write("\16:\u0688\13:\7:\u068a\n:\f:\16:\u068d\13:\3;\3;\7;\u0691")
        buf.write("\n;\f;\16;\u0694\13;\3;\5;\u0697\n;\3<\3<\5<\u069b\n<")
        buf.write("\3<\7<\u069e\n<\f<\16<\u06a1\13<\3<\5<\u06a4\n<\3=\3=")
        buf.write("\3=\7=\u06a9\n=\f=\16=\u06ac\13=\3=\3=\7=\u06b0\n=\f=")
        buf.write("\16=\u06b3\13=\3=\3=\3=\3=\7=\u06b9\n=\f=\16=\u06bc\13")
        buf.write("=\3=\5=\u06bf\n=\3=\7=\u06c2\n=\f=\16=\u06c5\13=\3=\5")
        buf.write("=\u06c8\n=\3=\7=\u06cb\n=\f=\16=\u06ce\13=\3=\3=\3=\7")
        buf.write("=\u06d3\n=\f=\16=\u06d6\13=\3=\3=\7=\u06da\n=\f=\16=\u06dd")
        buf.write("\13=\3=\5=\u06e0\n=\3=\7=\u06e3\n=\f=\16=\u06e6\13=\3")
        buf.write("=\3=\7=\u06ea\n=\f=\16=\u06ed\13=\3=\3=\3=\3=\7=\u06f3")
        buf.write("\n=\f=\16=\u06f6\13=\3=\3=\7=\u06fa\n=\f=\16=\u06fd\13")
        buf.write("=\3=\3=\7=\u0701\n=\f=\16=\u0704\13=\3=\3=\7=\u0708\n")
        buf.write("=\f=\16=\u070b\13=\3=\3=\3=\3=\7=\u0711\n=\f=\16=\u0714")
        buf.write("\13=\3=\3=\7=\u0718\n=\f=\16=\u071b\13=\3=\3=\3=\7=\u0720")
        buf.write("\n=\f=\16=\u0723\13=\3=\5=\u0726\n=\3=\7=\u0729\n=\f=")
        buf.write("\16=\u072c\13=\3=\5=\u072f\n=\3=\3=\7=\u0733\n=\f=\16")
        buf.write("=\u0736\13=\3=\3=\7=\u073a\n=\f=\16=\u073d\13=\3=\5=\u0740")
        buf.write("\n=\3=\7=\u0743\n=\f=\16=\u0746\13=\3=\5=\u0749\n=\3=")
        buf.write("\7=\u074c\n=\f=\16=\u074f\13=\3=\3=\3=\7=\u0754\n=\f=")
        buf.write("\16=\u0757\13=\3=\3=\7=\u075b\n=\f=\16=\u075e\13=\3=\3")
        buf.write("=\7=\u0762\n=\f=\16=\u0765\13=\3=\5=\u0768\n=\3=\7=\u076b")
        buf.write("\n=\f=\16=\u076e\13=\3=\3=\7=\u0772\n=\f=\16=\u0775\13")
        buf.write("=\3=\3=\3=\3=\7=\u077b\n=\f=\16=\u077e\13=\3=\3=\7=\u0782")
        buf.write("\n=\f=\16=\u0785\13=\3=\3=\7=\u0789\n=\f=\16=\u078c\13")
        buf.write("=\3=\3=\7=\u0790\n=\f=\16=\u0793\13=\3=\3=\7=\u0797\n")
        buf.write("=\f=\16=\u079a\13=\3=\3=\3=\3=\7=\u07a0\n=\f=\16=\u07a3")
        buf.write("\13=\3=\3=\7=\u07a7\n=\f=\16=\u07aa\13=\3=\3=\7=\u07ae")
        buf.write("\n=\f=\16=\u07b1\13=\3=\3=\3=\7=\u07b6\n=\f=\16=\u07b9")
        buf.write("\13=\3=\3=\7=\u07bd\n=\f=\16=\u07c0\13=\3=\5=\u07c3\n")
        buf.write("=\3=\7=\u07c6\n=\f=\16=\u07c9\13=\3=\7=\u07cc\n=\f=\16")
        buf.write("=\u07cf\13=\3>\3>\3?\3?\3?\7?\u07d6\n?\f?\16?\u07d9\13")
        buf.write("?\3?\5?\u07dc\n?\3?\7?\u07df\n?\f?\16?\u07e2\13?\3?\5")
        buf.write("?\u07e5\n?\3?\7?\u07e8\n?\f?\16?\u07eb\13?\3?\5?\u07ee")
        buf.write("\n?\3@\5@\u07f1\n@\3@\7@\u07f4\n@\f@\16@\u07f7\13@\3@")
        buf.write("\3@\7@\u07fb\n@\f@\16@\u07fe\13@\3@\3@\7@\u0802\n@\f@")
        buf.write("\16@\u0805\13@\3@\5@\u0808\n@\3@\7@\u080b\n@\f@\16@\u080e")
        buf.write("\13@\3@\3@\7@\u0812\n@\f@\16@\u0815\13@\7@\u0817\n@\f")
        buf.write("@\16@\u081a\13@\3A\3A\7A\u081e\nA\fA\16A\u0821\13A\3A")
        buf.write("\3A\3B\6B\u0826\nB\rB\16B\u0827\3C\3C\7C\u082c\nC\fC\16")
        buf.write("C\u082f\13C\3C\3C\7C\u0833\nC\fC\16C\u0836\13C\3C\3C\3")
        buf.write("C\3C\7C\u083c\nC\fC\16C\u083f\13C\3C\5C\u0842\nC\3D\3")
        buf.write("D\7D\u0846\nD\fD\16D\u0849\13D\3D\3D\7D\u084d\nD\fD\16")
        buf.write("D\u0850\13D\3D\3D\7D\u0854\nD\fD\16D\u0857\13D\3D\3D\7")
        buf.write("D\u085b\nD\fD\16D\u085e\13D\3D\6D\u0861\nD\rD\16D\u0862")
        buf.write("\3D\7D\u0866\nD\fD\16D\u0869\13D\3D\3D\3D\3E\3E\3E\3E")
        buf.write("\3E\3E\3E\3E\3E\7E\u0877\nE\fE\16E\u087a\13E\3E\3E\7E")
        buf.write("\u087e\nE\fE\16E\u0881\13E\3E\3E\7E\u0885\nE\fE\16E\u0888")
        buf.write("\13E\3E\3E\7E\u088c\nE\fE\16E\u088f\13E\7E\u0891\nE\f")
        buf.write("E\16E\u0894\13E\5E\u0896\nE\3E\7E\u0899\nE\fE\16E\u089c")
        buf.write("\13E\3E\3E\7E\u08a0\nE\fE\16E\u08a3\13E\3E\3E\7E\u08a7")
        buf.write("\nE\fE\16E\u08aa\13E\3E\3E\7E\u08ae\nE\fE\16E\u08b1\13")
        buf.write("E\3E\7E\u08b4\nE\fE\16E\u08b7\13E\5E\u08b9\nE\7E\u08bb")
        buf.write("\nE\fE\16E\u08be\13E\3E\7E\u08c1\nE\fE\16E\u08c4\13E\3")
        buf.write("E\3E\5E\u08c8\nE\3F\3F\7F\u08cc\nF\fF\16F\u08cf\13F\3")
        buf.write("F\3F\7F\u08d3\nF\fF\16F\u08d6\13F\3F\3F\7F\u08da\nF\f")
        buf.write("F\16F\u08dd\13F\3F\3F\3F\3F\7F\u08e3\nF\fF\16F\u08e6\13")
        buf.write("F\3F\3F\7F\u08ea\nF\fF\16F\u08ed\13F\3F\5F\u08f0\nF\3")
        buf.write("G\3G\7G\u08f4\nG\fG\16G\u08f7\13G\3G\5G\u08fa\nG\3G\7")
        buf.write("G\u08fd\nG\fG\16G\u0900\13G\3G\3G\3H\6H\u0905\nH\rH\16")
        buf.write("H\u0906\3I\7I\u090a\nI\fI\16I\u090d\13I\3I\3I\5I\u0911")
        buf.write("\nI\3I\7I\u0914\nI\fI\16I\u0917\13I\3J\5J\u091a\nJ\3J")
        buf.write("\3J\3K\3K\7K\u0920\nK\fK\16K\u0923\13K\3K\3K\7K\u0927")
        buf.write("\nK\fK\16K\u092a\13K\3K\6K\u092d\nK\rK\16K\u092e\3K\7")
        buf.write("K\u0932\nK\fK\16K\u0935\13K\3K\3K\7K\u0939\nK\fK\16K\u093c")
        buf.write("\13K\3K\5K\u093f\nK\3K\7K\u0942\nK\fK\16K\u0945\13K\3")
        buf.write("K\3K\7K\u0949\nK\fK\16K\u094c\13K\3K\5K\u094f\nK\3K\7")
        buf.write("K\u0952\nK\fK\16K\u0955\13K\5K\u0957\nK\3L\3L\7L\u095b")
        buf.write("\nL\fL\16L\u095e\13L\3L\3L\7L\u0962\nL\fL\16L\u0965\13")
        buf.write("L\3L\3L\5L\u0969\nL\3L\7L\u096c\nL\fL\16L\u096f\13L\3")
        buf.write("L\3L\7L\u0973\nL\fL\16L\u0976\13L\3L\3L\7L\u097a\nL\f")
        buf.write("L\16L\u097d\13L\3L\5L\u0980\nL\3L\7L\u0983\nL\fL\16L\u0986")
        buf.write("\13L\3L\3L\3M\3M\7M\u098c\nM\fM\16M\u098f\13M\3M\3M\3")
        buf.write("N\3N\7N\u0995\nN\fN\16N\u0998\13N\3N\3N\3O\3O\7O\u099e")
        buf.write("\nO\fO\16O\u09a1\13O\3O\3O\7O\u09a5\nO\fO\16O\u09a8\13")
        buf.write("O\3O\3O\7O\u09ac\nO\fO\16O\u09af\13O\3O\3O\7O\u09b3\n")
        buf.write("O\fO\16O\u09b6\13O\3O\3O\7O\u09ba\nO\fO\16O\u09bd\13O")
        buf.write("\3O\3O\7O\u09c1\nO\fO\16O\u09c4\13O\3O\5O\u09c7\nO\3O")
        buf.write("\3O\7O\u09cb\nO\fO\16O\u09ce\13O\3O\3O\7O\u09d2\nO\fO")
        buf.write("\16O\u09d5\13O\3O\3O\7O\u09d9\nO\fO\16O\u09dc\13O\3O\3")
        buf.write("O\7O\u09e0\nO\fO\16O\u09e3\13O\3O\3O\5O\u09e7\nO\3P\3")
        buf.write("P\7P\u09eb\nP\fP\16P\u09ee\13P\3P\3P\7P\u09f2\nP\fP\16")
        buf.write("P\u09f5\13P\3P\3P\7P\u09f9\nP\fP\16P\u09fc\13P\3P\3P\7")
        buf.write("P\u0a00\nP\fP\16P\u0a03\13P\3P\3P\3P\3P\7P\u0a09\nP\f")
        buf.write("P\16P\u0a0c\13P\3P\3P\7P\u0a10\nP\fP\16P\u0a13\13P\3P")
        buf.write("\3P\7P\u0a17\nP\fP\16P\u0a1a\13P\3P\3P\7P\u0a1e\nP\fP")
        buf.write("\16P\u0a21\13P\3P\3P\7P\u0a25\nP\fP\16P\u0a28\13P\3P\3")
        buf.write("P\3P\3P\3P\7P\u0a2f\nP\fP\16P\u0a32\13P\3P\3P\7P\u0a36")
        buf.write("\nP\fP\16P\u0a39\13P\3P\3P\7P\u0a3d\nP\fP\16P\u0a40\13")
        buf.write("P\3P\3P\7P\u0a44\nP\fP\16P\u0a47\13P\3P\3P\5P\u0a4b\n")
        buf.write("P\3Q\3Q\5Q\u0a4f\nQ\5Q\u0a51\nQ\3Q\3Q\5Q\u0a55\nQ\3Q\3")
        buf.write("Q\5Q\u0a59\nQ\3R\3R\7R\u0a5d\nR\fR\16R\u0a60\13R\3R\5")
        buf.write("R\u0a63\nR\3S\3S\7S\u0a67\nS\fS\16S\u0a6a\13S\3S\3S\7")
        buf.write("S\u0a6e\nS\fS\16S\u0a71\13S\3S\3S\7S\u0a75\nS\fS\16S\u0a78")
        buf.write("\13S\7S\u0a7a\nS\fS\16S\u0a7d\13S\3T\3T\3T\7T\u0a82\n")
        buf.write("T\fT\16T\u0a85\13T\3T\5T\u0a88\nT\5T\u0a8a\nT\3T\3T\3")
        buf.write("U\5U\u0a8f\nU\3U\3U\3V\3V\3V\6V\u0a96\nV\rV\16V\u0a97")
        buf.write("\6V\u0a9a\nV\rV\16V\u0a9b\3W\3W\3W\5W\u0aa1\nW\3X\3X\7")
        buf.write("X\u0aa5\nX\fX\16X\u0aa8\13X\3X\3X\7X\u0aac\nX\fX\16X\u0aaf")
        buf.write("\13X\3X\5X\u0ab2\nX\3X\7X\u0ab5\nX\fX\16X\u0ab8\13X\3")
        buf.write("X\3X\3X\3X\7X\u0abe\nX\fX\16X\u0ac1\13X\3X\3X\7X\u0ac5")
        buf.write("\nX\fX\16X\u0ac8\13X\3X\5X\u0acb\nX\3X\7X\u0ace\nX\fX")
        buf.write("\16X\u0ad1\13X\3X\3X\3X\5X\u0ad6\nX\3Y\7Y\u0ad9\nY\fY")
        buf.write("\16Y\u0adc\13Y\3Y\7Y\u0adf\nY\fY\16Y\u0ae2\13Y\3Y\5Y\u0ae5")
        buf.write("\nY\3Z\3Z\3Z\3[\3[\7[\u0aec\n[\f[\16[\u0aef\13[\3[\3[")
        buf.write("\7[\u0af3\n[\f[\16[\u0af6\13[\3[\3[\7[\u0afa\n[\f[\16")
        buf.write("[\u0afd\13[\3[\5[\u0b00\n[\3[\7[\u0b03\n[\f[\16[\u0b06")
        buf.write("\13[\3[\3[\3\\\3\\\7\\\u0b0c\n\\\f\\\16\\\u0b0f\13\\\3")
        buf.write("\\\3\\\7\\\u0b13\n\\\f\\\16\\\u0b16\13\\\3\\\3\\\7\\\u0b1a")
        buf.write("\n\\\f\\\16\\\u0b1d\13\\\3\\\3\\\7\\\u0b21\n\\\f\\\16")
        buf.write("\\\u0b24\13\\\7\\\u0b26\n\\\f\\\16\\\u0b29\13\\\5\\\u0b2b")
        buf.write("\n\\\3\\\3\\\3]\3]\7]\u0b31\n]\f]\16]\u0b34\13]\3]\3]")
        buf.write("\7]\u0b38\n]\f]\16]\u0b3b\13]\3]\3]\3^\3^\7^\u0b41\n^")
        buf.write("\f^\16^\u0b44\13^\6^\u0b46\n^\r^\16^\u0b47\3_\7_\u0b4b")
        buf.write("\n_\f_\16_\u0b4e\13_\3_\3_\7_\u0b52\n_\f_\16_\u0b55\13")
        buf.write("_\3_\2\6\24Bdx`\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
        buf.write(" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt")
        buf.write("vxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e")
        buf.write("\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0")
        buf.write("\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2")
        buf.write("\u00b4\u00b6\u00b8\u00ba\u00bc\2\24\3\2de\4\2@@BB\5\2")
        buf.write("--@@BB\4\2--\62\62\7\2??AACCFFKL\3\2CE\4\2??AA\3\2=>\3")
        buf.write("\2`c\3\2^_\3\2S]\5\2\31\34//\66\66\4\2,,\60\60\4\2\25")
        buf.write("\27((\4\2\n\n\64\64\3\2\678\4\2CCJJ\3\2 !\2\u0cde\2\u00ca")
        buf.write("\3\2\2\2\4\u00cc\3\2\2\2\6\u00e7\3\2\2\2\b\u00e9\3\2\2")
        buf.write("\2\n\u00f2\3\2\2\2\f\u0133\3\2\2\2\16\u016a\3\2\2\2\20")
        buf.write("\u0187\3\2\2\2\22\u01b3\3\2\2\2\24\u01cf\3\2\2\2\26\u01e5")
        buf.write("\3\2\2\2\30\u01ff\3\2\2\2\32\u0219\3\2\2\2\34\u0233\3")
        buf.write("\2\2\2\36\u024d\3\2\2\2 \u0267\3\2\2\2\"\u0281\3\2\2\2")
        buf.write("$\u029b\3\2\2\2&\u02b5\3\2\2\2(\u02cf\3\2\2\2*\u02e9\3")
        buf.write("\2\2\2,\u0320\3\2\2\2.\u0322\3\2\2\2\60\u0324\3\2\2\2")
        buf.write("\62\u033e\3\2\2\2\64\u034d\3\2\2\2\66\u0356\3\2\2\28\u035f")
        buf.write("\3\2\2\2:\u0361\3\2\2\2<\u037b\3\2\2\2>\u0392\3\2\2\2")
        buf.write("@\u03fe\3\2\2\2B\u0447\3\2\2\2D\u0484\3\2\2\2F\u0486\3")
        buf.write("\2\2\2H\u0495\3\2\2\2J\u04a6\3\2\2\2L\u04aa\3\2\2\2N\u04b5")
        buf.write("\3\2\2\2P\u04db\3\2\2\2R\u050e\3\2\2\2T\u0510\3\2\2\2")
        buf.write("V\u052a\3\2\2\2X\u0541\3\2\2\2Z\u0543\3\2\2\2\\\u055f")
        buf.write("\3\2\2\2^\u0561\3\2\2\2`\u0563\3\2\2\2b\u057e\3\2\2\2")
        buf.write("d\u05c9\3\2\2\2f\u0612\3\2\2\2h\u0625\3\2\2\2j\u062a\3")
        buf.write("\2\2\2l\u062e\3\2\2\2n\u0645\3\2\2\2p\u0672\3\2\2\2r\u0674")
        buf.write("\3\2\2\2t\u068e\3\2\2\2v\u06a3\3\2\2\2x\u072e\3\2\2\2")
        buf.write("z\u07d0\3\2\2\2|\u07ed\3\2\2\2~\u07f0\3\2\2\2\u0080\u081b")
        buf.write("\3\2\2\2\u0082\u0825\3\2\2\2\u0084\u0841\3\2\2\2\u0086")
        buf.write("\u0843\3\2\2\2\u0088\u08c7\3\2\2\2\u008a\u08ef\3\2\2\2")
        buf.write("\u008c\u08f1\3\2\2\2\u008e\u0904\3\2\2\2\u0090\u090b\3")
        buf.write("\2\2\2\u0092\u0919\3\2\2\2\u0094\u091d\3\2\2\2\u0096\u0958")
        buf.write("\3\2\2\2\u0098\u0989\3\2\2\2\u009a\u0992\3\2\2\2\u009c")
        buf.write("\u09e6\3\2\2\2\u009e\u0a4a\3\2\2\2\u00a0\u0a50\3\2\2\2")
        buf.write("\u00a2\u0a5a\3\2\2\2\u00a4\u0a64\3\2\2\2\u00a6\u0a89\3")
        buf.write("\2\2\2\u00a8\u0a8e\3\2\2\2\u00aa\u0a99\3\2\2\2\u00ac\u0aa0")
        buf.write("\3\2\2\2\u00ae\u0ad5\3\2\2\2\u00b0\u0ada\3\2\2\2\u00b2")
        buf.write("\u0ae6\3\2\2\2\u00b4\u0ae9\3\2\2\2\u00b6\u0b09\3\2\2\2")
        buf.write("\u00b8\u0b2e\3\2\2\2\u00ba\u0b45\3\2\2\2\u00bc\u0b4c\3")
        buf.write("\2\2\2\u00be\u00cb\7g\2\2\u00bf\u00cb\7h\2\2\u00c0\u00c2")
        buf.write("\7j\2\2\u00c1\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3")
        buf.write("\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00cb\3\2\2\2")
        buf.write("\u00c5\u00c6\7\67\2\2\u00c6\u00c7\5\60\31\2\u00c7\u00c8")
        buf.write("\78\2\2\u00c8\u00cb\3\2\2\2\u00c9\u00cb\5\4\3\2\u00ca")
        buf.write("\u00be\3\2\2\2\u00ca\u00bf\3\2\2\2\u00ca\u00c1\3\2\2\2")
        buf.write("\u00ca\u00c5\3\2\2\2\u00ca\u00c9\3\2\2\2\u00cb\3\3\2\2")
        buf.write("\2\u00cc\u00d0\7\67\2\2\u00cd\u00cf\7m\2\2\u00ce\u00cd")
        buf.write("\3\2\2\2\u00cf\u00d2\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d0")
        buf.write("\u00d1\3\2\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2")
        buf.write("\u00d3\u00d5\5n8\2\u00d4\u00d3\3\2\2\2\u00d4\u00d5\3\2")
        buf.write("\2\2\u00d5\u00d9\3\2\2\2\u00d6\u00d8\7m\2\2\u00d7\u00d6")
        buf.write("\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9")
        buf.write("\u00da\3\2\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2")
        buf.write("\u00dc\u00e0\78\2\2\u00dd\u00df\7m\2\2\u00de\u00dd\3\2")
        buf.write("\2\2\u00df\u00e2\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1")
        buf.write("\3\2\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3")
        buf.write("\u00e4\5\6\4\2\u00e4\5\3\2\2\2\u00e5\u00e8\5\b\5\2\u00e6")
        buf.write("\u00e8\5\n\6\2\u00e7\u00e5\3\2\2\2\u00e7\u00e6\3\2\2\2")
        buf.write("\u00e8\7\3\2\2\2\u00e9\u00ed\7N\2\2\u00ea\u00ec\7m\2\2")
        buf.write("\u00eb\u00ea\3\2\2\2\u00ec\u00ef\3\2\2\2\u00ed\u00eb\3")
        buf.write("\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00f0\3\2\2\2\u00ef\u00ed")
        buf.write("\3\2\2\2\u00f0\u00f1\5\60\31\2\u00f1\t\3\2\2\2\u00f2\u00f6")
        buf.write("\7N\2\2\u00f3\u00f5\7m\2\2\u00f4\u00f3\3\2\2\2\u00f5\u00f8")
        buf.write("\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7")
        buf.write("\u00f9\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f9\u00fa\5\u008c")
        buf.write("G\2\u00fa\13\3\2\2\2\u00fb\u00fd\7+\2\2\u00fc\u00fb\3")
        buf.write("\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u0101\3\2\2\2\u00fe\u0100")
        buf.write("\7m\2\2\u00ff\u00fe\3\2\2\2\u0100\u0103\3\2\2\2\u0101")
        buf.write("\u00ff\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0104\3\2\2\2")
        buf.write("\u0103\u0101\3\2\2\2\u0104\u0134\5\2\2\2\u0105\u0109\7")
        buf.write("\67\2\2\u0106\u0108\7m\2\2\u0107\u0106\3\2\2\2\u0108\u010b")
        buf.write("\3\2\2\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a")
        buf.write("\u010c\3\2\2\2\u010b\u0109\3\2\2\2\u010c\u0110\5t;\2\u010d")
        buf.write("\u010f\7m\2\2\u010e\u010d\3\2\2\2\u010f\u0112\3\2\2\2")
        buf.write("\u0110\u010e\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0113\3")
        buf.write("\2\2\2\u0112\u0110\3\2\2\2\u0113\u0117\78\2\2\u0114\u0116")
        buf.write("\7m\2\2\u0115\u0114\3\2\2\2\u0116\u0119\3\2\2\2\u0117")
        buf.write("\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011a\3\2\2\2")
        buf.write("\u0119\u0117\3\2\2\2\u011a\u011e\7;\2\2\u011b\u011d\7")
        buf.write("m\2\2\u011c\u011b\3\2\2\2\u011d\u0120\3\2\2\2\u011e\u011c")
        buf.write("\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0121\3\2\2\2\u0120")
        buf.write("\u011e\3\2\2\2\u0121\u0125\5~@\2\u0122\u0124\7m\2\2\u0123")
        buf.write("\u0122\3\2\2\2\u0124\u0127\3\2\2\2\u0125\u0123\3\2\2\2")
        buf.write("\u0125\u0126\3\2\2\2\u0126\u0129\3\2\2\2\u0127\u0125\3")
        buf.write("\2\2\2\u0128\u012a\7R\2\2\u0129\u0128\3\2\2\2\u0129\u012a")
        buf.write("\3\2\2\2\u012a\u012e\3\2\2\2\u012b\u012d\7m\2\2\u012c")
        buf.write("\u012b\3\2\2\2\u012d\u0130\3\2\2\2\u012e\u012c\3\2\2\2")
        buf.write("\u012e\u012f\3\2\2\2\u012f\u0131\3\2\2\2\u0130\u012e\3")
        buf.write("\2\2\2\u0131\u0132\7<\2\2\u0132\u0134\3\2\2\2\u0133\u00fc")
        buf.write("\3\2\2\2\u0133\u0105\3\2\2\2\u0134\u0138\3\2\2\2\u0135")
        buf.write("\u0137\7m\2\2\u0136\u0135\3\2\2\2\u0137\u013a\3\2\2\2")
        buf.write("\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u0167\3")
        buf.write("\2\2\2\u013a\u0138\3\2\2\2\u013b\u013f\79\2\2\u013c\u013e")
        buf.write("\7m\2\2\u013d\u013c\3\2\2\2\u013e\u0141\3\2\2\2\u013f")
        buf.write("\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0142\3\2\2\2")
        buf.write("\u0141\u013f\3\2\2\2\u0142\u0146\5\60\31\2\u0143\u0145")
        buf.write("\7m\2\2\u0144\u0143\3\2\2\2\u0145\u0148\3\2\2\2\u0146")
        buf.write("\u0144\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0149\3\2\2\2")
        buf.write("\u0148\u0146\3\2\2\2\u0149\u014a\7:\2\2\u014a\u0166\3")
        buf.write("\2\2\2\u014b\u014f\7\67\2\2\u014c\u014e\7m\2\2\u014d\u014c")
        buf.write("\3\2\2\2\u014e\u0151\3\2\2\2\u014f\u014d\3\2\2\2\u014f")
        buf.write("\u0150\3\2\2\2\u0150\u0153\3\2\2\2\u0151\u014f\3\2\2\2")
        buf.write("\u0152\u0154\5\16\b\2\u0153\u0152\3\2\2\2\u0153\u0154")
        buf.write("\3\2\2\2\u0154\u0158\3\2\2\2\u0155\u0157\7m\2\2\u0156")
        buf.write("\u0155\3\2\2\2\u0157\u015a\3\2\2\2\u0158\u0156\3\2\2\2")
        buf.write("\u0158\u0159\3\2\2\2\u0159\u015b\3\2\2\2\u015a\u0158\3")
        buf.write("\2\2\2\u015b\u0166\78\2\2\u015c\u0160\t\2\2\2\u015d\u015f")
        buf.write("\7m\2\2\u015e\u015d\3\2\2\2\u015f\u0162\3\2\2\2\u0160")
        buf.write("\u015e\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0163\3\2\2\2")
        buf.write("\u0162\u0160\3\2\2\2\u0163\u0166\7g\2\2\u0164\u0166\t")
        buf.write("\3\2\2\u0165\u013b\3\2\2\2\u0165\u014b\3\2\2\2\u0165\u015c")
        buf.write("\3\2\2\2\u0165\u0164\3\2\2\2\u0166\u0169\3\2\2\2\u0167")
        buf.write("\u0165\3\2\2\2\u0167\u0168\3\2\2\2\u0168\r\3\2\2\2\u0169")
        buf.write("\u0167\3\2\2\2\u016a\u016e\5,\27\2\u016b\u016d\7m\2\2")
        buf.write("\u016c\u016b\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3")
        buf.write("\2\2\2\u016e\u016f\3\2\2\2\u016f\u0181\3\2\2\2\u0170\u016e")
        buf.write("\3\2\2\2\u0171\u0175\7R\2\2\u0172\u0174\7m\2\2\u0173\u0172")
        buf.write("\3\2\2\2\u0174\u0177\3\2\2\2\u0175\u0173\3\2\2\2\u0175")
        buf.write("\u0176\3\2\2\2\u0176\u0178\3\2\2\2\u0177\u0175\3\2\2\2")
        buf.write("\u0178\u017c\5,\27\2\u0179\u017b\7m\2\2\u017a\u0179\3")
        buf.write("\2\2\2\u017b\u017e\3\2\2\2\u017c\u017a\3\2\2\2\u017c\u017d")
        buf.write("\3\2\2\2\u017d\u0180\3\2\2\2\u017e\u017c\3\2\2\2\u017f")
        buf.write("\u0171\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2")
        buf.write("\u0181\u0182\3\2\2\2\u0182\17\3\2\2\2\u0183\u0181\3\2")
        buf.write("\2\2\u0184\u0186\t\4\2\2\u0185\u0184\3\2\2\2\u0186\u0189")
        buf.write("\3\2\2\2\u0187\u0185\3\2\2\2\u0187\u0188\3\2\2\2\u0188")
        buf.write("\u018d\3\2\2\2\u0189\u0187\3\2\2\2\u018a\u018c\7m\2\2")
        buf.write("\u018b\u018a\3\2\2\2\u018c\u018f\3\2\2\2\u018d\u018b\3")
        buf.write("\2\2\2\u018d\u018e\3\2\2\2\u018e\u01b1\3\2\2\2\u018f\u018d")
        buf.write("\3\2\2\2\u0190\u01b2\5\f\7\2\u0191\u0195\5\22\n\2\u0192")
        buf.write("\u0194\7m\2\2\u0193\u0192\3\2\2\2\u0194\u0197\3\2\2\2")
        buf.write("\u0195\u0193\3\2\2\2\u0195\u0196\3\2\2\2\u0196\u0198\3")
        buf.write("\2\2\2\u0197\u0195\3\2\2\2\u0198\u0199\5\24\13\2\u0199")
        buf.write("\u01b2\3\2\2\2\u019a\u019e\t\5\2\2\u019b\u019d\7m\2\2")
        buf.write("\u019c\u019b\3\2\2\2\u019d\u01a0\3\2\2\2\u019e\u019c\3")
        buf.write("\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a1\3\2\2\2\u01a0\u019e")
        buf.write("\3\2\2\2\u01a1\u01a5\7\67\2\2\u01a2\u01a4\7m\2\2\u01a3")
        buf.write("\u01a2\3\2\2\2\u01a4\u01a7\3\2\2\2\u01a5\u01a3\3\2\2\2")
        buf.write("\u01a5\u01a6\3\2\2\2\u01a6\u01a8\3\2\2\2\u01a7\u01a5\3")
        buf.write("\2\2\2\u01a8\u01ac\5t;\2\u01a9\u01ab\7m\2\2\u01aa\u01a9")
        buf.write("\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac")
        buf.write("\u01ad\3\2\2\2\u01ad\u01af\3\2\2\2\u01ae\u01ac\3\2\2\2")
        buf.write("\u01af\u01b0\78\2\2\u01b0\u01b2\3\2\2\2\u01b1\u0190\3")
        buf.write("\2\2\2\u01b1\u0191\3\2\2\2\u01b1\u019a\3\2\2\2\u01b2\21")
        buf.write("\3\2\2\2\u01b3\u01b4\t\6\2\2\u01b4\23\3\2\2\2\u01b5\u01b6")
        buf.write("\b\13\1\2\u01b6\u01ba\7\67\2\2\u01b7\u01b9\7m\2\2\u01b8")
        buf.write("\u01b7\3\2\2\2\u01b9\u01bc\3\2\2\2\u01ba\u01b8\3\2\2\2")
        buf.write("\u01ba\u01bb\3\2\2\2\u01bb\u01bd\3\2\2\2\u01bc\u01ba\3")
        buf.write("\2\2\2\u01bd\u01c1\5t;\2\u01be\u01c0\7m\2\2\u01bf\u01be")
        buf.write("\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1\u01bf\3\2\2\2\u01c1")
        buf.write("\u01c2\3\2\2\2\u01c2\u01c4\3\2\2\2\u01c3\u01c1\3\2\2\2")
        buf.write("\u01c4\u01c8\78\2\2\u01c5\u01c7\7m\2\2\u01c6\u01c5\3\2")
        buf.write("\2\2\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c8\u01c9")
        buf.write("\3\2\2\2\u01c9\u01cb\3\2\2\2\u01ca\u01c8\3\2\2\2\u01cb")
        buf.write("\u01cc\5\24\13\6\u01cc\u01d0\3\2\2\2\u01cd\u01d0\5\20")
        buf.write("\t\2\u01ce\u01d0\7i\2\2\u01cf\u01b5\3\2\2\2\u01cf\u01cd")
        buf.write("\3\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01e2\3\2\2\2\u01d1")
        buf.write("\u01d5\f\5\2\2\u01d2\u01d4\7m\2\2\u01d3\u01d2\3\2\2\2")
        buf.write("\u01d4\u01d7\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3")
        buf.write("\2\2\2\u01d6\u01d8\3\2\2\2\u01d7\u01d5\3\2\2\2\u01d8\u01dc")
        buf.write("\7\30\2\2\u01d9\u01db\7m\2\2\u01da\u01d9\3\2\2\2\u01db")
        buf.write("\u01de\3\2\2\2\u01dc\u01da\3\2\2\2\u01dc\u01dd\3\2\2\2")
        buf.write("\u01dd\u01df\3\2\2\2\u01de\u01dc\3\2\2\2\u01df\u01e1\5")
        buf.write("t;\2\u01e0\u01d1\3\2\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0")
        buf.write("\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\25\3\2\2\2\u01e4\u01e2")
        buf.write("\3\2\2\2\u01e5\u01e9\5\24\13\2\u01e6\u01e8\7m\2\2\u01e7")
        buf.write("\u01e6\3\2\2\2\u01e8\u01eb\3\2\2\2\u01e9\u01e7\3\2\2\2")
        buf.write("\u01e9\u01ea\3\2\2\2\u01ea\u01fc\3\2\2\2\u01eb\u01e9\3")
        buf.write("\2\2\2\u01ec\u01f0\t\7\2\2\u01ed\u01ef\7m\2\2\u01ee\u01ed")
        buf.write("\3\2\2\2\u01ef\u01f2\3\2\2\2\u01f0\u01ee\3\2\2\2\u01f0")
        buf.write("\u01f1\3\2\2\2\u01f1\u01f3\3\2\2\2\u01f2\u01f0\3\2\2\2")
        buf.write("\u01f3\u01f7\5\24\13\2\u01f4\u01f6\7m\2\2\u01f5\u01f4")
        buf.write("\3\2\2\2\u01f6\u01f9\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f7")
        buf.write("\u01f8\3\2\2\2\u01f8\u01fb\3\2\2\2\u01f9\u01f7\3\2\2\2")
        buf.write("\u01fa\u01ec\3\2\2\2\u01fb\u01fe\3\2\2\2\u01fc\u01fa\3")
        buf.write("\2\2\2\u01fc\u01fd\3\2\2\2\u01fd\27\3\2\2\2\u01fe\u01fc")
        buf.write("\3\2\2\2\u01ff\u0203\5\26\f\2\u0200\u0202\7m\2\2\u0201")
        buf.write("\u0200\3\2\2\2\u0202\u0205\3\2\2\2\u0203\u0201\3\2\2\2")
        buf.write("\u0203\u0204\3\2\2\2\u0204\u0216\3\2\2\2\u0205\u0203\3")
        buf.write("\2\2\2\u0206\u020a\t\b\2\2\u0207\u0209\7m\2\2\u0208\u0207")
        buf.write("\3\2\2\2\u0209\u020c\3\2\2\2\u020a\u0208\3\2\2\2\u020a")
        buf.write("\u020b\3\2\2\2\u020b\u020d\3\2\2\2\u020c\u020a\3\2\2\2")
        buf.write("\u020d\u0211\5\26\f\2\u020e\u0210\7m\2\2\u020f\u020e\3")
        buf.write("\2\2\2\u0210\u0213\3\2\2\2\u0211\u020f\3\2\2\2\u0211\u0212")
        buf.write("\3\2\2\2\u0212\u0215\3\2\2\2\u0213\u0211\3\2\2\2\u0214")
        buf.write("\u0206\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2\2\2")
        buf.write("\u0216\u0217\3\2\2\2\u0217\31\3\2\2\2\u0218\u0216\3\2")
        buf.write("\2\2\u0219\u021d\5\30\r\2\u021a\u021c\7m\2\2\u021b\u021a")
        buf.write("\3\2\2\2\u021c\u021f\3\2\2\2\u021d\u021b\3\2\2\2\u021d")
        buf.write("\u021e\3\2\2\2\u021e\u0230\3\2\2\2\u021f\u021d\3\2\2\2")
        buf.write("\u0220\u0224\t\t\2\2\u0221\u0223\7m\2\2\u0222\u0221\3")
        buf.write("\2\2\2\u0223\u0226\3\2\2\2\u0224\u0222\3\2\2\2\u0224\u0225")
        buf.write("\3\2\2\2\u0225\u0227\3\2\2\2\u0226\u0224\3\2\2\2\u0227")
        buf.write("\u022b\5\30\r\2\u0228\u022a\7m\2\2\u0229\u0228\3\2\2\2")
        buf.write("\u022a\u022d\3\2\2\2\u022b\u0229\3\2\2\2\u022b\u022c\3")
        buf.write("\2\2\2\u022c\u022f\3\2\2\2\u022d\u022b\3\2\2\2\u022e\u0220")
        buf.write("\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u022e\3\2\2\2\u0230")
        buf.write("\u0231\3\2\2\2\u0231\33\3\2\2\2\u0232\u0230\3\2\2\2\u0233")
        buf.write("\u0237\5\32\16\2\u0234\u0236\7m\2\2\u0235\u0234\3\2\2")
        buf.write("\2\u0236\u0239\3\2\2\2\u0237\u0235\3\2\2\2\u0237\u0238")
        buf.write("\3\2\2\2\u0238\u024a\3\2\2\2\u0239\u0237\3\2\2\2\u023a")
        buf.write("\u023e\t\n\2\2\u023b\u023d\7m\2\2\u023c\u023b\3\2\2\2")
        buf.write("\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023e\u023f\3")
        buf.write("\2\2\2\u023f\u0241\3\2\2\2\u0240\u023e\3\2\2\2\u0241\u0245")
        buf.write("\5\32\16\2\u0242\u0244\7m\2\2\u0243\u0242\3\2\2\2\u0244")
        buf.write("\u0247\3\2\2\2\u0245\u0243\3\2\2\2\u0245\u0246\3\2\2\2")
        buf.write("\u0246\u0249\3\2\2\2\u0247\u0245\3\2\2\2\u0248\u023a\3")
        buf.write("\2\2\2\u0249\u024c\3\2\2\2\u024a\u0248\3\2\2\2\u024a\u024b")
        buf.write("\3\2\2\2\u024b\35\3\2\2\2\u024c\u024a\3\2\2\2\u024d\u0251")
        buf.write("\5\34\17\2\u024e\u0250\7m\2\2\u024f\u024e\3\2\2\2\u0250")
        buf.write("\u0253\3\2\2\2\u0251\u024f\3\2\2\2\u0251\u0252\3\2\2\2")
        buf.write("\u0252\u0264\3\2\2\2\u0253\u0251\3\2\2\2\u0254\u0258\t")
        buf.write("\13\2\2\u0255\u0257\7m\2\2\u0256\u0255\3\2\2\2\u0257\u025a")
        buf.write("\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0259\3\2\2\2\u0259")
        buf.write("\u025b\3\2\2\2\u025a\u0258\3\2\2\2\u025b\u025f\5\34\17")
        buf.write("\2\u025c\u025e\7m\2\2\u025d\u025c\3\2\2\2\u025e\u0261")
        buf.write("\3\2\2\2\u025f\u025d\3\2\2\2\u025f\u0260\3\2\2\2\u0260")
        buf.write("\u0263\3\2\2\2\u0261\u025f\3\2\2\2\u0262\u0254\3\2\2\2")
        buf.write("\u0263\u0266\3\2\2\2\u0264\u0262\3\2\2\2\u0264\u0265\3")
        buf.write("\2\2\2\u0265\37\3\2\2\2\u0266\u0264\3\2\2\2\u0267\u026b")
        buf.write("\5\36\20\2\u0268\u026a\7m\2\2\u0269\u0268\3\2\2\2\u026a")
        buf.write("\u026d\3\2\2\2\u026b\u0269\3\2\2\2\u026b\u026c\3\2\2\2")
        buf.write("\u026c\u027e\3\2\2\2\u026d\u026b\3\2\2\2\u026e\u0272\7")
        buf.write("F\2\2\u026f\u0271\7m\2\2\u0270\u026f\3\2\2\2\u0271\u0274")
        buf.write("\3\2\2\2\u0272\u0270\3\2\2\2\u0272\u0273\3\2\2\2\u0273")
        buf.write("\u0275\3\2\2\2\u0274\u0272\3\2\2\2\u0275\u0279\5\36\20")
        buf.write("\2\u0276\u0278\7m\2\2\u0277\u0276\3\2\2\2\u0278\u027b")
        buf.write("\3\2\2\2\u0279\u0277\3\2\2\2\u0279\u027a\3\2\2\2\u027a")
        buf.write("\u027d\3\2\2\2\u027b\u0279\3\2\2\2\u027c\u026e\3\2\2\2")
        buf.write("\u027d\u0280\3\2\2\2\u027e\u027c\3\2\2\2\u027e\u027f\3")
        buf.write("\2\2\2\u027f!\3\2\2\2\u0280\u027e\3\2\2\2\u0281\u0285")
        buf.write("\5 \21\2\u0282\u0284\7m\2\2\u0283\u0282\3\2\2\2\u0284")
        buf.write("\u0287\3\2\2\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2")
        buf.write("\u0286\u0298\3\2\2\2\u0287\u0285\3\2\2\2\u0288\u028c\7")
        buf.write("J\2\2\u0289\u028b\7m\2\2\u028a\u0289\3\2\2\2\u028b\u028e")
        buf.write("\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d")
        buf.write("\u028f\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0293\5 \21\2")
        buf.write("\u0290\u0292\7m\2\2\u0291\u0290\3\2\2\2\u0292\u0295\3")
        buf.write("\2\2\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294\u0297")
        buf.write("\3\2\2\2\u0295\u0293\3\2\2\2\u0296\u0288\3\2\2\2\u0297")
        buf.write("\u029a\3\2\2\2\u0298\u0296\3\2\2\2\u0298\u0299\3\2\2\2")
        buf.write("\u0299#\3\2\2\2\u029a\u0298\3\2\2\2\u029b\u029f\5\"\22")
        buf.write("\2\u029c\u029e\7m\2\2\u029d\u029c\3\2\2\2\u029e\u02a1")
        buf.write("\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0")
        buf.write("\u02b2\3\2\2\2\u02a1\u029f\3\2\2\2\u02a2\u02a6\7G\2\2")
        buf.write("\u02a3\u02a5\7m\2\2\u02a4\u02a3\3\2\2\2\u02a5\u02a8\3")
        buf.write("\2\2\2\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02a9")
        buf.write("\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a9\u02ad\5\"\22\2\u02aa")
        buf.write("\u02ac\7m\2\2\u02ab\u02aa\3\2\2\2\u02ac\u02af\3\2\2\2")
        buf.write("\u02ad\u02ab\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b1\3")
        buf.write("\2\2\2\u02af\u02ad\3\2\2\2\u02b0\u02a2\3\2\2\2\u02b1\u02b4")
        buf.write("\3\2\2\2\u02b2\u02b0\3\2\2\2\u02b2\u02b3\3\2\2\2\u02b3")
        buf.write("%\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b5\u02b9\5$\23\2\u02b6")
        buf.write("\u02b8\7m\2\2\u02b7\u02b6\3\2\2\2\u02b8\u02bb\3\2\2\2")
        buf.write("\u02b9\u02b7\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02cc\3")
        buf.write("\2\2\2\u02bb\u02b9\3\2\2\2\u02bc\u02c0\7H\2\2\u02bd\u02bf")
        buf.write("\7m\2\2\u02be\u02bd\3\2\2\2\u02bf\u02c2\3\2\2\2\u02c0")
        buf.write("\u02be\3\2\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c3\3\2\2\2")
        buf.write("\u02c2\u02c0\3\2\2\2\u02c3\u02c7\5$\23\2\u02c4\u02c6\7")
        buf.write("m\2\2\u02c5\u02c4\3\2\2\2\u02c6\u02c9\3\2\2\2\u02c7\u02c5")
        buf.write("\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8\u02cb\3\2\2\2\u02c9")
        buf.write("\u02c7\3\2\2\2\u02ca\u02bc\3\2\2\2\u02cb\u02ce\3\2\2\2")
        buf.write("\u02cc\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\'\3\2\2")
        buf.write("\2\u02ce\u02cc\3\2\2\2\u02cf\u02d3\5&\24\2\u02d0\u02d2")
        buf.write("\7m\2\2\u02d1\u02d0\3\2\2\2\u02d2\u02d5\3\2\2\2\u02d3")
        buf.write("\u02d1\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02e6\3\2\2\2")
        buf.write("\u02d5\u02d3\3\2\2\2\u02d6\u02da\7I\2\2\u02d7\u02d9\7")
        buf.write("m\2\2\u02d8\u02d7\3\2\2\2\u02d9\u02dc\3\2\2\2\u02da\u02d8")
        buf.write("\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2\2\2\u02dc")
        buf.write("\u02da\3\2\2\2\u02dd\u02e1\5&\24\2\u02de\u02e0\7m\2\2")
        buf.write("\u02df\u02de\3\2\2\2\u02e0\u02e3\3\2\2\2\u02e1\u02df\3")
        buf.write("\2\2\2\u02e1\u02e2\3\2\2\2\u02e2\u02e5\3\2\2\2\u02e3\u02e1")
        buf.write("\3\2\2\2\u02e4\u02d6\3\2\2\2\u02e5\u02e8\3\2\2\2\u02e6")
        buf.write("\u02e4\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7)\3\2\2\2\u02e8")
        buf.write("\u02e6\3\2\2\2\u02e9\u02ed\5(\25\2\u02ea\u02ec\7m\2\2")
        buf.write("\u02eb\u02ea\3\2\2\2\u02ec\u02ef\3\2\2\2\u02ed\u02eb\3")
        buf.write("\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u030c\3\2\2\2\u02ef\u02ed")
        buf.write("\3\2\2\2\u02f0\u02f4\7O\2\2\u02f1\u02f3\7m\2\2\u02f2\u02f1")
        buf.write("\3\2\2\2\u02f3\u02f6\3\2\2\2\u02f4\u02f2\3\2\2\2\u02f4")
        buf.write("\u02f5\3\2\2\2\u02f5\u02f7\3\2\2\2\u02f6\u02f4\3\2\2\2")
        buf.write("\u02f7\u02fb\5\60\31\2\u02f8\u02fa\7m\2\2\u02f9\u02f8")
        buf.write("\3\2\2\2\u02fa\u02fd\3\2\2\2\u02fb\u02f9\3\2\2\2\u02fb")
        buf.write("\u02fc\3\2\2\2\u02fc\u02fe\3\2\2\2\u02fd\u02fb\3\2\2\2")
        buf.write("\u02fe\u0302\7P\2\2\u02ff\u0301\7m\2\2\u0300\u02ff\3\2")
        buf.write("\2\2\u0301\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303")
        buf.write("\3\2\2\2\u0303\u0305\3\2\2\2\u0304\u0302\3\2\2\2\u0305")
        buf.write("\u0309\5*\26\2\u0306\u0308\7m\2\2\u0307\u0306\3\2\2\2")
        buf.write("\u0308\u030b\3\2\2\2\u0309\u0307\3\2\2\2\u0309\u030a\3")
        buf.write("\2\2\2\u030a\u030d\3\2\2\2\u030b\u0309\3\2\2\2\u030c\u02f0")
        buf.write("\3\2\2\2\u030c\u030d\3\2\2\2\u030d+\3\2\2\2\u030e\u0321")
        buf.write("\5*\26\2\u030f\u0313\5\20\t\2\u0310\u0312\7m\2\2\u0311")
        buf.write("\u0310\3\2\2\2\u0312\u0315\3\2\2\2\u0313\u0311\3\2\2\2")
        buf.write("\u0313\u0314\3\2\2\2\u0314\u0316\3\2\2\2\u0315\u0313\3")
        buf.write("\2\2\2\u0316\u031a\5.\30\2\u0317\u0319\7m\2\2\u0318\u0317")
        buf.write("\3\2\2\2\u0319\u031c\3\2\2\2\u031a\u0318\3\2\2\2\u031a")
        buf.write("\u031b\3\2\2\2\u031b\u031d\3\2\2\2\u031c\u031a\3\2\2\2")
        buf.write("\u031d\u031e\5,\27\2\u031e\u0321\3\2\2\2\u031f\u0321\7")
        buf.write("i\2\2\u0320\u030e\3\2\2\2\u0320\u030f\3\2\2\2\u0320\u031f")
        buf.write("\3\2\2\2\u0321-\3\2\2\2\u0322\u0323\t\f\2\2\u0323/\3\2")
        buf.write("\2\2\u0324\u0328\5,\27\2\u0325\u0327\7m\2\2\u0326\u0325")
        buf.write("\3\2\2\2\u0327\u032a\3\2\2\2\u0328\u0326\3\2\2\2\u0328")
        buf.write("\u0329\3\2\2\2\u0329\u033b\3\2\2\2\u032a\u0328\3\2\2\2")
        buf.write("\u032b\u032f\7R\2\2\u032c\u032e\7m\2\2\u032d\u032c\3\2")
        buf.write("\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3\2\2\2\u032f\u0330")
        buf.write("\3\2\2\2\u0330\u0332\3\2\2\2\u0331\u032f\3\2\2\2\u0332")
        buf.write("\u0336\5,\27\2\u0333\u0335\7m\2\2\u0334\u0333\3\2\2\2")
        buf.write("\u0335\u0338\3\2\2\2\u0336\u0334\3\2\2\2\u0336\u0337\3")
        buf.write("\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2\2\2\u0339\u032b")
        buf.write("\3\2\2\2\u033a\u033d\3\2\2\2\u033b\u0339\3\2\2\2\u033b")
        buf.write("\u033c\3\2\2\2\u033c\61\3\2\2\2\u033d\u033b\3\2\2\2\u033e")
        buf.write("\u033f\5*\26\2\u033f\63\3\2\2\2\u0340\u0344\5\66\34\2")
        buf.write("\u0341\u0343\7m\2\2\u0342\u0341\3\2\2\2\u0343\u0346\3")
        buf.write("\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0348")
        buf.write("\3\2\2\2\u0346\u0344\3\2\2\2\u0347\u0349\5:\36\2\u0348")
        buf.write("\u0347\3\2\2\2\u0348\u0349\3\2\2\2\u0349\u034a\3\2\2\2")
        buf.write("\u034a\u034b\5\u00bc_\2\u034b\u034e\3\2\2\2\u034c\u034e")
        buf.write("\5\u0086D\2\u034d\u0340\3\2\2\2\u034d\u034c\3\2\2\2\u034e")
        buf.write("\65\3\2\2\2\u034f\u0353\58\35\2\u0350\u0352\7m\2\2\u0351")
        buf.write("\u0350\3\2\2\2\u0352\u0355\3\2\2\2\u0353\u0351\3\2\2\2")
        buf.write("\u0353\u0354\3\2\2\2\u0354\u0357\3\2\2\2\u0355\u0353\3")
        buf.write("\2\2\2\u0356\u034f\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0356")
        buf.write("\3\2\2\2\u0358\u0359\3\2\2\2\u0359\67\3\2\2\2\u035a\u0360")
        buf.write("\5> \2\u035b\u0360\5B\"\2\u035c\u0360\5\\/\2\u035d\u0360")
        buf.write("\5^\60\2\u035e\u0360\5`\61\2\u035f\u035a\3\2\2\2\u035f")
        buf.write("\u035b\3\2\2\2\u035f\u035c\3\2\2\2\u035f\u035d\3\2\2\2")
        buf.write("\u035f\u035e\3\2\2\2\u03609\3\2\2\2\u0361\u0365\5<\37")
        buf.write("\2\u0362\u0364\7m\2\2\u0363\u0362\3\2\2\2\u0364\u0367")
        buf.write("\3\2\2\2\u0365\u0363\3\2\2\2\u0365\u0366\3\2\2\2\u0366")
        buf.write("\u0378\3\2\2\2\u0367\u0365\3\2\2\2\u0368\u036c\7R\2\2")
        buf.write("\u0369\u036b\7m\2\2\u036a\u0369\3\2\2\2\u036b\u036e\3")
        buf.write("\2\2\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u036f")
        buf.write("\3\2\2\2\u036e\u036c\3\2\2\2\u036f\u0373\5<\37\2\u0370")
        buf.write("\u0372\7m\2\2\u0371\u0370\3\2\2\2\u0372\u0375\3\2\2\2")
        buf.write("\u0373\u0371\3\2\2\2\u0373\u0374\3\2\2\2\u0374\u0377\3")
        buf.write("\2\2\2\u0375\u0373\3\2\2\2\u0376\u0368\3\2\2\2\u0377\u037a")
        buf.write("\3\2\2\2\u0378\u0376\3\2\2\2\u0378\u0379\3\2\2\2\u0379")
        buf.write(";\3\2\2\2\u037a\u0378\3\2\2\2\u037b\u037f\5b\62\2\u037c")
        buf.write("\u037e\7m\2\2\u037d\u037c\3\2\2\2\u037e\u0381\3\2\2\2")
        buf.write("\u037f\u037d\3\2\2\2\u037f\u0380\3\2\2\2\u0380\u0390\3")
        buf.write("\2\2\2\u0381\u037f\3\2\2\2\u0382\u0386\7S\2\2\u0383\u0385")
        buf.write("\7m\2\2\u0384\u0383\3\2\2\2\u0385\u0388\3\2\2\2\u0386")
        buf.write("\u0384\3\2\2\2\u0386\u0387\3\2\2\2\u0387\u0389\3\2\2\2")
        buf.write("\u0388\u0386\3\2\2\2\u0389\u038d\5|?\2\u038a\u038c\7m")
        buf.write("\2\2\u038b\u038a\3\2\2\2\u038c\u038f\3\2\2\2\u038d\u038b")
        buf.write("\3\2\2\2\u038d\u038e\3\2\2\2\u038e\u0391\3\2\2\2\u038f")
        buf.write("\u038d\3\2\2\2\u0390\u0382\3\2\2\2\u0390\u0391\3\2\2\2")
        buf.write("\u0391=\3\2\2\2\u0392\u0393\t\r\2\2\u0393?\3\2\2\2\u0394")
        buf.write("\u0398\79\2\2\u0395\u0397\7m\2\2\u0396\u0395\3\2\2\2\u0397")
        buf.write("\u039a\3\2\2\2\u0398\u0396\3\2\2\2\u0398\u0399\3\2\2\2")
        buf.write("\u0399\u039c\3\2\2\2\u039a\u0398\3\2\2\2\u039b\u039d\5")
        buf.write("j\66\2\u039c\u039b\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u03a1")
        buf.write("\3\2\2\2\u039e\u03a0\7m\2\2\u039f\u039e\3\2\2\2\u03a0")
        buf.write("\u03a3\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1\u03a2\3\2\2\2")
        buf.write("\u03a2\u03a5\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a4\u03a6\5")
        buf.write(",\27\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03aa")
        buf.write("\3\2\2\2\u03a7\u03a9\7m\2\2\u03a8\u03a7\3\2\2\2\u03a9")
        buf.write("\u03ac\3\2\2\2\u03aa\u03a8\3\2\2\2\u03aa\u03ab\3\2\2\2")
        buf.write("\u03ab\u03ad\3\2\2\2\u03ac\u03aa\3\2\2\2\u03ad\u03ff\7")
        buf.write(":\2\2\u03ae\u03b2\79\2\2\u03af\u03b1\7m\2\2\u03b0\u03af")
        buf.write("\3\2\2\2\u03b1\u03b4\3\2\2\2\u03b2\u03b0\3\2\2\2\u03b2")
        buf.write("\u03b3\3\2\2\2\u03b3\u03b5\3\2\2\2\u03b4\u03b2\3\2\2\2")
        buf.write("\u03b5\u03b9\7\33\2\2\u03b6\u03b8\7m\2\2\u03b7\u03b6\3")
        buf.write("\2\2\2\u03b8\u03bb\3\2\2\2\u03b9\u03b7\3\2\2\2\u03b9\u03ba")
        buf.write("\3\2\2\2\u03ba\u03bd\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bc")
        buf.write("\u03be\5j\66\2\u03bd\u03bc\3\2\2\2\u03bd\u03be\3\2\2\2")
        buf.write("\u03be\u03c2\3\2\2\2\u03bf\u03c1\7m\2\2\u03c0\u03bf\3")
        buf.write("\2\2\2\u03c1\u03c4\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c2\u03c3")
        buf.write("\3\2\2\2\u03c3\u03c5\3\2\2\2\u03c4\u03c2\3\2\2\2\u03c5")
        buf.write("\u03c9\5,\27\2\u03c6\u03c8\7m\2\2\u03c7\u03c6\3\2\2\2")
        buf.write("\u03c8\u03cb\3\2\2\2\u03c9\u03c7\3\2\2\2\u03c9\u03ca\3")
        buf.write("\2\2\2\u03ca\u03cc\3\2\2\2\u03cb\u03c9\3\2\2\2\u03cc\u03cd")
        buf.write("\7:\2\2\u03cd\u03ff\3\2\2\2\u03ce\u03d2\79\2\2\u03cf\u03d1")
        buf.write("\7m\2\2\u03d0\u03cf\3\2\2\2\u03d1\u03d4\3\2\2\2\u03d2")
        buf.write("\u03d0\3\2\2\2\u03d2\u03d3\3\2\2\2\u03d3\u03d5\3\2\2\2")
        buf.write("\u03d4\u03d2\3\2\2\2\u03d5\u03d9\5j\66\2\u03d6\u03d8\7")
        buf.write("m\2\2\u03d7\u03d6\3\2\2\2\u03d8\u03db\3\2\2\2\u03d9\u03d7")
        buf.write("\3\2\2\2\u03d9\u03da\3\2\2\2\u03da\u03dc\3\2\2\2\u03db")
        buf.write("\u03d9\3\2\2\2\u03dc\u03dd\7\33\2\2\u03dd\u03e1\5,\27")
        buf.write("\2\u03de\u03e0\7m\2\2\u03df\u03de\3\2\2\2\u03e0\u03e3")
        buf.write("\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2")
        buf.write("\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\7:\2\2")
        buf.write("\u03e5\u03ff\3\2\2\2\u03e6\u03ea\79\2\2\u03e7\u03e9\7")
        buf.write("m\2\2\u03e8\u03e7\3\2\2\2\u03e9\u03ec\3\2\2\2\u03ea\u03e8")
        buf.write("\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ee\3\2\2\2\u03ec")
        buf.write("\u03ea\3\2\2\2\u03ed\u03ef\5j\66\2\u03ee\u03ed\3\2\2\2")
        buf.write("\u03ee\u03ef\3\2\2\2\u03ef\u03f3\3\2\2\2\u03f0\u03f2\7")
        buf.write("m\2\2\u03f1\u03f0\3\2\2\2\u03f2\u03f5\3\2\2\2\u03f3\u03f1")
        buf.write("\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f6\3\2\2\2\u03f5")
        buf.write("\u03f3\3\2\2\2\u03f6\u03fa\7C\2\2\u03f7\u03f9\7m\2\2\u03f8")
        buf.write("\u03f7\3\2\2\2\u03f9\u03fc\3\2\2\2\u03fa\u03f8\3\2\2\2")
        buf.write("\u03fa\u03fb\3\2\2\2\u03fb\u03fd\3\2\2\2\u03fc\u03fa\3")
        buf.write("\2\2\2\u03fd\u03ff\7:\2\2\u03fe\u0394\3\2\2\2\u03fe\u03ae")
        buf.write("\3\2\2\2\u03fe\u03ce\3\2\2\2\u03fe\u03e6\3\2\2\2\u03ff")
        buf.write("A\3\2\2\2\u0400\u0424\b\"\1\2\u0401\u0425\7\24\2\2\u0402")
        buf.write("\u0425\7\7\2\2\u0403\u0425\7\21\2\2\u0404\u0425\7\r\2")
        buf.write("\2\u0405\u0425\7\22\2\2\u0406\u0425\7\17\2\2\u0407\u0425")
        buf.write("\7\13\2\2\u0408\u0425\7\t\2\2\u0409\u0425\7\20\2\2\u040a")
        buf.write("\u040e\7\16\2\2\u040b\u040d\7m\2\2\u040c\u040b\3\2\2\2")
        buf.write("\u040d\u0410\3\2\2\2\u040e\u040c\3\2\2\2\u040e\u040f\3")
        buf.write("\2\2\2\u040f\u0411\3\2\2\2\u0410\u040e\3\2\2\2\u0411\u0415")
        buf.write("\7`\2\2\u0412\u0414\7m\2\2\u0413\u0412\3\2\2\2\u0414\u0417")
        buf.write("\3\2\2\2\u0415\u0413\3\2\2\2\u0415\u0416\3\2\2\2\u0416")
        buf.write("\u0418\3\2\2\2\u0417\u0415\3\2\2\2\u0418\u041c\5l\67\2")
        buf.write("\u0419\u041b\7m\2\2\u041a\u0419\3\2\2\2\u041b\u041e\3")
        buf.write("\2\2\2\u041c\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u041f")
        buf.write("\3\2\2\2\u041e\u041c\3\2\2\2\u041f\u0420\7b\2\2\u0420")
        buf.write("\u0425\3\2\2\2\u0421\u0425\7\23\2\2\u0422\u0425\7\6\2")
        buf.write("\2\u0423\u0425\7\b\2\2\u0424\u0401\3\2\2\2\u0424\u0402")
        buf.write("\3\2\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424")
        buf.write("\u0405\3\2\2\2\u0424\u0406\3\2\2\2\u0424\u0407\3\2\2\2")
        buf.write("\u0424\u0408\3\2\2\2\u0424\u0409\3\2\2\2\u0424\u040a\3")
        buf.write("\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424\u0423")
        buf.write("\3\2\2\2\u0425\u0429\3\2\2\2\u0426\u0428\5@!\2\u0427\u0426")
        buf.write("\3\2\2\2\u0428\u042b\3\2\2\2\u0429\u0427\3\2\2\2\u0429")
        buf.write("\u042a\3\2\2\2\u042a\u0448\3\2\2\2\u042b\u0429\3\2\2\2")
        buf.write("\u042c\u0448\5Z.\2\u042d\u0448\5D#\2\u042e\u0448\5R*\2")
        buf.write("\u042f\u0448\5z>\2\u0430\u0434\7.\2\2\u0431\u0433\7m\2")
        buf.write("\2\u0432\u0431\3\2\2\2\u0433\u0436\3\2\2\2\u0434\u0432")
        buf.write("\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u0437\3\2\2\2\u0436")
        buf.write("\u0434\3\2\2\2\u0437\u043b\7\67\2\2\u0438\u043a\7m\2\2")
        buf.write("\u0439\u0438\3\2\2\2\u043a\u043d\3\2\2\2\u043b\u0439\3")
        buf.write("\2\2\2\u043b\u043c\3\2\2\2\u043c\u043e\3\2\2\2\u043d\u043b")
        buf.write("\3\2\2\2\u043e\u0442\5\62\32\2\u043f\u0441\7m\2\2\u0440")
        buf.write("\u043f\3\2\2\2\u0441\u0444\3\2\2\2\u0442\u0440\3\2\2\2")
        buf.write("\u0442\u0443\3\2\2\2\u0443\u0445\3\2\2\2\u0444\u0442\3")
        buf.write("\2\2\2\u0445\u0446\78\2\2\u0446\u0448\3\2\2\2\u0447\u0400")
        buf.write("\3\2\2\2\u0447\u042c\3\2\2\2\u0447\u042d\3\2\2\2\u0447")
        buf.write("\u042e\3\2\2\2\u0447\u042f\3\2\2\2\u0447\u0430\3\2\2\2")
        buf.write("\u0448\u0453\3\2\2\2\u0449\u044d\f\3\2\2\u044a\u044c\7")
        buf.write("m\2\2\u044b\u044a\3\2\2\2\u044c\u044f\3\2\2\2\u044d\u044b")
        buf.write("\3\2\2\2\u044d\u044e\3\2\2\2\u044e\u0450\3\2\2\2\u044f")
        buf.write("\u044d\3\2\2\2\u0450\u0452\5h\65\2\u0451\u0449\3\2\2\2")
        buf.write("\u0452\u0455\3\2\2\2\u0453\u0451\3\2\2\2\u0453\u0454\3")
        buf.write("\2\2\2\u0454C\3\2\2\2\u0455\u0453\3\2\2\2\u0456\u045a")
        buf.write("\5F$\2\u0457\u0459\7m\2\2\u0458\u0457\3\2\2\2\u0459\u045c")
        buf.write("\3\2\2\2\u045a\u0458\3\2\2\2\u045a\u045b\3\2\2\2\u045b")
        buf.write("\u0464\3\2\2\2\u045c\u045a\3\2\2\2\u045d\u0461\7g\2\2")
        buf.write("\u045e\u0460\7m\2\2\u045f\u045e\3\2\2\2\u0460\u0463\3")
        buf.write("\2\2\2\u0461\u045f\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0465")
        buf.write("\3\2\2\2\u0463\u0461\3\2\2\2\u0464\u045d\3\2\2\2\u0464")
        buf.write("\u0465\3\2\2\2\u0465\u0466\3\2\2\2\u0466\u046a\7;\2\2")
        buf.write("\u0467\u0469\7m\2\2\u0468\u0467\3\2\2\2\u0469\u046c\3")
        buf.write("\2\2\2\u046a\u0468\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u0470")
        buf.write("\3\2\2\2\u046c\u046a\3\2\2\2\u046d\u046f\5H%\2\u046e\u046d")
        buf.write("\3\2\2\2\u046f\u0472\3\2\2\2\u0470\u046e\3\2\2\2\u0470")
        buf.write("\u0471\3\2\2\2\u0471\u0476\3\2\2\2\u0472\u0470\3\2\2\2")
        buf.write("\u0473\u0475\7m\2\2\u0474\u0473\3\2\2\2\u0475\u0478\3")
        buf.write("\2\2\2\u0476\u0474\3\2\2\2\u0476\u0477\3\2\2\2\u0477\u0479")
        buf.write("\3\2\2\2\u0478\u0476\3\2\2\2\u0479\u047a\7<\2\2\u047a")
        buf.write("\u0485\3\2\2\2\u047b\u047f\5F$\2\u047c\u047e\7m\2\2\u047d")
        buf.write("\u047c\3\2\2\2\u047e\u0481\3\2\2\2\u047f\u047d\3\2\2\2")
        buf.write("\u047f\u0480\3\2\2\2\u0480\u0482\3\2\2\2\u0481\u047f\3")
        buf.write("\2\2\2\u0482\u0483\7g\2\2\u0483\u0485\3\2\2\2\u0484\u0456")
        buf.write("\3\2\2\2\u0484\u047b\3\2\2\2\u0485E\3\2\2\2\u0486\u0487")
        buf.write("\t\16\2\2\u0487G\3\2\2\2\u0488\u048a\7m\2\2\u0489\u0488")
        buf.write("\3\2\2\2\u048a\u048d\3\2\2\2\u048b\u0489\3\2\2\2\u048b")
        buf.write("\u048c\3\2\2\2\u048c\u048e\3\2\2\2\u048d\u048b\3\2\2\2")
        buf.write("\u048e\u0492\5J&\2\u048f\u0491\7m\2\2\u0490\u048f\3\2")
        buf.write("\2\2\u0491\u0494\3\2\2\2\u0492\u0490\3\2\2\2\u0492\u0493")
        buf.write("\3\2\2\2\u0493\u0496\3\2\2\2\u0494\u0492\3\2\2\2\u0495")
        buf.write("\u048b\3\2\2\2\u0496\u0497\3\2\2\2\u0497\u0495\3\2\2\2")
        buf.write("\u0497\u0498\3\2\2\2\u0498I\3\2\2\2\u0499\u049d\5L\'\2")
        buf.write("\u049a\u049c\7m\2\2\u049b\u049a\3\2\2\2\u049c\u049f\3")
        buf.write("\2\2\2\u049d\u049b\3\2\2\2\u049d\u049e\3\2\2\2\u049e\u04a1")
        buf.write("\3\2\2\2\u049f\u049d\3\2\2\2\u04a0\u04a2\5N(\2\u04a1\u04a0")
        buf.write("\3\2\2\2\u04a1\u04a2\3\2\2\2\u04a2\u04a3\3\2\2\2\u04a3")
        buf.write("\u04a4\5\u00bc_\2\u04a4\u04a7\3\2\2\2\u04a5\u04a7\5\u0086")
        buf.write("D\2\u04a6\u0499\3\2\2\2\u04a6\u04a5\3\2\2\2\u04a7K\3\2")
        buf.write("\2\2\u04a8\u04ab\5B\"\2\u04a9\u04ab\5\\/\2\u04aa\u04a8")
        buf.write("\3\2\2\2\u04aa\u04a9\3\2\2\2\u04ab\u04af\3\2\2\2\u04ac")
        buf.write("\u04ae\7m\2\2\u04ad\u04ac\3\2\2\2\u04ae\u04b1\3\2\2\2")
        buf.write("\u04af\u04ad\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b3\3")
        buf.write("\2\2\2\u04b1\u04af\3\2\2\2\u04b2\u04b4\5L\'\2\u04b3\u04b2")
        buf.write("\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4M\3\2\2\2\u04b5\u04b9")
        buf.write("\5P)\2\u04b6\u04b8\7m\2\2\u04b7\u04b6\3\2\2\2\u04b8\u04bb")
        buf.write("\3\2\2\2\u04b9\u04b7\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba")
        buf.write("\u04c6\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bc\u04c0\7R\2\2")
        buf.write("\u04bd\u04bf\7m\2\2\u04be\u04bd\3\2\2\2\u04bf\u04c2\3")
        buf.write("\2\2\2\u04c0\u04be\3\2\2\2\u04c0\u04c1\3\2\2\2\u04c1\u04c3")
        buf.write("\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04c5\5P)\2\u04c4\u04bc")
        buf.write("\3\2\2\2\u04c5\u04c8\3\2\2\2\u04c6\u04c4\3\2\2\2\u04c6")
        buf.write("\u04c7\3\2\2\2\u04c7O\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c9")
        buf.write("\u04dc\5b\62\2\u04ca\u04cc\5b\62\2\u04cb\u04ca\3\2\2\2")
        buf.write("\u04cb\u04cc\3\2\2\2\u04cc\u04d0\3\2\2\2\u04cd\u04cf\7")
        buf.write("m\2\2\u04ce\u04cd\3\2\2\2\u04cf\u04d2\3\2\2\2\u04d0\u04ce")
        buf.write("\3\2\2\2\u04d0\u04d1\3\2\2\2\u04d1\u04d3\3\2\2\2\u04d2")
        buf.write("\u04d0\3\2\2\2\u04d3\u04d7\7P\2\2\u04d4\u04d6\7m\2\2\u04d5")
        buf.write("\u04d4\3\2\2\2\u04d6\u04d9\3\2\2\2\u04d7\u04d5\3\2\2\2")
        buf.write("\u04d7\u04d8\3\2\2\2\u04d8\u04da\3\2\2\2\u04d9\u04d7\3")
        buf.write("\2\2\2\u04da\u04dc\5\62\32\2\u04db\u04c9\3\2\2\2\u04db")
        buf.write("\u04cb\3\2\2\2\u04dcQ\3\2\2\2\u04dd\u04e1\7\'\2\2\u04de")
        buf.write("\u04e0\7m\2\2\u04df\u04de\3\2\2\2\u04e0\u04e3\3\2\2\2")
        buf.write("\u04e1\u04df\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e5\3")
        buf.write("\2\2\2\u04e3\u04e1\3\2\2\2\u04e4\u04e6\7g\2\2\u04e5\u04e4")
        buf.write("\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04ea\3\2\2\2\u04e7")
        buf.write("\u04e9\7m\2\2\u04e8\u04e7\3\2\2\2\u04e9\u04ec\3\2\2\2")
        buf.write("\u04ea\u04e8\3\2\2\2\u04ea\u04eb\3\2\2\2\u04eb\u04ed\3")
        buf.write("\2\2\2\u04ec\u04ea\3\2\2\2\u04ed\u04f1\7;\2\2\u04ee\u04f0")
        buf.write("\7m\2\2\u04ef\u04ee\3\2\2\2\u04f0\u04f3\3\2\2\2\u04f1")
        buf.write("\u04ef\3\2\2\2\u04f1\u04f2\3\2\2\2\u04f2\u04f4\3\2\2\2")
        buf.write("\u04f3\u04f1\3\2\2\2\u04f4\u04f8\5T+\2\u04f5\u04f7\7m")
        buf.write("\2\2\u04f6\u04f5\3\2\2\2\u04f7\u04fa\3\2\2\2\u04f8\u04f6")
        buf.write("\3\2\2\2\u04f8\u04f9\3\2\2\2\u04f9\u04fc\3\2\2\2\u04fa")
        buf.write("\u04f8\3\2\2\2\u04fb\u04fd\7R\2\2\u04fc\u04fb\3\2\2\2")
        buf.write("\u04fc\u04fd\3\2\2\2\u04fd\u0501\3\2\2\2\u04fe\u0500\7")
        buf.write("m\2\2\u04ff\u04fe\3\2\2\2\u0500\u0503\3\2\2\2\u0501\u04ff")
        buf.write("\3\2\2\2\u0501\u0502\3\2\2\2\u0502\u0504\3\2\2\2\u0503")
        buf.write("\u0501\3\2\2\2\u0504\u0505\7<\2\2\u0505\u050f\3\2\2\2")
        buf.write("\u0506\u050a\7\'\2\2\u0507\u0509\7m\2\2\u0508\u0507\3")
        buf.write("\2\2\2\u0509\u050c\3\2\2\2\u050a\u0508\3\2\2\2\u050a\u050b")
        buf.write("\3\2\2\2\u050b\u050d\3\2\2\2\u050c\u050a\3\2\2\2\u050d")
        buf.write("\u050f\7g\2\2\u050e\u04dd\3\2\2\2\u050e\u0506\3\2\2\2")
        buf.write("\u050fS\3\2\2\2\u0510\u0514\5V,\2\u0511\u0513\7m\2\2\u0512")
        buf.write("\u0511\3\2\2\2\u0513\u0516\3\2\2\2\u0514\u0512\3\2\2\2")
        buf.write("\u0514\u0515\3\2\2\2\u0515\u0527\3\2\2\2\u0516\u0514\3")
        buf.write("\2\2\2\u0517\u051b\7R\2\2\u0518\u051a\7m\2\2\u0519\u0518")
        buf.write("\3\2\2\2\u051a\u051d\3\2\2\2\u051b\u0519\3\2\2\2\u051b")
        buf.write("\u051c\3\2\2\2\u051c\u051e\3\2\2\2\u051d\u051b\3\2\2\2")
        buf.write("\u051e\u0522\5V,\2\u051f\u0521\7m\2\2\u0520\u051f\3\2")
        buf.write("\2\2\u0521\u0524\3\2\2\2\u0522\u0520\3\2\2\2\u0522\u0523")
        buf.write("\3\2\2\2\u0523\u0526\3\2\2\2\u0524\u0522\3\2\2\2\u0525")
        buf.write("\u0517\3\2\2\2\u0526\u0529\3\2\2\2\u0527\u0525\3\2\2\2")
        buf.write("\u0527\u0528\3\2\2\2\u0528U\3\2\2\2\u0529\u0527\3\2\2")
        buf.write("\2\u052a\u052e\5X-\2\u052b\u052d\7m\2\2\u052c\u052b\3")
        buf.write("\2\2\2\u052d\u0530\3\2\2\2\u052e\u052c\3\2\2\2\u052e\u052f")
        buf.write("\3\2\2\2\u052f\u053f\3\2\2\2\u0530\u052e\3\2\2\2\u0531")
        buf.write("\u0535\7S\2\2\u0532\u0534\7m\2\2\u0533\u0532\3\2\2\2\u0534")
        buf.write("\u0537\3\2\2\2\u0535\u0533\3\2\2\2\u0535\u0536\3\2\2\2")
        buf.write("\u0536\u0538\3\2\2\2\u0537\u0535\3\2\2\2\u0538\u053c\5")
        buf.write("\62\32\2\u0539\u053b\7m\2\2\u053a\u0539\3\2\2\2\u053b")
        buf.write("\u053e\3\2\2\2\u053c\u053a\3\2\2\2\u053c\u053d\3\2\2\2")
        buf.write("\u053d\u0540\3\2\2\2\u053e\u053c\3\2\2\2\u053f\u0531\3")
        buf.write("\2\2\2\u053f\u0540\3\2\2\2\u0540W\3\2\2\2\u0541\u0542")
        buf.write("\7g\2\2\u0542Y\3\2\2\2\u0543\u0547\7\27\2\2\u0544\u0546")
        buf.write("\7m\2\2\u0545\u0544\3\2\2\2\u0546\u0549\3\2\2\2\u0547")
        buf.write("\u0545\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u054a\3\2\2\2")
        buf.write("\u0549\u0547\3\2\2\2\u054a\u054e\7\67\2\2\u054b\u054d")
        buf.write("\7m\2\2\u054c\u054b\3\2\2\2\u054d\u0550\3\2\2\2\u054e")
        buf.write("\u054c\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0551\3\2\2\2")
        buf.write("\u0550\u054e\3\2\2\2\u0551\u0555\5t;\2\u0552\u0554\7m")
        buf.write("\2\2\u0553\u0552\3\2\2\2\u0554\u0557\3\2\2\2\u0555\u0553")
        buf.write("\3\2\2\2\u0555\u0556\3\2\2\2\u0556\u0558\3\2\2\2\u0557")
        buf.write("\u0555\3\2\2\2\u0558\u055c\78\2\2\u0559\u055b\7m\2\2\u055a")
        buf.write("\u0559\3\2\2\2\u055b\u055e\3\2\2\2\u055c\u055a\3\2\2\2")
        buf.write("\u055c\u055d\3\2\2\2\u055d[\3\2\2\2\u055e\u055c\3\2\2")
        buf.write("\2\u055f\u0560\t\17\2\2\u0560]\3\2\2\2\u0561\u0562\t\20")
        buf.write("\2\2\u0562_\3\2\2\2\u0563\u0567\7\61\2\2\u0564\u0566\7")
        buf.write("m\2\2\u0565\u0564\3\2\2\2\u0566\u0569\3\2\2\2\u0567\u0565")
        buf.write("\3\2\2\2\u0567\u0568\3\2\2\2\u0568\u056a\3\2\2\2\u0569")
        buf.write("\u0567\3\2\2\2\u056a\u056e\7\67\2\2\u056b\u056d\7m\2\2")
        buf.write("\u056c\u056b\3\2\2\2\u056d\u0570\3\2\2\2\u056e\u056c\3")
        buf.write("\2\2\2\u056e\u056f\3\2\2\2\u056f\u0573\3\2\2\2\u0570\u056e")
        buf.write("\3\2\2\2\u0571\u0574\5t;\2\u0572\u0574\5\62\32\2\u0573")
        buf.write("\u0571\3\2\2\2\u0573\u0572\3\2\2\2\u0574\u0578\3\2\2\2")
        buf.write("\u0575\u0577\7m\2\2\u0576\u0575\3\2\2\2\u0577\u057a\3")
        buf.write("\2\2\2\u0578\u0576\3\2\2\2\u0578\u0579\3\2\2\2\u0579\u057b")
        buf.write("\3\2\2\2\u057a\u0578\3\2\2\2\u057b\u057c\78\2\2\u057c")
        buf.write("a\3\2\2\2\u057d\u057f\5h\65\2\u057e\u057d\3\2\2\2\u057e")
        buf.write("\u057f\3\2\2\2\u057f\u0583\3\2\2\2\u0580\u0582\7m\2\2")
        buf.write("\u0581\u0580\3\2\2\2\u0582\u0585\3\2\2\2\u0583\u0581\3")
        buf.write("\2\2\2\u0583\u0584\3\2\2\2\u0584\u0586\3\2\2\2\u0585\u0583")
        buf.write("\3\2\2\2\u0586\u0587\5d\63\2\u0587c\3\2\2\2\u0588\u0589")
        buf.write("\b\63\1\2\u0589\u05ca\7g\2\2\u058a\u058e\7\67\2\2\u058b")
        buf.write("\u058d\7m\2\2\u058c\u058b\3\2\2\2\u058d\u0590\3\2\2\2")
        buf.write("\u058e\u058c\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0591\3")
        buf.write("\2\2\2\u0590\u058e\3\2\2\2\u0591\u0595\5b\62\2\u0592\u0594")
        buf.write("\7m\2\2\u0593\u0592\3\2\2\2\u0594\u0597\3\2\2\2\u0595")
        buf.write("\u0593\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0598\3\2\2\2")
        buf.write("\u0597\u0595\3\2\2\2\u0598\u0599\78\2\2\u0599\u05ca\3")
        buf.write("\2\2\2\u059a\u059e\7g\2\2\u059b\u059d\7m\2\2\u059c\u059b")
        buf.write("\3\2\2\2\u059d\u05a0\3\2\2\2\u059e\u059c\3\2\2\2\u059e")
        buf.write("\u059f\3\2\2\2\u059f\u05a1\3\2\2\2\u05a0\u059e\3\2\2\2")
        buf.write("\u05a1\u05a5\7P\2\2\u05a2\u05a4\7m\2\2\u05a3\u05a2\3\2")
        buf.write("\2\2\u05a4\u05a7\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a6")
        buf.write("\3\2\2\2\u05a6\u05a8\3\2\2\2\u05a7\u05a5\3\2\2\2\u05a8")
        buf.write("\u05ca\7i\2\2\u05a9\u05ad\7\67\2\2\u05aa\u05ac\7m\2\2")
        buf.write("\u05ab\u05aa\3\2\2\2\u05ac\u05af\3\2\2\2\u05ad\u05ab\3")
        buf.write("\2\2\2\u05ad\u05ae\3\2\2\2\u05ae\u05b1\3\2\2\2\u05af\u05ad")
        buf.write("\3\2\2\2\u05b0\u05b2\5B\"\2\u05b1\u05b0\3\2\2\2\u05b1")
        buf.write("\u05b2\3\2\2\2\u05b2\u05b6\3\2\2\2\u05b3\u05b5\7m\2\2")
        buf.write("\u05b4\u05b3\3\2\2\2\u05b5\u05b8\3\2\2\2\u05b6\u05b4\3")
        buf.write("\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05b9\3\2\2\2\u05b8\u05b6")
        buf.write("\3\2\2\2\u05b9\u05bd\5h\65\2\u05ba\u05bc\7m\2\2\u05bb")
        buf.write("\u05ba\3\2\2\2\u05bc\u05bf\3\2\2\2\u05bd\u05bb\3\2\2\2")
        buf.write("\u05bd\u05be\3\2\2\2\u05be\u05c0\3\2\2\2\u05bf\u05bd\3")
        buf.write("\2\2\2\u05c0\u05c4\5d\63\2\u05c1\u05c3\7m\2\2\u05c2\u05c1")
        buf.write("\3\2\2\2\u05c3\u05c6\3\2\2\2\u05c4\u05c2\3\2\2\2\u05c4")
        buf.write("\u05c5\3\2\2\2\u05c5\u05c7\3\2\2\2\u05c6\u05c4\3\2\2\2")
        buf.write("\u05c7\u05c8\78\2\2\u05c8\u05ca\3\2\2\2\u05c9\u0588\3")
        buf.write("\2\2\2\u05c9\u058a\3\2\2\2\u05c9\u059a\3\2\2\2\u05c9\u05a9")
        buf.write("\3\2\2\2\u05ca\u05fc\3\2\2\2\u05cb\u05cf\f\6\2\2\u05cc")
        buf.write("\u05ce\7m\2\2\u05cd\u05cc\3\2\2\2\u05ce\u05d1\3\2\2\2")
        buf.write("\u05cf\u05cd\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u05d2\3")
        buf.write("\2\2\2\u05d1\u05cf\3\2\2\2\u05d2\u05d6\7\67\2\2\u05d3")
        buf.write("\u05d5\7m\2\2\u05d4\u05d3\3\2\2\2\u05d5\u05d8\3\2\2\2")
        buf.write("\u05d6\u05d4\3\2\2\2\u05d6\u05d7\3\2\2\2\u05d7\u05d9\3")
        buf.write("\2\2\2\u05d8\u05d6\3\2\2\2\u05d9\u05dd\5l\67\2\u05da\u05dc")
        buf.write("\7m\2\2\u05db\u05da\3\2\2\2\u05dc\u05df\3\2\2\2\u05dd")
        buf.write("\u05db\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u05e0\3\2\2\2")
        buf.write("\u05df\u05dd\3\2\2\2\u05e0\u05e1\78\2\2\u05e1\u05fb\3")
        buf.write("\2\2\2\u05e2\u05e6\f\5\2\2\u05e3\u05e5\7m\2\2\u05e4\u05e3")
        buf.write("\3\2\2\2\u05e5\u05e8\3\2\2\2\u05e6\u05e4\3\2\2\2\u05e6")
        buf.write("\u05e7\3\2\2\2\u05e7\u05e9\3\2\2\2\u05e8\u05e6\3\2\2\2")
        buf.write("\u05e9\u05ed\7\67\2\2\u05ea\u05ec\7m\2\2\u05eb\u05ea\3")
        buf.write("\2\2\2\u05ec\u05ef\3\2\2\2\u05ed\u05eb\3\2\2\2\u05ed\u05ee")
        buf.write("\3\2\2\2\u05ee\u05f1\3\2\2\2\u05ef\u05ed\3\2\2\2\u05f0")
        buf.write("\u05f2\5r:\2\u05f1\u05f0\3\2\2\2\u05f1\u05f2\3\2\2\2\u05f2")
        buf.write("\u05f6\3\2\2\2\u05f3\u05f5\7m\2\2\u05f4\u05f3\3\2\2\2")
        buf.write("\u05f5\u05f8\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f6\u05f7\3")
        buf.write("\2\2\2\u05f7\u05f9\3\2\2\2\u05f8\u05f6\3\2\2\2\u05f9\u05fb")
        buf.write("\78\2\2\u05fa\u05cb\3\2\2\2\u05fa\u05e2\3\2\2\2\u05fb")
        buf.write("\u05fe\3\2\2\2\u05fc\u05fa\3\2\2\2\u05fc\u05fd\3\2\2\2")
        buf.write("\u05fde\3\2\2\2\u05fe\u05fc\3\2\2\2\u05ff\u0611\n\21\2")
        buf.write("\2\u0600\u0604\7\67\2\2\u0601\u0603\7m\2\2\u0602\u0601")
        buf.write("\3\2\2\2\u0603\u0606\3\2\2\2\u0604\u0602\3\2\2\2\u0604")
        buf.write("\u0605\3\2\2\2\u0605\u0607\3\2\2\2\u0606\u0604\3\2\2\2")
        buf.write("\u0607\u060b\5f\64\2\u0608\u060a\7m\2\2\u0609\u0608\3")
        buf.write("\2\2\2\u060a\u060d\3\2\2\2\u060b\u0609\3\2\2\2\u060b\u060c")
        buf.write("\3\2\2\2\u060c\u060e\3\2\2\2\u060d\u060b\3\2\2\2\u060e")
        buf.write("\u060f\78\2\2\u060f\u0611\3\2\2\2\u0610\u05ff\3\2\2\2")
        buf.write("\u0610\u0600\3\2\2\2\u0611\u0614\3\2\2\2\u0612\u0610\3")
        buf.write("\2\2\2\u0612\u0613\3\2\2\2\u0613g\3\2\2\2\u0614\u0612")
        buf.write("\3\2\2\2\u0615\u0619\t\22\2\2\u0616\u0618\7m\2\2\u0617")
        buf.write("\u0616\3\2\2\2\u0618\u061b\3\2\2\2\u0619\u0617\3\2\2\2")
        buf.write("\u0619\u061a\3\2\2\2\u061a\u061d\3\2\2\2\u061b\u0619\3")
        buf.write("\2\2\2\u061c\u061e\5j\66\2\u061d\u061c\3\2\2\2\u061d\u061e")
        buf.write("\3\2\2\2\u061e\u0622\3\2\2\2\u061f\u0621\7m\2\2\u0620")
        buf.write("\u061f\3\2\2\2\u0621\u0624\3\2\2\2\u0622\u0620\3\2\2\2")
        buf.write("\u0622\u0623\3\2\2\2\u0623\u0626\3\2\2\2\u0624\u0622\3")
        buf.write("\2\2\2\u0625\u0615\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0625")
        buf.write("\3\2\2\2\u0627\u0628\3\2\2\2\u0628i\3\2\2\2\u0629\u062b")
        buf.write("\5\\/\2\u062a\u0629\3\2\2\2\u062b\u062c\3\2\2\2\u062c")
        buf.write("\u062a\3\2\2\2\u062c\u062d\3\2\2\2\u062dk\3\2\2\2\u062e")
        buf.write("\u0632\5n8\2\u062f\u0631\7m\2\2\u0630\u062f\3\2\2\2\u0631")
        buf.write("\u0634\3\2\2\2\u0632\u0630\3\2\2\2\u0632\u0633\3\2\2\2")
        buf.write("\u0633\u0643\3\2\2\2\u0634\u0632\3\2\2\2\u0635\u0639\7")
        buf.write("R\2\2\u0636\u0638\7m\2\2\u0637\u0636\3\2\2\2\u0638\u063b")
        buf.write("\3\2\2\2\u0639\u0637\3\2\2\2\u0639\u063a\3\2\2\2\u063a")
        buf.write("\u063c\3\2\2\2\u063b\u0639\3\2\2\2\u063c\u0640\7f\2\2")
        buf.write("\u063d\u063f\7m\2\2\u063e\u063d\3\2\2\2\u063f\u0642\3")
        buf.write("\2\2\2\u0640\u063e\3\2\2\2\u0640\u0641\3\2\2\2\u0641\u0644")
        buf.write("\3\2\2\2\u0642\u0640\3\2\2\2\u0643\u0635\3\2\2\2\u0643")
        buf.write("\u0644\3\2\2\2\u0644m\3\2\2\2\u0645\u0649\5p9\2\u0646")
        buf.write("\u0648\7m\2\2\u0647\u0646\3\2\2\2\u0648\u064b\3\2\2\2")
        buf.write("\u0649\u0647\3\2\2\2\u0649\u064a\3\2\2\2\u064a\u065c\3")
        buf.write("\2\2\2\u064b\u0649\3\2\2\2\u064c\u0650\7R\2\2\u064d\u064f")
        buf.write("\7m\2\2\u064e\u064d\3\2\2\2\u064f\u0652\3\2\2\2\u0650")
        buf.write("\u064e\3\2\2\2\u0650\u0651\3\2\2\2\u0651\u0653\3\2\2\2")
        buf.write("\u0652\u0650\3\2\2\2\u0653\u0657\5p9\2\u0654\u0656\7m")
        buf.write("\2\2\u0655\u0654\3\2\2\2\u0656\u0659\3\2\2\2\u0657\u0655")
        buf.write("\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u065b\3\2\2\2\u0659")
        buf.write("\u0657\3\2\2\2\u065a\u064c\3\2\2\2\u065b\u065e\3\2\2\2")
        buf.write("\u065c\u065a\3\2\2\2\u065c\u065d\3\2\2\2\u065do\3\2\2")
        buf.write("\2\u065e\u065c\3\2\2\2\u065f\u0663\5\66\34\2\u0660\u0662")
        buf.write("\7m\2\2\u0661\u0660\3\2\2\2\u0662\u0665\3\2\2\2\u0663")
        buf.write("\u0661\3\2\2\2\u0663\u0664\3\2\2\2\u0664\u0666\3\2\2\2")
        buf.write("\u0665\u0663\3\2\2\2\u0666\u0667\5b\62\2\u0667\u0673\3")
        buf.write("\2\2\2\u0668\u066c\5\66\34\2\u0669\u066b\7m\2\2\u066a")
        buf.write("\u0669\3\2\2\2\u066b\u066e\3\2\2\2\u066c\u066a\3\2\2\2")
        buf.write("\u066c\u066d\3\2\2\2\u066d\u0670\3\2\2\2\u066e\u066c\3")
        buf.write("\2\2\2\u066f\u0671\5v<\2\u0670\u066f\3\2\2\2\u0670\u0671")
        buf.write("\3\2\2\2\u0671\u0673\3\2\2\2\u0672\u065f\3\2\2\2\u0672")
        buf.write("\u0668\3\2\2\2\u0673q\3\2\2\2\u0674\u0678\7g\2\2\u0675")
        buf.write("\u0677\7m\2\2\u0676\u0675\3\2\2\2\u0677\u067a\3\2\2\2")
        buf.write("\u0678\u0676\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u068b\3")
        buf.write("\2\2\2\u067a\u0678\3\2\2\2\u067b\u067f\7R\2\2\u067c\u067e")
        buf.write("\7m\2\2\u067d\u067c\3\2\2\2\u067e\u0681\3\2\2\2\u067f")
        buf.write("\u067d\3\2\2\2\u067f\u0680\3\2\2\2\u0680\u0682\3\2\2\2")
        buf.write("\u0681\u067f\3\2\2\2\u0682\u0686\7g\2\2\u0683\u0685\7")
        buf.write("m\2\2\u0684\u0683\3\2\2\2\u0685\u0688\3\2\2\2\u0686\u0684")
        buf.write("\3\2\2\2\u0686\u0687\3\2\2\2\u0687\u068a\3\2\2\2\u0688")
        buf.write("\u0686\3\2\2\2\u0689\u067b\3\2\2\2\u068a\u068d\3\2\2\2")
        buf.write("\u068b\u0689\3\2\2\2\u068b\u068c\3\2\2\2\u068cs\3\2\2")
        buf.write("\2\u068d\u068b\3\2\2\2\u068e\u0692\5L\'\2\u068f\u0691")
        buf.write("\7m\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692")
        buf.write("\u0690\3\2\2\2\u0692\u0693\3\2\2\2\u0693\u0696\3\2\2\2")
        buf.write("\u0694\u0692\3\2\2\2\u0695\u0697\5v<\2\u0696\u0695\3\2")
        buf.write("\2\2\u0696\u0697\3\2\2\2\u0697u\3\2\2\2\u0698\u06a4\5")
        buf.write("h\65\2\u0699\u069b\5h\65\2\u069a\u0699\3\2\2\2\u069a\u069b")
        buf.write("\3\2\2\2\u069b\u069f\3\2\2\2\u069c\u069e\7m\2\2\u069d")
        buf.write("\u069c\3\2\2\2\u069e\u06a1\3\2\2\2\u069f\u069d\3\2\2\2")
        buf.write("\u069f\u06a0\3\2\2\2\u06a0\u06a2\3\2\2\2\u06a1\u069f\3")
        buf.write("\2\2\2\u06a2\u06a4\5x=\2\u06a3\u0698\3\2\2\2\u06a3\u069a")
        buf.write("\3\2\2\2\u06a4w\3\2\2\2\u06a5\u06a6\b=\1\2\u06a6\u06aa")
        buf.write("\7\67\2\2\u06a7\u06a9\7m\2\2\u06a8\u06a7\3\2\2\2\u06a9")
        buf.write("\u06ac\3\2\2\2\u06aa\u06a8\3\2\2\2\u06aa\u06ab\3\2\2\2")
        buf.write("\u06ab\u06ad\3\2\2\2\u06ac\u06aa\3\2\2\2\u06ad\u06b1\5")
        buf.write("v<\2\u06ae\u06b0\7m\2\2\u06af\u06ae\3\2\2\2\u06b0\u06b3")
        buf.write("\3\2\2\2\u06b1\u06af\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2")
        buf.write("\u06b4\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b4\u06b5\78\2\2")
        buf.write("\u06b5\u072f\3\2\2\2\u06b6\u06ba\79\2\2\u06b7\u06b9\7")
        buf.write("m\2\2\u06b8\u06b7\3\2\2\2\u06b9\u06bc\3\2\2\2\u06ba\u06b8")
        buf.write("\3\2\2\2\u06ba\u06bb\3\2\2\2\u06bb\u06be\3\2\2\2\u06bc")
        buf.write("\u06ba\3\2\2\2\u06bd\u06bf\5j\66\2\u06be\u06bd\3\2\2\2")
        buf.write("\u06be\u06bf\3\2\2\2\u06bf\u06c3\3\2\2\2\u06c0\u06c2\7")
        buf.write("m\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1")
        buf.write("\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5")
        buf.write("\u06c3\3\2\2\2\u06c6\u06c8\5,\27\2\u06c7\u06c6\3\2\2\2")
        buf.write("\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2\2\2\u06c9\u06cb\7")
        buf.write("m\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc\u06ca")
        buf.write("\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06cf\3\2\2\2\u06ce")
        buf.write("\u06cc\3\2\2\2\u06cf\u072f\7:\2\2\u06d0\u06d4\79\2\2\u06d1")
        buf.write("\u06d3\7m\2\2\u06d2\u06d1\3\2\2\2\u06d3\u06d6\3\2\2\2")
        buf.write("\u06d4\u06d2\3\2\2\2\u06d4\u06d5\3\2\2\2\u06d5\u06d7\3")
        buf.write("\2\2\2\u06d6\u06d4\3\2\2\2\u06d7\u06db\7\33\2\2\u06d8")
        buf.write("\u06da\7m\2\2\u06d9\u06d8\3\2\2\2\u06da\u06dd\3\2\2\2")
        buf.write("\u06db\u06d9\3\2\2\2\u06db\u06dc\3\2\2\2\u06dc\u06df\3")
        buf.write("\2\2\2\u06dd\u06db\3\2\2\2\u06de\u06e0\5j\66\2\u06df\u06de")
        buf.write("\3\2\2\2\u06df\u06e0\3\2\2\2\u06e0\u06e4\3\2\2\2\u06e1")
        buf.write("\u06e3\7m\2\2\u06e2\u06e1\3\2\2\2\u06e3\u06e6\3\2\2\2")
        buf.write("\u06e4\u06e2\3\2\2\2\u06e4\u06e5\3\2\2\2\u06e5\u06e7\3")
        buf.write("\2\2\2\u06e6\u06e4\3\2\2\2\u06e7\u06eb\5,\27\2\u06e8\u06ea")
        buf.write("\7m\2\2\u06e9\u06e8\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb")
        buf.write("\u06e9\3\2\2\2\u06eb\u06ec\3\2\2\2\u06ec\u06ee\3\2\2\2")
        buf.write("\u06ed\u06eb\3\2\2\2\u06ee\u06ef\7:\2\2\u06ef\u072f\3")
        buf.write("\2\2\2\u06f0\u06f4\79\2\2\u06f1\u06f3\7m\2\2\u06f2\u06f1")
        buf.write("\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4\u06f2\3\2\2\2\u06f4")
        buf.write("\u06f5\3\2\2\2\u06f5\u06f7\3\2\2\2\u06f6\u06f4\3\2\2\2")
        buf.write("\u06f7\u06fb\5j\66\2\u06f8\u06fa\7m\2\2\u06f9\u06f8\3")
        buf.write("\2\2\2\u06fa\u06fd\3\2\2\2\u06fb\u06f9\3\2\2\2\u06fb\u06fc")
        buf.write("\3\2\2\2\u06fc\u06fe\3\2\2\2\u06fd\u06fb\3\2\2\2\u06fe")
        buf.write("\u0702\7\33\2\2\u06ff\u0701\7m\2\2\u0700\u06ff\3\2\2\2")
        buf.write("\u0701\u0704\3\2\2\2\u0702\u0700\3\2\2\2\u0702\u0703\3")
        buf.write("\2\2\2\u0703\u0705\3\2\2\2\u0704\u0702\3\2\2\2\u0705\u0709")
        buf.write("\5,\27\2\u0706\u0708\7m\2\2\u0707\u0706\3\2\2\2\u0708")
        buf.write("\u070b\3\2\2\2\u0709\u0707\3\2\2\2\u0709\u070a\3\2\2\2")
        buf.write("\u070a\u070c\3\2\2\2\u070b\u0709\3\2\2\2\u070c\u070d\7")
        buf.write(":\2\2\u070d\u072f\3\2\2\2\u070e\u0712\79\2\2\u070f\u0711")
        buf.write("\7m\2\2\u0710\u070f\3\2\2\2\u0711\u0714\3\2\2\2\u0712")
        buf.write("\u0710\3\2\2\2\u0712\u0713\3\2\2\2\u0713\u0715\3\2\2\2")
        buf.write("\u0714\u0712\3\2\2\2\u0715\u0719\7C\2\2\u0716\u0718\7")
        buf.write("m\2\2\u0717\u0716\3\2\2\2\u0718\u071b\3\2\2\2\u0719\u0717")
        buf.write("\3\2\2\2\u0719\u071a\3\2\2\2\u071a\u071c\3\2\2\2\u071b")
        buf.write("\u0719\3\2\2\2\u071c\u072f\7:\2\2\u071d\u0721\7\67\2\2")
        buf.write("\u071e\u0720\7m\2\2\u071f\u071e\3\2\2\2\u0720\u0723\3")
        buf.write("\2\2\2\u0721\u071f\3\2\2\2\u0721\u0722\3\2\2\2\u0722\u0725")
        buf.write("\3\2\2\2\u0723\u0721\3\2\2\2\u0724\u0726\5l\67\2\u0725")
        buf.write("\u0724\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u072a\3\2\2\2")
        buf.write("\u0727\u0729\7m\2\2\u0728\u0727\3\2\2\2\u0729\u072c\3")
        buf.write("\2\2\2\u072a\u0728\3\2\2\2\u072a\u072b\3\2\2\2\u072b\u072d")
        buf.write("\3\2\2\2\u072c\u072a\3\2\2\2\u072d\u072f\78\2\2\u072e")
        buf.write("\u06a5\3\2\2\2\u072e\u06b6\3\2\2\2\u072e\u06d0\3\2\2\2")
        buf.write("\u072e\u06f0\3\2\2\2\u072e\u070e\3\2\2\2\u072e\u071d\3")
        buf.write("\2\2\2\u072f\u07cd\3\2\2\2\u0730\u0734\f\7\2\2\u0731\u0733")
        buf.write("\7m\2\2\u0732\u0731\3\2\2\2\u0733\u0736\3\2\2\2\u0734")
        buf.write("\u0732\3\2\2\2\u0734\u0735\3\2\2\2\u0735\u0737\3\2\2\2")
        buf.write("\u0736\u0734\3\2\2\2\u0737\u073b\79\2\2\u0738\u073a\7")
        buf.write("m\2\2\u0739\u0738\3\2\2\2\u073a\u073d\3\2\2\2\u073b\u0739")
        buf.write("\3\2\2\2\u073b\u073c\3\2\2\2\u073c\u073f\3\2\2\2\u073d")
        buf.write("\u073b\3\2\2\2\u073e\u0740\5j\66\2\u073f\u073e\3\2\2\2")
        buf.write("\u073f\u0740\3\2\2\2\u0740\u0744\3\2\2\2\u0741\u0743\7")
        buf.write("m\2\2\u0742\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742")
        buf.write("\3\2\2\2\u0744\u0745\3\2\2\2\u0745\u0748\3\2\2\2\u0746")
        buf.write("\u0744\3\2\2\2\u0747\u0749\5,\27\2\u0748\u0747\3\2\2\2")
        buf.write("\u0748\u0749\3\2\2\2\u0749\u074d\3\2\2\2\u074a\u074c\7")
        buf.write("m\2\2\u074b\u074a\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b")
        buf.write("\3\2\2\2\u074d\u074e\3\2\2\2\u074e\u0750\3\2\2\2\u074f")
        buf.write("\u074d\3\2\2\2\u0750\u07cc\7:\2\2\u0751\u0755\f\6\2\2")
        buf.write("\u0752\u0754\7m\2\2\u0753\u0752\3\2\2\2\u0754\u0757\3")
        buf.write("\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758")
        buf.write("\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075c\79\2\2\u0759")
        buf.write("\u075b\7m\2\2\u075a\u0759\3\2\2\2\u075b\u075e\3\2\2\2")
        buf.write("\u075c\u075a\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u075f\3")
        buf.write("\2\2\2\u075e\u075c\3\2\2\2\u075f\u0763\7\33\2\2\u0760")
        buf.write("\u0762\7m\2\2\u0761\u0760\3\2\2\2\u0762\u0765\3\2\2\2")
        buf.write("\u0763\u0761\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0767\3")
        buf.write("\2\2\2\u0765\u0763\3\2\2\2\u0766\u0768\5j\66\2\u0767\u0766")
        buf.write("\3\2\2\2\u0767\u0768\3\2\2\2\u0768\u076c\3\2\2\2\u0769")
        buf.write("\u076b\7m\2\2\u076a\u0769\3\2\2\2\u076b\u076e\3\2\2\2")
        buf.write("\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u076f\3")
        buf.write("\2\2\2\u076e\u076c\3\2\2\2\u076f\u0773\5,\27\2\u0770\u0772")
        buf.write("\7m\2\2\u0771\u0770\3\2\2\2\u0772\u0775\3\2\2\2\u0773")
        buf.write("\u0771\3\2\2\2\u0773\u0774\3\2\2\2\u0774\u0776\3\2\2\2")
        buf.write("\u0775\u0773\3\2\2\2\u0776\u0777\7:\2\2\u0777\u07cc\3")
        buf.write("\2\2\2\u0778\u077c\f\5\2\2\u0779\u077b\7m\2\2\u077a\u0779")
        buf.write("\3\2\2\2\u077b\u077e\3\2\2\2\u077c\u077a\3\2\2\2\u077c")
        buf.write("\u077d\3\2\2\2\u077d\u077f\3\2\2\2\u077e\u077c\3\2\2\2")
        buf.write("\u077f\u0783\79\2\2\u0780\u0782\7m\2\2\u0781\u0780\3\2")
        buf.write("\2\2\u0782\u0785\3\2\2\2\u0783\u0781\3\2\2\2\u0783\u0784")
        buf.write("\3\2\2\2\u0784\u0786\3\2\2\2\u0785\u0783\3\2\2\2\u0786")
        buf.write("\u078a\5j\66\2\u0787\u0789\7m\2\2\u0788\u0787\3\2\2\2")
        buf.write("\u0789\u078c\3\2\2\2\u078a\u0788\3\2\2\2\u078a\u078b\3")
        buf.write("\2\2\2\u078b\u078d\3\2\2\2\u078c\u078a\3\2\2\2\u078d\u0791")
        buf.write("\7\33\2\2\u078e\u0790\7m\2\2\u078f\u078e\3\2\2\2\u0790")
        buf.write("\u0793\3\2\2\2\u0791\u078f\3\2\2\2\u0791\u0792\3\2\2\2")
        buf.write("\u0792\u0794\3\2\2\2\u0793\u0791\3\2\2\2\u0794\u0798\5")
        buf.write(",\27\2\u0795\u0797\7m\2\2\u0796\u0795\3\2\2\2\u0797\u079a")
        buf.write("\3\2\2\2\u0798\u0796\3\2\2\2\u0798\u0799\3\2\2\2\u0799")
        buf.write("\u079b\3\2\2\2\u079a\u0798\3\2\2\2\u079b\u079c\7:\2\2")
        buf.write("\u079c\u07cc\3\2\2\2\u079d\u07a1\f\4\2\2\u079e\u07a0\7")
        buf.write("m\2\2\u079f\u079e\3\2\2\2\u07a0\u07a3\3\2\2\2\u07a1\u079f")
        buf.write("\3\2\2\2\u07a1\u07a2\3\2\2\2\u07a2\u07a4\3\2\2\2\u07a3")
        buf.write("\u07a1\3\2\2\2\u07a4\u07a8\79\2\2\u07a5\u07a7\7m\2\2\u07a6")
        buf.write("\u07a5\3\2\2\2\u07a7\u07aa\3\2\2\2\u07a8\u07a6\3\2\2\2")
        buf.write("\u07a8\u07a9\3\2\2\2\u07a9\u07ab\3\2\2\2\u07aa\u07a8\3")
        buf.write("\2\2\2\u07ab\u07af\7C\2\2\u07ac\u07ae\7m\2\2\u07ad\u07ac")
        buf.write("\3\2\2\2\u07ae\u07b1\3\2\2\2\u07af\u07ad\3\2\2\2\u07af")
        buf.write("\u07b0\3\2\2\2\u07b0\u07b2\3\2\2\2\u07b1\u07af\3\2\2\2")
        buf.write("\u07b2\u07cc\7:\2\2\u07b3\u07b7\f\3\2\2\u07b4\u07b6\7")
        buf.write("m\2\2\u07b5\u07b4\3\2\2\2\u07b6\u07b9\3\2\2\2\u07b7\u07b5")
        buf.write("\3\2\2\2\u07b7\u07b8\3\2\2\2\u07b8\u07ba\3\2\2\2\u07b9")
        buf.write("\u07b7\3\2\2\2\u07ba\u07be\7\67\2\2\u07bb\u07bd\7m\2\2")
        buf.write("\u07bc\u07bb\3\2\2\2\u07bd\u07c0\3\2\2\2\u07be\u07bc\3")
        buf.write("\2\2\2\u07be\u07bf\3\2\2\2\u07bf\u07c2\3\2\2\2\u07c0\u07be")
        buf.write("\3\2\2\2\u07c1\u07c3\5l\67\2\u07c2\u07c1\3\2\2\2\u07c2")
        buf.write("\u07c3\3\2\2\2\u07c3\u07c7\3\2\2\2\u07c4\u07c6\7m\2\2")
        buf.write("\u07c5\u07c4\3\2\2\2\u07c6\u07c9\3\2\2\2\u07c7\u07c5\3")
        buf.write("\2\2\2\u07c7\u07c8\3\2\2\2\u07c8\u07ca\3\2\2\2\u07c9\u07c7")
        buf.write("\3\2\2\2\u07ca\u07cc\78\2\2\u07cb\u0730\3\2\2\2\u07cb")
        buf.write("\u0751\3\2\2\2\u07cb\u0778\3\2\2\2\u07cb\u079d\3\2\2\2")
        buf.write("\u07cb\u07b3\3\2\2\2\u07cc\u07cf\3\2\2\2\u07cd\u07cb\3")
        buf.write("\2\2\2\u07cd\u07ce\3\2\2\2\u07cey\3\2\2\2\u07cf\u07cd")
        buf.write("\3\2\2\2\u07d0\u07d1\7g\2\2\u07d1{\3\2\2\2\u07d2\u07ee")
        buf.write("\5,\27\2\u07d3\u07d7\7;\2\2\u07d4\u07d6\7m\2\2\u07d5\u07d4")
        buf.write("\3\2\2\2\u07d6\u07d9\3\2\2\2\u07d7\u07d5\3\2\2\2\u07d7")
        buf.write("\u07d8\3\2\2\2\u07d8\u07db\3\2\2\2\u07d9\u07d7\3\2\2\2")
        buf.write("\u07da\u07dc\5~@\2\u07db\u07da\3\2\2\2\u07db\u07dc\3\2")
        buf.write("\2\2\u07dc\u07e0\3\2\2\2\u07dd\u07df\7m\2\2\u07de\u07dd")
        buf.write("\3\2\2\2\u07df\u07e2\3\2\2\2\u07e0\u07de\3\2\2\2\u07e0")
        buf.write("\u07e1\3\2\2\2\u07e1\u07e4\3\2\2\2\u07e2\u07e0\3\2\2\2")
        buf.write("\u07e3\u07e5\7R\2\2\u07e4\u07e3\3\2\2\2\u07e4\u07e5\3")
        buf.write("\2\2\2\u07e5\u07e9\3\2\2\2\u07e6\u07e8\7m\2\2\u07e7\u07e6")
        buf.write("\3\2\2\2\u07e8\u07eb\3\2\2\2\u07e9\u07e7\3\2\2\2\u07e9")
        buf.write("\u07ea\3\2\2\2\u07ea\u07ec\3\2\2\2\u07eb\u07e9\3\2\2\2")
        buf.write("\u07ec\u07ee\7<\2\2\u07ed\u07d2\3\2\2\2\u07ed\u07d3\3")
        buf.write("\2\2\2\u07ee}\3\2\2\2\u07ef\u07f1\5\u0080A\2\u07f0\u07ef")
        buf.write("\3\2\2\2\u07f0\u07f1\3\2\2\2\u07f1\u07f5\3\2\2\2\u07f2")
        buf.write("\u07f4\7m\2\2\u07f3\u07f2\3\2\2\2\u07f4\u07f7\3\2\2\2")
        buf.write("\u07f5\u07f3\3\2\2\2\u07f5\u07f6\3\2\2\2\u07f6\u07f8\3")
        buf.write("\2\2\2\u07f7\u07f5\3\2\2\2\u07f8\u07fc\5|?\2\u07f9\u07fb")
        buf.write("\7m\2\2\u07fa\u07f9\3\2\2\2\u07fb\u07fe\3\2\2\2\u07fc")
        buf.write("\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u0818\3\2\2\2")
        buf.write("\u07fe\u07fc\3\2\2\2\u07ff\u0803\7R\2\2\u0800\u0802\7")
        buf.write("m\2\2\u0801\u0800\3\2\2\2\u0802\u0805\3\2\2\2\u0803\u0801")
        buf.write("\3\2\2\2\u0803\u0804\3\2\2\2\u0804\u0807\3\2\2\2\u0805")
        buf.write("\u0803\3\2\2\2\u0806\u0808\5\u0080A\2\u0807\u0806\3\2")
        buf.write("\2\2\u0807\u0808\3\2\2\2\u0808\u080c\3\2\2\2\u0809\u080b")
        buf.write("\7m\2\2\u080a\u0809\3\2\2\2\u080b\u080e\3\2\2\2\u080c")
        buf.write("\u080a\3\2\2\2\u080c\u080d\3\2\2\2\u080d\u080f\3\2\2\2")
        buf.write("\u080e\u080c\3\2\2\2\u080f\u0813\5|?\2\u0810\u0812\7m")
        buf.write("\2\2\u0811\u0810\3\2\2\2\u0812\u0815\3\2\2\2\u0813\u0811")
        buf.write("\3\2\2\2\u0813\u0814\3\2\2\2\u0814\u0817\3\2\2\2\u0815")
        buf.write("\u0813\3\2\2\2\u0816\u07ff\3\2\2\2\u0817\u081a\3\2\2\2")
        buf.write("\u0818\u0816\3\2\2\2\u0818\u0819\3\2\2\2\u0819\177\3\2")
        buf.write("\2\2\u081a\u0818\3\2\2\2\u081b\u081f\5\u0082B\2\u081c")
        buf.write("\u081e\7m\2\2\u081d\u081c\3\2\2\2\u081e\u0821\3\2\2\2")
        buf.write("\u081f\u081d\3\2\2\2\u081f\u0820\3\2\2\2\u0820\u0822\3")
        buf.write("\2\2\2\u0821\u081f\3\2\2\2\u0822\u0823\7S\2\2\u0823\u0081")
        buf.write("\3\2\2\2\u0824\u0826\5\u0084C\2\u0825\u0824\3\2\2\2\u0826")
        buf.write("\u0827\3\2\2\2\u0827\u0825\3\2\2\2\u0827\u0828\3\2\2\2")
        buf.write("\u0828\u0083\3\2\2\2\u0829\u082d\79\2\2\u082a\u082c\7")
        buf.write("m\2\2\u082b\u082a\3\2\2\2\u082c\u082f\3\2\2\2\u082d\u082b")
        buf.write("\3\2\2\2\u082d\u082e\3\2\2\2\u082e\u0830\3\2\2\2\u082f")
        buf.write("\u082d\3\2\2\2\u0830\u0834\5\62\32\2\u0831\u0833\7m\2")
        buf.write("\2\u0832\u0831\3\2\2\2\u0833\u0836\3\2\2\2\u0834\u0832")
        buf.write("\3\2\2\2\u0834\u0835\3\2\2\2\u0835\u0837\3\2\2\2\u0836")
        buf.write("\u0834\3\2\2\2\u0837\u0838\7:\2\2\u0838\u0842\3\2\2\2")
        buf.write("\u0839\u083d\7e\2\2\u083a\u083c\7m\2\2\u083b\u083a\3\2")
        buf.write("\2\2\u083c\u083f\3\2\2\2\u083d\u083b\3\2\2\2\u083d\u083e")
        buf.write("\3\2\2\2\u083e\u0840\3\2\2\2\u083f\u083d\3\2\2\2\u0840")
        buf.write("\u0842\7g\2\2\u0841\u0829\3\2\2\2\u0841\u0839\3\2\2\2")
        buf.write("\u0842\u0085\3\2\2\2\u0843\u0847\7\65\2\2\u0844\u0846")
        buf.write("\7m\2\2\u0845\u0844\3\2\2\2\u0846\u0849\3\2\2\2\u0847")
        buf.write("\u0845\3\2\2\2\u0847\u0848\3\2\2\2\u0848\u084a\3\2\2\2")
        buf.write("\u0849\u0847\3\2\2\2\u084a\u084e\7\67\2\2\u084b\u084d")
        buf.write("\7m\2\2\u084c\u084b\3\2\2\2\u084d\u0850\3\2\2\2\u084e")
        buf.write("\u084c\3\2\2\2\u084e\u084f\3\2\2\2\u084f\u0851\3\2\2\2")
        buf.write("\u0850\u084e\3\2\2\2\u0851\u0855\5\62\32\2\u0852\u0854")
        buf.write("\7m\2\2\u0853\u0852\3\2\2\2\u0854\u0857\3\2\2\2\u0855")
        buf.write("\u0853\3\2\2\2\u0855\u0856\3\2\2\2\u0856\u0858\3\2\2\2")
        buf.write("\u0857\u0855\3\2\2\2\u0858\u085c\7R\2\2\u0859\u085b\7")
        buf.write("m\2\2\u085a\u0859\3\2\2\2\u085b\u085e\3\2\2\2\u085c\u085a")
        buf.write("\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u0860\3\2\2\2\u085e")
        buf.write("\u085c\3\2\2\2\u085f\u0861\7j\2\2\u0860\u085f\3\2\2\2")
        buf.write("\u0861\u0862\3\2\2\2\u0862\u0860\3\2\2\2\u0862\u0863\3")
        buf.write("\2\2\2\u0863\u0867\3\2\2\2\u0864\u0866\7m\2\2\u0865\u0864")
        buf.write("\3\2\2\2\u0866\u0869\3\2\2\2\u0867\u0865\3\2\2\2\u0867")
        buf.write("\u0868\3\2\2\2\u0868\u086a\3\2\2\2\u0869\u0867\3\2\2\2")
        buf.write("\u086a\u086b\78\2\2\u086b\u086c\5\u00bc_\2\u086c\u0087")
        buf.write("\3\2\2\2\u086d\u08c8\5\u008aF\2\u086e\u08c8\5\u008cG\2")
        buf.write("\u086f\u08c8\5\u0092J\2\u0870\u08c8\5\u0094K\2\u0871\u08c8")
        buf.write("\5\u009cO\2\u0872\u08c8\5\u009eP\2\u0873\u08c8\5\u00a6")
        buf.write("T\2\u0874\u0878\7\67\2\2\u0875\u0877\7m\2\2\u0876\u0875")
        buf.write("\3\2\2\2\u0877\u087a\3\2\2\2\u0878\u0876\3\2\2\2\u0878")
        buf.write("\u0879\3\2\2\2\u0879\u0895\3\2\2\2\u087a\u0878\3\2\2\2")
        buf.write("\u087b\u087f\5(\25\2\u087c\u087e\7m\2\2\u087d\u087c\3")
        buf.write("\2\2\2\u087e\u0881\3\2\2\2\u087f\u087d\3\2\2\2\u087f\u0880")
        buf.write("\3\2\2\2\u0880\u0892\3\2\2\2\u0881\u087f\3\2\2\2\u0882")
        buf.write("\u0886\7R\2\2\u0883\u0885\7m\2\2\u0884\u0883\3\2\2\2\u0885")
        buf.write("\u0888\3\2\2\2\u0886\u0884\3\2\2\2\u0886\u0887\3\2\2\2")
        buf.write("\u0887\u0889\3\2\2\2\u0888\u0886\3\2\2\2\u0889\u088d\5")
        buf.write("(\25\2\u088a\u088c\7m\2\2\u088b\u088a\3\2\2\2\u088c\u088f")
        buf.write("\3\2\2\2\u088d\u088b\3\2\2\2\u088d\u088e\3\2\2\2\u088e")
        buf.write("\u0891\3\2\2\2\u088f\u088d\3\2\2\2\u0890\u0882\3\2\2\2")
        buf.write("\u0891\u0894\3\2\2\2\u0892\u0890\3\2\2\2\u0892\u0893\3")
        buf.write("\2\2\2\u0893\u0896\3\2\2\2\u0894\u0892\3\2\2\2\u0895\u087b")
        buf.write("\3\2\2\2\u0895\u0896\3\2\2\2\u0896\u089a\3\2\2\2\u0897")
        buf.write("\u0899\7m\2\2\u0898\u0897\3\2\2\2\u0899\u089c\3\2\2\2")
        buf.write("\u089a\u0898\3\2\2\2\u089a\u089b\3\2\2\2\u089b\u08bc\3")
        buf.write("\2\2\2\u089c\u089a\3\2\2\2\u089d\u08a1\7P\2\2\u089e\u08a0")
        buf.write("\7m\2\2\u089f\u089e\3\2\2\2\u08a0\u08a3\3\2\2\2\u08a1")
        buf.write("\u089f\3\2\2\2\u08a1\u08a2\3\2\2\2\u08a2\u08b8\3\2\2\2")
        buf.write("\u08a3\u08a1\3\2\2\2\u08a4\u08a8\5(\25\2\u08a5\u08a7\7")
        buf.write("m\2\2\u08a6\u08a5\3\2\2\2\u08a7\u08aa\3\2\2\2\u08a8\u08a6")
        buf.write("\3\2\2\2\u08a8\u08a9\3\2\2\2\u08a9\u08b5\3\2\2\2\u08aa")
        buf.write("\u08a8\3\2\2\2\u08ab\u08af\7R\2\2\u08ac\u08ae\7m\2\2\u08ad")
        buf.write("\u08ac\3\2\2\2\u08ae\u08b1\3\2\2\2\u08af\u08ad\3\2\2\2")
        buf.write("\u08af\u08b0\3\2\2\2\u08b0\u08b2\3\2\2\2\u08b1\u08af\3")
        buf.write("\2\2\2\u08b2\u08b4\5(\25\2\u08b3\u08ab\3\2\2\2\u08b4\u08b7")
        buf.write("\3\2\2\2\u08b5\u08b3\3\2\2\2\u08b5\u08b6\3\2\2\2\u08b6")
        buf.write("\u08b9\3\2\2\2\u08b7\u08b5\3\2\2\2\u08b8\u08a4\3\2\2\2")
        buf.write("\u08b8\u08b9\3\2\2\2\u08b9\u08bb\3\2\2\2\u08ba\u089d\3")
        buf.write("\2\2\2\u08bb\u08be\3\2\2\2\u08bc\u08ba\3\2\2\2\u08bc\u08bd")
        buf.write("\3\2\2\2\u08bd\u08c2\3\2\2\2\u08be\u08bc\3\2\2\2\u08bf")
        buf.write("\u08c1\7m\2\2\u08c0\u08bf\3\2\2\2\u08c1\u08c4\3\2\2\2")
        buf.write("\u08c2\u08c0\3\2\2\2\u08c2\u08c3\3\2\2\2\u08c3\u08c5\3")
        buf.write("\2\2\2\u08c4\u08c2\3\2\2\2\u08c5\u08c6\78\2\2\u08c6\u08c8")
        buf.write("\5\u00bc_\2\u08c7\u086d\3\2\2\2\u08c7\u086e\3\2\2\2\u08c7")
        buf.write("\u086f\3\2\2\2\u08c7\u0870\3\2\2\2\u08c7\u0871\3\2\2\2")
        buf.write("\u08c7\u0872\3\2\2\2\u08c7\u0873\3\2\2\2\u08c7\u0874\3")
        buf.write("\2\2\2\u08c8\u0089\3\2\2\2\u08c9\u08cd\7\36\2\2\u08ca")
        buf.write("\u08cc\7m\2\2\u08cb\u08ca\3\2\2\2\u08cc\u08cf\3\2\2\2")
        buf.write("\u08cd\u08cb\3\2\2\2\u08cd\u08ce\3\2\2\2\u08ce\u08d0\3")
        buf.write("\2\2\2\u08cf\u08cd\3\2\2\2\u08d0\u08d4\5\62\32\2\u08d1")
        buf.write("\u08d3\7m\2\2\u08d2\u08d1\3\2\2\2\u08d3\u08d6\3\2\2\2")
        buf.write("\u08d4\u08d2\3\2\2\2\u08d4\u08d5\3\2\2\2\u08d5\u08d7\3")
        buf.write("\2\2\2\u08d6\u08d4\3\2\2\2\u08d7\u08db\7P\2\2\u08d8\u08da")
        buf.write("\7m\2\2\u08d9\u08d8\3\2\2\2\u08da\u08dd\3\2\2\2\u08db")
        buf.write("\u08d9\3\2\2\2\u08db\u08dc\3\2\2\2\u08dc\u08de\3\2\2\2")
        buf.write("\u08dd\u08db\3\2\2\2\u08de\u08df\5\u0088E\2\u08df\u08f0")
        buf.write("\3\2\2\2\u08e0\u08e4\7\37\2\2\u08e1\u08e3\7m\2\2\u08e2")
        buf.write("\u08e1\3\2\2\2\u08e3\u08e6\3\2\2\2\u08e4\u08e2\3\2\2\2")
        buf.write("\u08e4\u08e5\3\2\2\2\u08e5\u08e7\3\2\2\2\u08e6\u08e4\3")
        buf.write("\2\2\2\u08e7\u08eb\7P\2\2\u08e8\u08ea\7m\2\2\u08e9\u08e8")
        buf.write("\3\2\2\2\u08ea\u08ed\3\2\2\2\u08eb\u08e9\3\2\2\2\u08eb")
        buf.write("\u08ec\3\2\2\2\u08ec\u08ee\3\2\2\2\u08ed\u08eb\3\2\2\2")
        buf.write("\u08ee\u08f0\5\u0088E\2\u08ef\u08c9\3\2\2\2\u08ef\u08e0")
        buf.write("\3\2\2\2\u08f0\u008b\3\2\2\2\u08f1\u08f5\7;\2\2\u08f2")
        buf.write("\u08f4\7m\2\2\u08f3\u08f2\3\2\2\2\u08f4\u08f7\3\2\2\2")
        buf.write("\u08f5\u08f3\3\2\2\2\u08f5\u08f6\3\2\2\2\u08f6\u08f9\3")
        buf.write("\2\2\2\u08f7\u08f5\3\2\2\2\u08f8\u08fa\5\u008eH\2\u08f9")
        buf.write("\u08f8\3\2\2\2\u08f9\u08fa\3\2\2\2\u08fa\u08fe\3\2\2\2")
        buf.write("\u08fb\u08fd\7m\2\2\u08fc\u08fb\3\2\2\2\u08fd\u0900\3")
        buf.write("\2\2\2\u08fe\u08fc\3\2\2\2\u08fe\u08ff\3\2\2\2\u08ff\u0901")
        buf.write("\3\2\2\2\u0900\u08fe\3\2\2\2\u0901\u0902\7<\2\2\u0902")
        buf.write("\u008d\3\2\2\2\u0903\u0905\5\u0090I\2\u0904\u0903\3\2")
        buf.write("\2\2\u0905\u0906\3\2\2\2\u0906\u0904\3\2\2\2\u0906\u0907")
        buf.write("\3\2\2\2\u0907\u008f\3\2\2\2\u0908\u090a\7m\2\2\u0909")
        buf.write("\u0908\3\2\2\2\u090a\u090d\3\2\2\2\u090b\u0909\3\2\2\2")
        buf.write("\u090b\u090c\3\2\2\2\u090c\u0910\3\2\2\2\u090d\u090b\3")
        buf.write("\2\2\2\u090e\u0911\5\u0088E\2\u090f\u0911\5\64\33\2\u0910")
        buf.write("\u090e\3\2\2\2\u0910\u090f\3\2\2\2\u0911\u0915\3\2\2\2")
        buf.write("\u0912\u0914\7m\2\2\u0913\u0912\3\2\2\2\u0914\u0917\3")
        buf.write("\2\2\2\u0915\u0913\3\2\2\2\u0915\u0916\3\2\2\2\u0916\u0091")
        buf.write("\3\2\2\2\u0917\u0915\3\2\2\2\u0918\u091a\5\60\31\2\u0919")
        buf.write("\u0918\3\2\2\2\u0919\u091a\3\2\2\2\u091a\u091b\3\2\2\2")
        buf.write("\u091b\u091c\5\u00bc_\2\u091c\u0093\3\2\2\2\u091d\u0921")
        buf.write("\7\3\2\2\u091e\u0920\7m\2\2\u091f\u091e\3\2\2\2\u0920")
        buf.write("\u0923\3\2\2\2\u0921\u091f\3\2\2\2\u0921\u0922\3\2\2\2")
        buf.write("\u0922\u0924\3\2\2\2\u0923\u0921\3\2\2\2\u0924\u0928\5")
        buf.write("\u008cG\2\u0925\u0927\7m\2\2\u0926\u0925\3\2\2\2\u0927")
        buf.write("\u092a\3\2\2\2\u0928\u0926\3\2\2\2\u0928\u0929\3\2\2\2")
        buf.write("\u0929\u092c\3\2\2\2\u092a\u0928\3\2\2\2\u092b\u092d\5")
        buf.write("\u0096L\2\u092c\u092b\3\2\2\2\u092d\u092e\3\2\2\2\u092e")
        buf.write("\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0933\3\2\2\2")
        buf.write("\u0930\u0932\7m\2\2\u0931\u0930\3\2\2\2\u0932\u0935\3")
        buf.write("\2\2\2\u0933\u0931\3\2\2\2\u0933\u0934\3\2\2\2\u0934\u0956")
        buf.write("\3\2\2\2\u0935\u0933\3\2\2\2\u0936\u093a\5\u0098M\2\u0937")
        buf.write("\u0939\7m\2\2\u0938\u0937\3\2\2\2\u0939\u093c\3\2\2\2")
        buf.write("\u093a\u0938\3\2\2\2\u093a\u093b\3\2\2\2\u093b\u093e\3")
        buf.write("\2\2\2\u093c\u093a\3\2\2\2\u093d\u093f\5\u009aN\2\u093e")
        buf.write("\u093d\3\2\2\2\u093e\u093f\3\2\2\2\u093f\u0943\3\2\2\2")
        buf.write("\u0940\u0942\7m\2\2\u0941\u0940\3\2\2\2\u0942\u0945\3")
        buf.write("\2\2\2\u0943\u0941\3\2\2\2\u0943\u0944\3\2\2\2\u0944\u0957")
        buf.write("\3\2\2\2\u0945\u0943\3\2\2\2\u0946\u094a\5\u009aN\2\u0947")
        buf.write("\u0949\7m\2\2\u0948\u0947\3\2\2\2\u0949\u094c\3\2\2\2")
        buf.write("\u094a\u0948\3\2\2\2\u094a\u094b\3\2\2\2\u094b\u094e\3")
        buf.write("\2\2\2\u094c\u094a\3\2\2\2\u094d\u094f\5\u0098M\2\u094e")
        buf.write("\u094d\3\2\2\2\u094e\u094f\3\2\2\2\u094f\u0953\3\2\2\2")
        buf.write("\u0950\u0952\7m\2\2\u0951\u0950\3\2\2\2\u0952\u0955\3")
        buf.write("\2\2\2\u0953\u0951\3\2\2\2\u0953\u0954\3\2\2\2\u0954\u0957")
        buf.write("\3\2\2\2\u0955\u0953\3\2\2\2\u0956\u0936\3\2\2\2\u0956")
        buf.write("\u0946\3\2\2\2\u0956\u0957\3\2\2\2\u0957\u0095\3\2\2\2")
        buf.write("\u0958\u095c\7\4\2\2\u0959\u095b\7m\2\2\u095a\u0959\3")
        buf.write("\2\2\2\u095b\u095e\3\2\2\2\u095c\u095a\3\2\2\2\u095c\u095d")
        buf.write("\3\2\2\2\u095d\u095f\3\2\2\2\u095e\u095c\3\2\2\2\u095f")
        buf.write("\u0963\7\67\2\2\u0960\u0962\7m\2\2\u0961\u0960\3\2\2\2")
        buf.write("\u0962\u0965\3\2\2\2\u0963\u0961\3\2\2\2\u0963\u0964\3")
        buf.write("\2\2\2\u0964\u0968\3\2\2\2\u0965\u0963\3\2\2\2\u0966\u0969")
        buf.write("\7g\2\2\u0967\u0969\5r:\2\u0968\u0966\3\2\2\2\u0968\u0967")
        buf.write("\3\2\2\2\u0969\u096d\3\2\2\2\u096a\u096c\7m\2\2\u096b")
        buf.write("\u096a\3\2\2\2\u096c\u096f\3\2\2\2\u096d\u096b\3\2\2\2")
        buf.write("\u096d\u096e\3\2\2\2\u096e\u0970\3\2\2\2\u096f\u096d\3")
        buf.write("\2\2\2\u0970\u0974\78\2\2\u0971\u0973\7m\2\2\u0972\u0971")
        buf.write("\3\2\2\2\u0973\u0976\3\2\2\2\u0974\u0972\3\2\2\2\u0974")
        buf.write("\u0975\3\2\2\2\u0975\u097f\3\2\2\2\u0976\u0974\3\2\2\2")
        buf.write("\u0977\u097b\7\30\2\2\u0978\u097a\7m\2\2\u0979\u0978\3")
        buf.write("\2\2\2\u097a\u097d\3\2\2\2\u097b\u0979\3\2\2\2\u097b\u097c")
        buf.write("\3\2\2\2\u097c\u097e\3\2\2\2\u097d\u097b\3\2\2\2\u097e")
        buf.write("\u0980\7g\2\2\u097f\u0977\3\2\2\2\u097f\u0980\3\2\2\2")
        buf.write("\u0980\u0984\3\2\2\2\u0981\u0983\7m\2\2\u0982\u0981\3")
        buf.write("\2\2\2\u0983\u0986\3\2\2\2\u0984\u0982\3\2\2\2\u0984\u0985")
        buf.write("\3\2\2\2\u0985\u0987\3\2\2\2\u0986\u0984\3\2\2\2\u0987")
        buf.write("\u0988\5\u008cG\2\u0988\u0097\3\2\2\2\u0989\u098d\7\5")
        buf.write("\2\2\u098a\u098c\7m\2\2\u098b\u098a\3\2\2\2\u098c\u098f")
        buf.write("\3\2\2\2\u098d\u098b\3\2\2\2\u098d\u098e\3\2\2\2\u098e")
        buf.write("\u0990\3\2\2\2\u098f\u098d\3\2\2\2\u0990\u0991\5\u008c")
        buf.write("G\2\u0991\u0099\3\2\2\2\u0992\u0996\7%\2\2\u0993\u0995")
        buf.write("\7m\2\2\u0994\u0993\3\2\2\2\u0995\u0998\3\2\2\2\u0996")
        buf.write("\u0994\3\2\2\2\u0996\u0997\3\2\2\2\u0997\u0999\3\2\2\2")
        buf.write("\u0998\u0996\3\2\2\2\u0999\u099a\5\u008cG\2\u099a\u009b")
        buf.write("\3\2\2\2\u099b\u099f\7$\2\2\u099c\u099e\7m\2\2\u099d\u099c")
        buf.write("\3\2\2\2\u099e\u09a1\3\2\2\2\u099f\u099d\3\2\2\2\u099f")
        buf.write("\u09a0\3\2\2\2\u09a0\u09a2\3\2\2\2\u09a1\u099f\3\2\2\2")
        buf.write("\u09a2\u09a6\7\67\2\2\u09a3\u09a5\7m\2\2\u09a4\u09a3\3")
        buf.write("\2\2\2\u09a5\u09a8\3\2\2\2\u09a6\u09a4\3\2\2\2\u09a6\u09a7")
        buf.write("\3\2\2\2\u09a7\u09a9\3\2\2\2\u09a8\u09a6\3\2\2\2\u09a9")
        buf.write("\u09ad\5\60\31\2\u09aa\u09ac\7m\2\2\u09ab\u09aa\3\2\2")
        buf.write("\2\u09ac\u09af\3\2\2\2\u09ad\u09ab\3\2\2\2\u09ad\u09ae")
        buf.write("\3\2\2\2\u09ae\u09b0\3\2\2\2\u09af\u09ad\3\2\2\2\u09b0")
        buf.write("\u09b4\78\2\2\u09b1\u09b3\7m\2\2\u09b2\u09b1\3\2\2\2\u09b3")
        buf.write("\u09b6\3\2\2\2\u09b4\u09b2\3\2\2\2\u09b4\u09b5\3\2\2\2")
        buf.write("\u09b5\u09b7\3\2\2\2\u09b6\u09b4\3\2\2\2\u09b7\u09bb\5")
        buf.write("\u0088E\2\u09b8\u09ba\7m\2\2\u09b9\u09b8\3\2\2\2\u09ba")
        buf.write("\u09bd\3\2\2\2\u09bb\u09b9\3\2\2\2\u09bb\u09bc\3\2\2\2")
        buf.write("\u09bc\u09c6\3\2\2\2\u09bd\u09bb\3\2\2\2\u09be\u09c2\7")
        buf.write("%\2\2\u09bf\u09c1\7m\2\2\u09c0\u09bf\3\2\2\2\u09c1\u09c4")
        buf.write("\3\2\2\2\u09c2\u09c0\3\2\2\2\u09c2\u09c3\3\2\2\2\u09c3")
        buf.write("\u09c5\3\2\2\2\u09c4\u09c2\3\2\2\2\u09c5\u09c7\5\u0088")
        buf.write("E\2\u09c6\u09be\3\2\2\2\u09c6\u09c7\3\2\2\2\u09c7\u09e7")
        buf.write("\3\2\2\2\u09c8\u09cc\7\35\2\2\u09c9\u09cb\7m\2\2\u09ca")
        buf.write("\u09c9\3\2\2\2\u09cb\u09ce\3\2\2\2\u09cc\u09ca\3\2\2\2")
        buf.write("\u09cc\u09cd\3\2\2\2\u09cd\u09cf\3\2\2\2\u09ce\u09cc\3")
        buf.write("\2\2\2\u09cf\u09d3\7\67\2\2\u09d0\u09d2\7m\2\2\u09d1\u09d0")
        buf.write("\3\2\2\2\u09d2\u09d5\3\2\2\2\u09d3\u09d1\3\2\2\2\u09d3")
        buf.write("\u09d4\3\2\2\2\u09d4\u09d6\3\2\2\2\u09d5\u09d3\3\2\2\2")
        buf.write("\u09d6\u09da\5\60\31\2\u09d7\u09d9\7m\2\2\u09d8\u09d7")
        buf.write("\3\2\2\2\u09d9\u09dc\3\2\2\2\u09da\u09d8\3\2\2\2\u09da")
        buf.write("\u09db\3\2\2\2\u09db\u09dd\3\2\2\2\u09dc\u09da\3\2\2\2")
        buf.write("\u09dd\u09e1\78\2\2\u09de\u09e0\7m\2\2\u09df\u09de\3\2")
        buf.write("\2\2\u09e0\u09e3\3\2\2\2\u09e1\u09df\3\2\2\2\u09e1\u09e2")
        buf.write("\3\2\2\2\u09e2\u09e4\3\2\2\2\u09e3\u09e1\3\2\2\2\u09e4")
        buf.write("\u09e5\5\u0088E\2\u09e5\u09e7\3\2\2\2\u09e6\u099b\3\2")
        buf.write("\2\2\u09e6\u09c8\3\2\2\2\u09e7\u009d\3\2\2\2\u09e8\u09ec")
        buf.write("\7#\2\2\u09e9\u09eb\7m\2\2\u09ea\u09e9\3\2\2\2\u09eb\u09ee")
        buf.write("\3\2\2\2\u09ec\u09ea\3\2\2\2\u09ec\u09ed\3\2\2\2\u09ed")
        buf.write("\u09ef\3\2\2\2\u09ee\u09ec\3\2\2\2\u09ef\u09f3\7\67\2")
        buf.write("\2\u09f0\u09f2\7m\2\2\u09f1\u09f0\3\2\2\2\u09f2\u09f5")
        buf.write("\3\2\2\2\u09f3\u09f1\3\2\2\2\u09f3\u09f4\3\2\2\2\u09f4")
        buf.write("\u09f6\3\2\2\2\u09f5\u09f3\3\2\2\2\u09f6\u09fa\5\60\31")
        buf.write("\2\u09f7\u09f9\7m\2\2\u09f8\u09f7\3\2\2\2\u09f9\u09fc")
        buf.write("\3\2\2\2\u09fa\u09f8\3\2\2\2\u09fa\u09fb\3\2\2\2\u09fb")
        buf.write("\u09fd\3\2\2\2\u09fc\u09fa\3\2\2\2\u09fd\u0a01\78\2\2")
        buf.write("\u09fe\u0a00\7m\2\2\u09ff\u09fe\3\2\2\2\u0a00\u0a03\3")
        buf.write("\2\2\2\u0a01\u09ff\3\2\2\2\u0a01\u0a02\3\2\2\2\u0a02\u0a04")
        buf.write("\3\2\2\2\u0a03\u0a01\3\2\2\2\u0a04\u0a05\5\u0088E\2\u0a05")
        buf.write("\u0a4b\3\2\2\2\u0a06\u0a0a\7\"\2\2\u0a07\u0a09\7m\2\2")
        buf.write("\u0a08\u0a07\3\2\2\2\u0a09\u0a0c\3\2\2\2\u0a0a\u0a08\3")
        buf.write("\2\2\2\u0a0a\u0a0b\3\2\2\2\u0a0b\u0a0d\3\2\2\2\u0a0c\u0a0a")
        buf.write("\3\2\2\2\u0a0d\u0a11\5\u0088E\2\u0a0e\u0a10\7m\2\2\u0a0f")
        buf.write("\u0a0e\3\2\2\2\u0a10\u0a13\3\2\2\2\u0a11\u0a0f\3\2\2\2")
        buf.write("\u0a11\u0a12\3\2\2\2\u0a12\u0a14\3\2\2\2\u0a13\u0a11\3")
        buf.write("\2\2\2\u0a14\u0a18\7#\2\2\u0a15\u0a17\7m\2\2\u0a16\u0a15")
        buf.write("\3\2\2\2\u0a17\u0a1a\3\2\2\2\u0a18\u0a16\3\2\2\2\u0a18")
        buf.write("\u0a19\3\2\2\2\u0a19\u0a1b\3\2\2\2\u0a1a\u0a18\3\2\2\2")
        buf.write("\u0a1b\u0a1f\7\67\2\2\u0a1c\u0a1e\7m\2\2\u0a1d\u0a1c\3")
        buf.write("\2\2\2\u0a1e\u0a21\3\2\2\2\u0a1f\u0a1d\3\2\2\2\u0a1f\u0a20")
        buf.write("\3\2\2\2\u0a20\u0a22\3\2\2\2\u0a21\u0a1f\3\2\2\2\u0a22")
        buf.write("\u0a26\5\60\31\2\u0a23\u0a25\7m\2\2\u0a24\u0a23\3\2\2")
        buf.write("\2\u0a25\u0a28\3\2\2\2\u0a26\u0a24\3\2\2\2\u0a26\u0a27")
        buf.write("\3\2\2\2\u0a27\u0a29\3\2\2\2\u0a28\u0a26\3\2\2\2\u0a29")
        buf.write("\u0a2a\78\2\2\u0a2a\u0a2b\5\u00bc_\2\u0a2b\u0a4b\3\2\2")
        buf.write("\2\u0a2c\u0a30\7&\2\2\u0a2d\u0a2f\7m\2\2\u0a2e\u0a2d\3")
        buf.write("\2\2\2\u0a2f\u0a32\3\2\2\2\u0a30\u0a2e\3\2\2\2\u0a30\u0a31")
        buf.write("\3\2\2\2\u0a31\u0a33\3\2\2\2\u0a32\u0a30\3\2\2\2\u0a33")
        buf.write("\u0a37\7\67\2\2\u0a34\u0a36\7m\2\2\u0a35\u0a34\3\2\2\2")
        buf.write("\u0a36\u0a39\3\2\2\2\u0a37\u0a35\3\2\2\2\u0a37\u0a38\3")
        buf.write("\2\2\2\u0a38\u0a3a\3\2\2\2\u0a39\u0a37\3\2\2\2\u0a3a\u0a3e")
        buf.write("\5\u00a0Q\2\u0a3b\u0a3d\7m\2\2\u0a3c\u0a3b\3\2\2\2\u0a3d")
        buf.write("\u0a40\3\2\2\2\u0a3e\u0a3c\3\2\2\2\u0a3e\u0a3f\3\2\2\2")
        buf.write("\u0a3f\u0a41\3\2\2\2\u0a40\u0a3e\3\2\2\2\u0a41\u0a45\7")
        buf.write("8\2\2\u0a42\u0a44\7m\2\2\u0a43\u0a42\3\2\2\2\u0a44\u0a47")
        buf.write("\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a46\3\2\2\2\u0a46")
        buf.write("\u0a48\3\2\2\2\u0a47\u0a45\3\2\2\2\u0a48\u0a49\5\u0088")
        buf.write("E\2\u0a49\u0a4b\3\2\2\2\u0a4a\u09e8\3\2\2\2\u0a4a\u0a06")
        buf.write("\3\2\2\2\u0a4a\u0a2c\3\2\2\2\u0a4b\u009f\3\2\2\2\u0a4c")
        buf.write("\u0a51\5\u00a2R\2\u0a4d\u0a4f\5\60\31\2\u0a4e\u0a4d\3")
        buf.write("\2\2\2\u0a4e\u0a4f\3\2\2\2\u0a4f\u0a51\3\2\2\2\u0a50\u0a4c")
        buf.write("\3\2\2\2\u0a50\u0a4e\3\2\2\2\u0a51\u0a52\3\2\2\2\u0a52")
        buf.write("\u0a54\5\u00bc_\2\u0a53\u0a55\5\u00a4S\2\u0a54\u0a53\3")
        buf.write("\2\2\2\u0a54\u0a55\3\2\2\2\u0a55\u0a56\3\2\2\2\u0a56\u0a58")
        buf.write("\5\u00bc_\2\u0a57\u0a59\5\u00a4S\2\u0a58\u0a57\3\2\2\2")
        buf.write("\u0a58\u0a59\3\2\2\2\u0a59\u00a1\3\2\2\2\u0a5a\u0a5e\5")
        buf.write("\66\34\2\u0a5b\u0a5d\7m\2\2\u0a5c\u0a5b\3\2\2\2\u0a5d")
        buf.write("\u0a60\3\2\2\2\u0a5e\u0a5c\3\2\2\2\u0a5e\u0a5f\3\2\2\2")
        buf.write("\u0a5f\u0a62\3\2\2\2\u0a60\u0a5e\3\2\2\2\u0a61\u0a63\5")
        buf.write(":\36\2\u0a62\u0a61\3\2\2\2\u0a62\u0a63\3\2\2\2\u0a63\u00a3")
        buf.write("\3\2\2\2\u0a64\u0a68\5,\27\2\u0a65\u0a67\7m\2\2\u0a66")
        buf.write("\u0a65\3\2\2\2\u0a67\u0a6a\3\2\2\2\u0a68\u0a66\3\2\2\2")
        buf.write("\u0a68\u0a69\3\2\2\2\u0a69\u0a7b\3\2\2\2\u0a6a\u0a68\3")
        buf.write("\2\2\2\u0a6b\u0a6f\7R\2\2\u0a6c\u0a6e\7m\2\2\u0a6d\u0a6c")
        buf.write("\3\2\2\2\u0a6e\u0a71\3\2\2\2\u0a6f\u0a6d\3\2\2\2\u0a6f")
        buf.write("\u0a70\3\2\2\2\u0a70\u0a72\3\2\2\2\u0a71\u0a6f\3\2\2\2")
        buf.write("\u0a72\u0a76\5,\27\2\u0a73\u0a75\7m\2\2\u0a74\u0a73\3")
        buf.write("\2\2\2\u0a75\u0a78\3\2\2\2\u0a76\u0a74\3\2\2\2\u0a76\u0a77")
        buf.write("\3\2\2\2\u0a77\u0a7a\3\2\2\2\u0a78\u0a76\3\2\2\2\u0a79")
        buf.write("\u0a6b\3\2\2\2\u0a7a\u0a7d\3\2\2\2\u0a7b\u0a79\3\2\2\2")
        buf.write("\u0a7b\u0a7c\3\2\2\2\u0a7c\u00a5\3\2\2\2\u0a7d\u0a7b\3")
        buf.write("\2\2\2\u0a7e\u0a8a\t\23\2\2\u0a7f\u0a83\7)\2\2\u0a80\u0a82")
        buf.write("\7m\2\2\u0a81\u0a80\3\2\2\2\u0a82\u0a85\3\2\2\2\u0a83")
        buf.write("\u0a81\3\2\2\2\u0a83\u0a84\3\2\2\2\u0a84\u0a87\3\2\2\2")
        buf.write("\u0a85\u0a83\3\2\2\2\u0a86\u0a88\5\60\31\2\u0a87\u0a86")
        buf.write("\3\2\2\2\u0a87\u0a88\3\2\2\2\u0a88\u0a8a\3\2\2\2\u0a89")
        buf.write("\u0a7e\3\2\2\2\u0a89\u0a7f\3\2\2\2\u0a8a\u0a8b\3\2\2\2")
        buf.write("\u0a8b\u0a8c\5\u00bc_\2\u0a8c\u00a7\3\2\2\2\u0a8d\u0a8f")
        buf.write("\5\u00aaV\2\u0a8e\u0a8d\3\2\2\2\u0a8e\u0a8f\3\2\2\2\u0a8f")
        buf.write("\u0a90\3\2\2\2\u0a90\u0a91\7\2\2\3\u0a91\u00a9\3\2\2\2")
        buf.write("\u0a92\u0a9a\5\u00acW\2\u0a93\u0a9a\5\u00bc_\2\u0a94\u0a96")
        buf.write("\7m\2\2\u0a95\u0a94\3\2\2\2\u0a96\u0a97\3\2\2\2\u0a97")
        buf.write("\u0a95\3\2\2\2\u0a97\u0a98\3\2\2\2\u0a98\u0a9a\3\2\2\2")
        buf.write("\u0a99\u0a92\3\2\2\2\u0a99\u0a93\3\2\2\2\u0a99\u0a95\3")
        buf.write("\2\2\2\u0a9a\u0a9b\3\2\2\2\u0a9b\u0a99\3\2\2\2\u0a9b\u0a9c")
        buf.write("\3\2\2\2\u0a9c\u00ab\3\2\2\2\u0a9d\u0aa1\5\u00aeX\2\u0a9e")
        buf.write("\u0aa1\5\64\33\2\u0a9f\u0aa1\5\u00b4[\2\u0aa0\u0a9d\3")
        buf.write("\2\2\2\u0aa0\u0a9e\3\2\2\2\u0aa0\u0a9f\3\2\2\2\u0aa1\u00ad")
        buf.write("\3\2\2\2\u0aa2\u0aa6\5\u00b0Y\2\u0aa3\u0aa5\7m\2\2\u0aa4")
        buf.write("\u0aa3\3\2\2\2\u0aa5\u0aa8\3\2\2\2\u0aa6\u0aa4\3\2\2\2")
        buf.write("\u0aa6\u0aa7\3\2\2\2\u0aa7\u0aa9\3\2\2\2\u0aa8\u0aa6\3")
        buf.write("\2\2\2\u0aa9\u0aad\5b\62\2\u0aaa\u0aac\7m\2\2\u0aab\u0aaa")
        buf.write("\3\2\2\2\u0aac\u0aaf\3\2\2\2\u0aad\u0aab\3\2\2\2\u0aad")
        buf.write("\u0aae\3\2\2\2\u0aae\u0ab1\3\2\2\2\u0aaf\u0aad\3\2\2\2")
        buf.write("\u0ab0\u0ab2\5\u00ba^\2\u0ab1\u0ab0\3\2\2\2\u0ab1\u0ab2")
        buf.write("\3\2\2\2\u0ab2\u0ab6\3\2\2\2\u0ab3\u0ab5\7m\2\2\u0ab4")
        buf.write("\u0ab3\3\2\2\2\u0ab5\u0ab8\3\2\2\2\u0ab6\u0ab4\3\2\2\2")
        buf.write("\u0ab6\u0ab7\3\2\2\2\u0ab7\u0ab9\3\2\2\2\u0ab8\u0ab6\3")
        buf.write("\2\2\2\u0ab9\u0aba\5\u008cG\2\u0aba\u0ad6\3\2\2\2\u0abb")
        buf.write("\u0abf\5\u00b0Y\2\u0abc\u0abe\7m\2\2\u0abd\u0abc\3\2\2")
        buf.write("\2\u0abe\u0ac1\3\2\2\2\u0abf\u0abd\3\2\2\2\u0abf\u0ac0")
        buf.write("\3\2\2\2\u0ac0\u0ac2\3\2\2\2\u0ac1\u0abf\3\2\2\2\u0ac2")
        buf.write("\u0ac6\5b\62\2\u0ac3\u0ac5\7m\2\2\u0ac4\u0ac3\3\2\2\2")
        buf.write("\u0ac5\u0ac8\3\2\2\2\u0ac6\u0ac4\3\2\2\2\u0ac6\u0ac7\3")
        buf.write("\2\2\2\u0ac7\u0aca\3\2\2\2\u0ac8\u0ac6\3\2\2\2\u0ac9\u0acb")
        buf.write("\5\u00ba^\2\u0aca\u0ac9\3\2\2\2\u0aca\u0acb\3\2\2\2\u0acb")
        buf.write("\u0acf\3\2\2\2\u0acc\u0ace\7m\2\2\u0acd\u0acc\3\2\2\2")
        buf.write("\u0ace\u0ad1\3\2\2\2\u0acf\u0acd\3\2\2\2\u0acf\u0ad0\3")
        buf.write("\2\2\2\u0ad0\u0ad2\3\2\2\2\u0ad1\u0acf\3\2\2\2\u0ad2\u0ad3")
        buf.write("\5\b\5\2\u0ad3\u0ad4\5\u00bc_\2\u0ad4\u0ad6\3\2\2\2\u0ad5")
        buf.write("\u0aa2\3\2\2\2\u0ad5\u0abb\3\2\2\2\u0ad6\u00af\3\2\2\2")
        buf.write("\u0ad7\u0ad9\5\u00b2Z\2\u0ad8\u0ad7\3\2\2\2\u0ad9\u0adc")
        buf.write("\3\2\2\2\u0ada\u0ad8\3\2\2\2\u0ada\u0adb\3\2\2\2\u0adb")
        buf.write("\u0ae0\3\2\2\2\u0adc\u0ada\3\2\2\2\u0add\u0adf\7m\2\2")
        buf.write("\u0ade\u0add\3\2\2\2\u0adf\u0ae2\3\2\2\2\u0ae0\u0ade\3")
        buf.write("\2\2\2\u0ae0\u0ae1\3\2\2\2\u0ae1\u0ae4\3\2\2\2\u0ae2\u0ae0")
        buf.write("\3\2\2\2\u0ae3\u0ae5\5\66\34\2\u0ae4\u0ae3\3\2\2\2\u0ae4")
        buf.write("\u0ae5\3\2\2\2\u0ae5\u00b1\3\2\2\2\u0ae6\u0ae7\7M\2\2")
        buf.write("\u0ae7\u0ae8\7g\2\2\u0ae8\u00b3\3\2\2\2\u0ae9\u0aed\7")
        buf.write("*\2\2\u0aea\u0aec\7m\2\2\u0aeb\u0aea\3\2\2\2\u0aec\u0aef")
        buf.write("\3\2\2\2\u0aed\u0aeb\3\2\2\2\u0aed\u0aee\3\2\2\2\u0aee")
        buf.write("\u0af0\3\2\2\2\u0aef\u0aed\3\2\2\2\u0af0\u0af4\7g\2\2")
        buf.write("\u0af1\u0af3\7m\2\2\u0af2\u0af1\3\2\2\2\u0af3\u0af6\3")
        buf.write("\2\2\2\u0af4\u0af2\3\2\2\2\u0af4\u0af5\3\2\2\2\u0af5\u0af7")
        buf.write("\3\2\2\2\u0af6\u0af4\3\2\2\2\u0af7\u0afb\5d\63\2\u0af8")
        buf.write("\u0afa\7m\2\2\u0af9\u0af8\3\2\2\2\u0afa\u0afd\3\2\2\2")
        buf.write("\u0afb\u0af9\3\2\2\2\u0afb\u0afc\3\2\2\2\u0afc\u0aff\3")
        buf.write("\2\2\2\u0afd\u0afb\3\2\2\2\u0afe\u0b00\5\u00ba^\2\u0aff")
        buf.write("\u0afe\3\2\2\2\u0aff\u0b00\3\2\2\2\u0b00\u0b04\3\2\2\2")
        buf.write("\u0b01\u0b03\7m\2\2\u0b02\u0b01\3\2\2\2\u0b03\u0b06\3")
        buf.write("\2\2\2\u0b04\u0b02\3\2\2\2\u0b04\u0b05\3\2\2\2\u0b05\u0b07")
        buf.write("\3\2\2\2\u0b06\u0b04\3\2\2\2\u0b07\u0b08\5\u00b6\\\2\u0b08")
        buf.write("\u00b5\3\2\2\2\u0b09\u0b0d\7;\2\2\u0b0a\u0b0c\7m\2\2\u0b0b")
        buf.write("\u0b0a\3\2\2\2\u0b0c\u0b0f\3\2\2\2\u0b0d\u0b0b\3\2\2\2")
        buf.write("\u0b0d\u0b0e\3\2\2\2\u0b0e\u0b2a\3\2\2\2\u0b0f\u0b0d\3")
        buf.write("\2\2\2\u0b10\u0b14\5\u00b8]\2\u0b11\u0b13\7m\2\2\u0b12")
        buf.write("\u0b11\3\2\2\2\u0b13\u0b16\3\2\2\2\u0b14\u0b12\3\2\2\2")
        buf.write("\u0b14\u0b15\3\2\2\2\u0b15\u0b27\3\2\2\2\u0b16\u0b14\3")
        buf.write("\2\2\2\u0b17\u0b1b\7R\2\2\u0b18\u0b1a\7m\2\2\u0b19\u0b18")
        buf.write("\3\2\2\2\u0b1a\u0b1d\3\2\2\2\u0b1b\u0b19\3\2\2\2\u0b1b")
        buf.write("\u0b1c\3\2\2\2\u0b1c\u0b1e\3\2\2\2\u0b1d\u0b1b\3\2\2\2")
        buf.write("\u0b1e\u0b22\5\u00b8]\2\u0b1f\u0b21\7m\2\2\u0b20\u0b1f")
        buf.write("\3\2\2\2\u0b21\u0b24\3\2\2\2\u0b22\u0b20\3\2\2\2\u0b22")
        buf.write("\u0b23\3\2\2\2\u0b23\u0b26\3\2\2\2\u0b24\u0b22\3\2\2\2")
        buf.write("\u0b25\u0b17\3\2\2\2\u0b26\u0b29\3\2\2\2\u0b27\u0b25\3")
        buf.write("\2\2\2\u0b27\u0b28\3\2\2\2\u0b28\u0b2b\3\2\2\2\u0b29\u0b27")
        buf.write("\3\2\2\2\u0b2a\u0b10\3\2\2\2\u0b2a\u0b2b\3\2\2\2\u0b2b")
        buf.write("\u0b2c\3\2\2\2\u0b2c\u0b2d\7<\2\2\u0b2d\u00b7\3\2\2\2")
        buf.write("\u0b2e\u0b32\7g\2\2\u0b2f\u0b31\7m\2\2\u0b30\u0b2f\3\2")
        buf.write("\2\2\u0b31\u0b34\3\2\2\2\u0b32\u0b30\3\2\2\2\u0b32\u0b33")
        buf.write("\3\2\2\2\u0b33\u0b35\3\2\2\2\u0b34\u0b32\3\2\2\2\u0b35")
        buf.write("\u0b39\7P\2\2\u0b36\u0b38\7m\2\2\u0b37\u0b36\3\2\2\2\u0b38")
        buf.write("\u0b3b\3\2\2\2\u0b39\u0b37\3\2\2\2\u0b39\u0b3a\3\2\2\2")
        buf.write("\u0b3a\u0b3c\3\2\2\2\u0b3b\u0b39\3\2\2\2\u0b3c\u0b3d\5")
        buf.write("\2\2\2\u0b3d\u00b9\3\2\2\2\u0b3e\u0b42\5\64\33\2\u0b3f")
        buf.write("\u0b41\7m\2\2\u0b40\u0b3f\3\2\2\2\u0b41\u0b44\3\2\2\2")
        buf.write("\u0b42\u0b40\3\2\2\2\u0b42\u0b43\3\2\2\2\u0b43\u0b46\3")
        buf.write("\2\2\2\u0b44\u0b42\3\2\2\2\u0b45\u0b3e\3\2\2\2\u0b46\u0b47")
        buf.write("\3\2\2\2\u0b47\u0b45\3\2\2\2\u0b47\u0b48\3\2\2\2\u0b48")
        buf.write("\u00bb\3\2\2\2\u0b49\u0b4b\7n\2\2\u0b4a\u0b49\3\2\2\2")
        buf.write("\u0b4b\u0b4e\3\2\2\2\u0b4c\u0b4a\3\2\2\2\u0b4c\u0b4d\3")
        buf.write("\2\2\2\u0b4d\u0b4f\3\2\2\2\u0b4e\u0b4c\3\2\2\2\u0b4f\u0b53")
        buf.write("\7Q\2\2\u0b50\u0b52\7n\2\2\u0b51\u0b50\3\2\2\2\u0b52\u0b55")
        buf.write("\3\2\2\2\u0b53\u0b51\3\2\2\2\u0b53\u0b54\3\2\2\2\u0b54")
        buf.write("\u00bd\3\2\2\2\u0b55\u0b53\3\2\2\2\u01b9\u00c3\u00ca\u00d0")
        buf.write("\u00d4\u00d9\u00e0\u00e7\u00ed\u00f6\u00fc\u0101\u0109")
        buf.write("\u0110\u0117\u011e\u0125\u0129\u012e\u0133\u0138\u013f")
        buf.write("\u0146\u014f\u0153\u0158\u0160\u0165\u0167\u016e\u0175")
        buf.write("\u017c\u0181\u0187\u018d\u0195\u019e\u01a5\u01ac\u01b1")
        buf.write("\u01ba\u01c1\u01c8\u01cf\u01d5\u01dc\u01e2\u01e9\u01f0")
        buf.write("\u01f7\u01fc\u0203\u020a\u0211\u0216\u021d\u0224\u022b")
        buf.write("\u0230\u0237\u023e\u0245\u024a\u0251\u0258\u025f\u0264")
        buf.write("\u026b\u0272\u0279\u027e\u0285\u028c\u0293\u0298\u029f")
        buf.write("\u02a6\u02ad\u02b2\u02b9\u02c0\u02c7\u02cc\u02d3\u02da")
        buf.write("\u02e1\u02e6\u02ed\u02f4\u02fb\u0302\u0309\u030c\u0313")
        buf.write("\u031a\u0320\u0328\u032f\u0336\u033b\u0344\u0348\u034d")
        buf.write("\u0353\u0358\u035f\u0365\u036c\u0373\u0378\u037f\u0386")
        buf.write("\u038d\u0390\u0398\u039c\u03a1\u03a5\u03aa\u03b2\u03b9")
        buf.write("\u03bd\u03c2\u03c9\u03d2\u03d9\u03e1\u03ea\u03ee\u03f3")
        buf.write("\u03fa\u03fe\u040e\u0415\u041c\u0424\u0429\u0434\u043b")
        buf.write("\u0442\u0447\u044d\u0453\u045a\u0461\u0464\u046a\u0470")
        buf.write("\u0476\u047f\u0484\u048b\u0492\u0497\u049d\u04a1\u04a6")
        buf.write("\u04aa\u04af\u04b3\u04b9\u04c0\u04c6\u04cb\u04d0\u04d7")
        buf.write("\u04db\u04e1\u04e5\u04ea\u04f1\u04f8\u04fc\u0501\u050a")
        buf.write("\u050e\u0514\u051b\u0522\u0527\u052e\u0535\u053c\u053f")
        buf.write("\u0547\u054e\u0555\u055c\u0567\u056e\u0573\u0578\u057e")
        buf.write("\u0583\u058e\u0595\u059e\u05a5\u05ad\u05b1\u05b6\u05bd")
        buf.write("\u05c4\u05c9\u05cf\u05d6\u05dd\u05e6\u05ed\u05f1\u05f6")
        buf.write("\u05fa\u05fc\u0604\u060b\u0610\u0612\u0619\u061d\u0622")
        buf.write("\u0627\u062c\u0632\u0639\u0640\u0643\u0649\u0650\u0657")
        buf.write("\u065c\u0663\u066c\u0670\u0672\u0678\u067f\u0686\u068b")
        buf.write("\u0692\u0696\u069a\u069f\u06a3\u06aa\u06b1\u06ba\u06be")
        buf.write("\u06c3\u06c7\u06cc\u06d4\u06db\u06df\u06e4\u06eb\u06f4")
        buf.write("\u06fb\u0702\u0709\u0712\u0719\u0721\u0725\u072a\u072e")
        buf.write("\u0734\u073b\u073f\u0744\u0748\u074d\u0755\u075c\u0763")
        buf.write("\u0767\u076c\u0773\u077c\u0783\u078a\u0791\u0798\u07a1")
        buf.write("\u07a8\u07af\u07b7\u07be\u07c2\u07c7\u07cb\u07cd\u07d7")
        buf.write("\u07db\u07e0\u07e4\u07e9\u07ed\u07f0\u07f5\u07fc\u0803")
        buf.write("\u0807\u080c\u0813\u0818\u081f\u0827\u082d\u0834\u083d")
        buf.write("\u0841\u0847\u084e\u0855\u085c\u0862\u0867\u0878\u087f")
        buf.write("\u0886\u088d\u0892\u0895\u089a\u08a1\u08a8\u08af\u08b5")
        buf.write("\u08b8\u08bc\u08c2\u08c7\u08cd\u08d4\u08db\u08e4\u08eb")
        buf.write("\u08ef\u08f5\u08f9\u08fe\u0906\u090b\u0910\u0915\u0919")
        buf.write("\u0921\u0928\u092e\u0933\u093a\u093e\u0943\u094a\u094e")
        buf.write("\u0953\u0956\u095c\u0963\u0968\u096d\u0974\u097b\u097f")
        buf.write("\u0984\u098d\u0996\u099f\u09a6\u09ad\u09b4\u09bb\u09c2")
        buf.write("\u09c6\u09cc\u09d3\u09da\u09e1\u09e6\u09ec\u09f3\u09fa")
        buf.write("\u0a01\u0a0a\u0a11\u0a18\u0a1f\u0a26\u0a30\u0a37\u0a3e")
        buf.write("\u0a45\u0a4a\u0a4e\u0a50\u0a54\u0a58\u0a5e\u0a62\u0a68")
        buf.write("\u0a6f\u0a76\u0a7b\u0a83\u0a87\u0a89\u0a8e\u0a97\u0a99")
        buf.write("\u0a9b\u0aa0\u0aa6\u0aad\u0ab1\u0ab6\u0abf\u0ac6\u0aca")
        buf.write("\u0acf\u0ad5\u0ada\u0ae0\u0ae4\u0aed\u0af4\u0afb\u0aff")
        buf.write("\u0b04\u0b0d\u0b14\u0b1b\u0b22\u0b27\u0b2a\u0b32\u0b39")
        buf.write("\u0b42\u0b47\u0b4c\u0b53")
        return buf.getvalue()


class ParaParser ( Parser ):

    grammarFileName = "Para.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'try'", "'except'", "'finally'", "'bool'", 
                     "'char'", "'complex'", "'double'", "'entry'", "'float'", 
                     "'imaginary'", "'int'", "'lambda'", "'long'", "'signed'", 
                     "'short'", "'status'", "'unsigned'", "'void'", "'const'", 
                     "'volatile'", "'atomic'", "'as'", "'auto'", "'register'", 
                     "'static'", "'extern'", "'switch'", "'case'", "'default'", 
                     "'break'", "'continue'", "'do'", "'while'", "'if'", 
                     "'else'", "'for'", "'enum'", "'restrict'", "'return'", 
                     "'exttask'", "'spawn'", "'struct'", "'sizeof'", "'typeof'", 
                     "'typedef'", "'union'", "'alignas'", "'alignof'", "'inline'", 
                     "'noreturn'", "'static_assert'", "'thread_local'", 
                     "'('", "')'", "'['", "']'", "'{'", "'}'", "'<<'", "'>>'", 
                     "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", 
                     "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", 
                     "'@'", "'=>'", "'?'", "':'", "';'", "','", "'='", "'*='", 
                     "'/='", "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", 
                     "'^='", "'|='", "'=='", "'!='", "'<'", "'<='", "'>'", 
                     "'>='", "'->'", "'.'", "'...'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "Bool", "Char", "Complex", "Double", "Entry", "Float", 
                      "Imaginary", "Int", "Lambda", "Long", "Signed", "Short", 
                      "Status", "Unsigned", "Void", "Const", "Volatile", 
                      "Atomic", "As", "Auto", "Register", "Static", "Extern", 
                      "Switch", "Case", "Default", "Break", "Continue", 
                      "Do", "While", "If", "Else", "For", "Enum", "Restrict", 
                      "Return", "ExtensionTask", "Spawn", "Struct", "Sizeof", 
                      "Typeof", "Typedef", "Union", "Alignas", "Alignof", 
                      "Inline", "Noreturn", "StaticAssert", "ThreadLocal", 
                      "LeftParen", "RightParen", "LeftBracket", "RightBracket", 
                      "LeftBrace", "RightBrace", "LeftShift", "RightShift", 
                      "Plus", "PlusPlus", "Minus", "MinusMinus", "Star", 
                      "Div", "Mod", "And", "Or", "AndAnd", "OrOr", "Caret", 
                      "Not", "Tilde", "DecoratorSign", "LambdaStartBlock", 
                      "Question", "Colon", "Semi", "Comma", "Assign", "StarAssign", 
                      "DivAssign", "ModAssign", "PlusAssign", "MinusAssign", 
                      "LeftShiftAssign", "RightShiftAssign", "AndAssign", 
                      "XorAssign", "OrAssign", "Equal", "NotEqual", "Less", 
                      "LessEqual", "Greater", "GreaterEqual", "Arrow", "Dot", 
                      "Ellipsis", "Identifier", "Constant", "DigitSequence", 
                      "StringLiteral", "AsmBlock", "Directive", "WS", "Whitespace", 
                      "Newline" ]

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

    ruleNames =  [ "primaryExpression", "lambdaFunction", "lambdaBody", 
                   "expressionLambda", "statementLambda", "postfixExpression", 
                   "argumentExpressionList", "unaryExpression", "unaryOperator", 
                   "castOrConvertExpression", "multiplicativeExpression", 
                   "additiveExpression", "shiftExpression", "relationalExpression", 
                   "equalityExpression", "andExpression", "exclusiveOrExpression", 
                   "inclusiveOrExpression", "logicalAndExpression", "logicalOrExpression", 
                   "conditionalExpression", "assignmentExpression", "assignmentOperator", 
                   "expression", "constantExpression", "declaration", "declarationSpecifiers", 
                   "declarationSpecifier", "initDeclaratorList", "initDeclarator", 
                   "storageClassSpecifier", "arraySpecifier", "typeSpecifier", 
                   "structOrUnionSpecifier", "structOrUnion", "structDeclarationList", 
                   "structDeclaration", "specifierQualifierList", "structDeclaratorList", 
                   "structDeclarator", "enumSpecifier", "enumeratorList", 
                   "enumerator", "enumerationConstant", "atomicTypeSpecifier", 
                   "typeQualifier", "functionSpecifier", "alignmentSpecifier", 
                   "declarator", "directDeclarator", "nestedParenthesesBlock", 
                   "pointer", "typeQualifierList", "parameterTypeList", 
                   "parameterList", "parameterDeclaration", "identifierList", 
                   "typeName", "abstractDeclarator", "directAbstractDeclarator", 
                   "typedefName", "initializer", "initializerList", "designation", 
                   "designatorList", "designator", "staticAssertDeclaration", 
                   "statement", "labeledStatement", "compoundStatement", 
                   "blockItemList", "blockItem", "expressionStatement", 
                   "tryExceptStatement", "exceptBlock", "finallyBlock", 
                   "elseBlock", "selectionStatement", "iterationStatement", 
                   "forCondition", "forDeclaration", "forExpression", "jumpStatement", 
                   "compilationUnit", "translationUnit", "externalItem", 
                   "functionDefinition", "functionDeclarationSpecifiers", 
                   "decoratorSpecifier", "extensionTaskDefinition", "extensionTaskParameterList", 
                   "extensionTaskParameter", "declarationList", "endOfItem" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    Bool=4
    Char=5
    Complex=6
    Double=7
    Entry=8
    Float=9
    Imaginary=10
    Int=11
    Lambda=12
    Long=13
    Signed=14
    Short=15
    Status=16
    Unsigned=17
    Void=18
    Const=19
    Volatile=20
    Atomic=21
    As=22
    Auto=23
    Register=24
    Static=25
    Extern=26
    Switch=27
    Case=28
    Default=29
    Break=30
    Continue=31
    Do=32
    While=33
    If=34
    Else=35
    For=36
    Enum=37
    Restrict=38
    Return=39
    ExtensionTask=40
    Spawn=41
    Struct=42
    Sizeof=43
    Typeof=44
    Typedef=45
    Union=46
    Alignas=47
    Alignof=48
    Inline=49
    Noreturn=50
    StaticAssert=51
    ThreadLocal=52
    LeftParen=53
    RightParen=54
    LeftBracket=55
    RightBracket=56
    LeftBrace=57
    RightBrace=58
    LeftShift=59
    RightShift=60
    Plus=61
    PlusPlus=62
    Minus=63
    MinusMinus=64
    Star=65
    Div=66
    Mod=67
    And=68
    Or=69
    AndAnd=70
    OrOr=71
    Caret=72
    Not=73
    Tilde=74
    DecoratorSign=75
    LambdaStartBlock=76
    Question=77
    Colon=78
    Semi=79
    Comma=80
    Assign=81
    StarAssign=82
    DivAssign=83
    ModAssign=84
    PlusAssign=85
    MinusAssign=86
    LeftShiftAssign=87
    RightShiftAssign=88
    AndAssign=89
    XorAssign=90
    OrAssign=91
    Equal=92
    NotEqual=93
    Less=94
    LessEqual=95
    Greater=96
    GreaterEqual=97
    Arrow=98
    Dot=99
    Ellipsis=100
    Identifier=101
    Constant=102
    DigitSequence=103
    StringLiteral=104
    AsmBlock=105
    Directive=106
    WS=107
    Whitespace=108
    Newline=109

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




    class PrimaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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


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

        def lambdaFunction(self):
            return self.getTypedRuleContext(ParaParser.LambdaFunctionContext,0)


        def getRuleIndex(self):
            return ParaParser.RULE_primaryExpression

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

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




    def primaryExpression(self):

        localctx = ParaParser.PrimaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_primaryExpression)
        try:
            self.state = 200
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 188
                self.match(ParaParser.Identifier)
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 191 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 190
                        self.match(ParaParser.StringLiteral)

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

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 195
                self.match(ParaParser.LeftParen)
                self.state = 196
                self.expression()
                self.state = 197
                self.match(ParaParser.RightParen)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 199
                self.lambdaFunction()
                pass


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


    class LambdaFunctionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def lambdaBody(self):
            return self.getTypedRuleContext(ParaParser.LambdaBodyContext,0)


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_lambdaFunction

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

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




    def lambdaFunction(self):

        localctx = ParaParser.LambdaFunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_lambdaFunction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 202
            self.match(ParaParser.LeftParen)
            self.state = 206
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 203
                    self.match(ParaParser.WS) 
                self.state = 208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

            self.state = 210
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier:
                self.state = 209
                self.parameterList()


            self.state = 215
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 212
                self.match(ParaParser.WS)
                self.state = 217
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 218
            self.match(ParaParser.RightParen)
            self.state = 222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 219
                self.match(ParaParser.WS)
                self.state = 224
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class LambdaBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expressionLambda(self):
            return self.getTypedRuleContext(ParaParser.ExpressionLambdaContext,0)


        def statementLambda(self):
            return self.getTypedRuleContext(ParaParser.StatementLambdaContext,0)


        def getRuleIndex(self):
            return ParaParser.RULE_lambdaBody

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

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




    def lambdaBody(self):

        localctx = ParaParser.LambdaBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_lambdaBody)
        try:
            self.state = 229
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 227
                self.expressionLambda()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 228
                self.statementLambda()
                pass


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


    class ExpressionLambdaContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LambdaStartBlock(self):
            return self.getToken(ParaParser.LambdaStartBlock, 0)

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_expressionLambda

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

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




    def expressionLambda(self):

        localctx = ParaParser.ExpressionLambdaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_expressionLambda)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 231
            self.match(ParaParser.LambdaStartBlock)
            self.state = 235
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 232
                    self.match(ParaParser.WS) 
                self.state = 237
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

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


    class StatementLambdaContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LambdaStartBlock(self):
            return self.getToken(ParaParser.LambdaStartBlock, 0)

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_statementLambda

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

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




    def statementLambda(self):

        localctx = ParaParser.StatementLambdaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_statementLambda)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 240
            self.match(ParaParser.LambdaStartBlock)
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 241
                self.match(ParaParser.WS)
                self.state = 246
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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

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

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

        def Spawn(self):
            return self.getToken(ParaParser.Spawn, 0)

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_postfixExpression

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

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




    def postfixExpression(self):

        localctx = ParaParser.PostfixExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_postfixExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 305
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.state = 250
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.Spawn:
                    self.state = 249
                    self.match(ParaParser.Spawn)


                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 252
                    self.match(ParaParser.WS)
                    self.state = 257
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 258
                self.primaryExpression()
                pass

            elif la_ == 2:
                self.state = 259
                self.match(ParaParser.LeftParen)
                self.state = 263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 260
                    self.match(ParaParser.WS)
                    self.state = 265
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 266
                self.typeName()
                self.state = 270
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 267
                    self.match(ParaParser.WS)
                    self.state = 272
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 273
                self.match(ParaParser.RightParen)
                self.state = 277
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 274
                    self.match(ParaParser.WS)
                    self.state = 279
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 280
                self.match(ParaParser.LeftBrace)
                self.state = 284
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 281
                        self.match(ParaParser.WS) 
                    self.state = 286
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,14,self._ctx)

                self.state = 287
                self.initializerList()
                self.state = 291
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 288
                        self.match(ParaParser.WS) 
                    self.state = 293
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,15,self._ctx)

                self.state = 295
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.Comma:
                    self.state = 294
                    self.match(ParaParser.Comma)


                self.state = 300
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 297
                    self.match(ParaParser.WS)
                    self.state = 302
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 303
                self.match(ParaParser.RightBrace)
                pass


            self.state = 310
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 307
                    self.match(ParaParser.WS) 
                self.state = 312
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,19,self._ctx)

            self.state = 357
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 355
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [ParaParser.LeftBracket]:
                        self.state = 313
                        self.match(ParaParser.LeftBracket)
                        self.state = 317
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,20,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 314
                                self.match(ParaParser.WS) 
                            self.state = 319
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,20,self._ctx)

                        self.state = 320
                        self.expression()
                        self.state = 324
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 321
                            self.match(ParaParser.WS)
                            self.state = 326
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 327
                        self.match(ParaParser.RightBracket)
                        pass
                    elif token in [ParaParser.LeftParen]:
                        self.state = 329
                        self.match(ParaParser.LeftParen)
                        self.state = 333
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 330
                                self.match(ParaParser.WS) 
                            self.state = 335
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

                        self.state = 337
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
                        if la_ == 1:
                            self.state = 336
                            self.argumentExpressionList()


                        self.state = 342
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 339
                            self.match(ParaParser.WS)
                            self.state = 344
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 345
                        self.match(ParaParser.RightParen)
                        pass
                    elif token in [ParaParser.Arrow, ParaParser.Dot]:
                        self.state = 346
                        _la = self._input.LA(1)
                        if not(_la==ParaParser.Arrow or _la==ParaParser.Dot):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 350
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 347
                            self.match(ParaParser.WS)
                            self.state = 352
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 353
                        self.match(ParaParser.Identifier)
                        pass
                    elif token in [ParaParser.PlusPlus, ParaParser.MinusMinus]:
                        self.state = 354
                        _la = self._input.LA(1)
                        if not(_la==ParaParser.PlusPlus or _la==ParaParser.MinusMinus):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 359
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,27,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 ArgumentExpressionListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_argumentExpressionList

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

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




    def argumentExpressionList(self):

        localctx = ParaParser.ArgumentExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_argumentExpressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 360
            self.assignmentExpression()
            self.state = 364
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 361
                    self.match(ParaParser.WS) 
                self.state = 366
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,28,self._ctx)

            self.state = 383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.Comma:
                self.state = 367
                self.match(ParaParser.Comma)
                self.state = 371
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 368
                        self.match(ParaParser.WS) 
                    self.state = 373
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,29,self._ctx)

                self.state = 374
                self.assignmentExpression()
                self.state = 378
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,30,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 375
                        self.match(ParaParser.WS) 
                    self.state = 380
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,30,self._ctx)

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

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


    class UnaryExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def castOrConvertExpression(self):
            return self.getTypedRuleContext(ParaParser.CastOrConvertExpressionContext,0)


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

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


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

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

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_unaryExpression

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

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




    def unaryExpression(self):

        localctx = ParaParser.UnaryExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_unaryExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 389
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 386
                    _la = self._input.LA(1)
                    if not(((((_la - 43)) & ~0x3f) == 0 and ((1 << (_la - 43)) & ((1 << (ParaParser.Sizeof - 43)) | (1 << (ParaParser.PlusPlus - 43)) | (1 << (ParaParser.MinusMinus - 43)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume() 
                self.state = 391
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,32,self._ctx)

            self.state = 395
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 392
                    self.match(ParaParser.WS) 
                self.state = 397
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,33,self._ctx)

            self.state = 431
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Spawn, ParaParser.LeftParen, ParaParser.Identifier, ParaParser.Constant, ParaParser.StringLiteral, ParaParser.WS]:
                self.state = 398
                self.postfixExpression()
                pass
            elif token in [ParaParser.Plus, ParaParser.Minus, ParaParser.Star, ParaParser.And, ParaParser.Not, ParaParser.Tilde]:
                self.state = 399
                self.unaryOperator()
                self.state = 403
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 400
                        self.match(ParaParser.WS) 
                    self.state = 405
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

                self.state = 406
                self.castOrConvertExpression(0)
                pass
            elif token in [ParaParser.Sizeof, ParaParser.Alignof]:
                self.state = 408
                _la = self._input.LA(1)
                if not(_la==ParaParser.Sizeof or _la==ParaParser.Alignof):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 412
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 409
                    self.match(ParaParser.WS)
                    self.state = 414
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 415
                self.match(ParaParser.LeftParen)
                self.state = 419
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 416
                    self.match(ParaParser.WS)
                    self.state = 421
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 422
                self.typeName()
                self.state = 426
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 423
                    self.match(ParaParser.WS)
                    self.state = 428
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 429
                self.match(ParaParser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

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


    class UnaryOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_unaryOperator

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

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




    def unaryOperator(self):

        localctx = ParaParser.UnaryOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_unaryOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 433
            _la = self._input.LA(1)
            if not(((((_la - 61)) & ~0x3f) == 0 and ((1 << (_la - 61)) & ((1 << (ParaParser.Plus - 61)) | (1 << (ParaParser.Minus - 61)) | (1 << (ParaParser.Star - 61)) | (1 << (ParaParser.And - 61)) | (1 << (ParaParser.Not - 61)) | (1 << (ParaParser.Tilde - 61)))) != 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 CastOrConvertExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def castOrConvertExpression(self):
            return self.getTypedRuleContext(ParaParser.CastOrConvertExpressionContext,0)


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

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


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

        def As(self):
            return self.getToken(ParaParser.As, 0)

        def getRuleIndex(self):
            return ParaParser.RULE_castOrConvertExpression

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

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



    def castOrConvertExpression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ParaParser.CastOrConvertExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 18
        self.enterRecursionRule(localctx, 18, self.RULE_castOrConvertExpression, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 461
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 436
                self.match(ParaParser.LeftParen)
                self.state = 440
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 437
                    self.match(ParaParser.WS)
                    self.state = 442
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 443
                self.typeName()
                self.state = 447
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 444
                    self.match(ParaParser.WS)
                    self.state = 449
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 450
                self.match(ParaParser.RightParen)
                self.state = 454
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 451
                        self.match(ParaParser.WS) 
                    self.state = 456
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

                self.state = 457
                self.castOrConvertExpression(4)
                pass

            elif la_ == 2:
                self.state = 459
                self.unaryExpression()
                pass

            elif la_ == 3:
                self.state = 460
                self.match(ParaParser.DigitSequence)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 480
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,45,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 = ParaParser.CastOrConvertExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_castOrConvertExpression)
                    self.state = 463
                    if not self.precpred(self._ctx, 3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                    self.state = 467
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 464
                        self.match(ParaParser.WS)
                        self.state = 469
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 470
                    self.match(ParaParser.As)
                    self.state = 474
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 471
                        self.match(ParaParser.WS)
                        self.state = 476
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 477
                    self.typeName() 
                self.state = 482
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,45,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 MultiplicativeExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def castOrConvertExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.CastOrConvertExpressionContext)
            else:
                return self.getTypedRuleContext(ParaParser.CastOrConvertExpressionContext,i)


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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_multiplicativeExpression

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

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




    def multiplicativeExpression(self):

        localctx = ParaParser.MultiplicativeExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_multiplicativeExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 483
            self.castOrConvertExpression(0)
            self.state = 487
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 484
                    self.match(ParaParser.WS) 
                self.state = 489
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,46,self._ctx)

            self.state = 506
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,49,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 490
                    _la = self._input.LA(1)
                    if not(((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (ParaParser.Star - 65)) | (1 << (ParaParser.Div - 65)) | (1 << (ParaParser.Mod - 65)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 494
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,47,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 491
                            self.match(ParaParser.WS) 
                        self.state = 496
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,47,self._ctx)

                    self.state = 497
                    self.castOrConvertExpression(0)
                    self.state = 501
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,48,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 498
                            self.match(ParaParser.WS) 
                        self.state = 503
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,48,self._ctx)
             
                self.state = 508
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,49,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 AdditiveExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_additiveExpression

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

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




    def additiveExpression(self):

        localctx = ParaParser.AdditiveExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_additiveExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 509
            self.multiplicativeExpression()
            self.state = 513
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,50,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 510
                    self.match(ParaParser.WS) 
                self.state = 515
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,50,self._ctx)

            self.state = 532
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,53,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 516
                    _la = self._input.LA(1)
                    if not(_la==ParaParser.Plus or _la==ParaParser.Minus):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 520
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,51,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 517
                            self.match(ParaParser.WS) 
                        self.state = 522
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,51,self._ctx)

                    self.state = 523
                    self.multiplicativeExpression()
                    self.state = 527
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 524
                            self.match(ParaParser.WS) 
                        self.state = 529
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
             
                self.state = 534
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,53,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 ShiftExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_shiftExpression

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

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




    def shiftExpression(self):

        localctx = ParaParser.ShiftExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_shiftExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 535
            self.additiveExpression()
            self.state = 539
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,54,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 536
                    self.match(ParaParser.WS) 
                self.state = 541
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,54,self._ctx)

            self.state = 558
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 542
                    _la = self._input.LA(1)
                    if not(_la==ParaParser.LeftShift or _la==ParaParser.RightShift):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 546
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,55,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 543
                            self.match(ParaParser.WS) 
                        self.state = 548
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,55,self._ctx)

                    self.state = 549
                    self.additiveExpression()
                    self.state = 553
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,56,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 550
                            self.match(ParaParser.WS) 
                        self.state = 555
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,56,self._ctx)
             
                self.state = 560
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,57,self._ctx)

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


    class RelationalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_relationalExpression

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

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




    def relationalExpression(self):

        localctx = ParaParser.RelationalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_relationalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 561
            self.shiftExpression()
            self.state = 565
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,58,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 562
                    self.match(ParaParser.WS) 
                self.state = 567
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,58,self._ctx)

            self.state = 584
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 568
                    _la = self._input.LA(1)
                    if not(((((_la - 94)) & ~0x3f) == 0 and ((1 << (_la - 94)) & ((1 << (ParaParser.Less - 94)) | (1 << (ParaParser.LessEqual - 94)) | (1 << (ParaParser.Greater - 94)) | (1 << (ParaParser.GreaterEqual - 94)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 572
                    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 = 569
                            self.match(ParaParser.WS) 
                        self.state = 574
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,59,self._ctx)

                    self.state = 575
                    self.shiftExpression()
                    self.state = 579
                    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 = 576
                            self.match(ParaParser.WS) 
                        self.state = 581
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,60,self._ctx)
             
                self.state = 586
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,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 EqualityExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_equalityExpression

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

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




    def equalityExpression(self):

        localctx = ParaParser.EqualityExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_equalityExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 587
            self.relationalExpression()
            self.state = 591
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 588
                    self.match(ParaParser.WS) 
                self.state = 593
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,62,self._ctx)

            self.state = 610
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 594
                    _la = self._input.LA(1)
                    if not(_la==ParaParser.Equal or _la==ParaParser.NotEqual):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 598
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,63,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 595
                            self.match(ParaParser.WS) 
                        self.state = 600
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,63,self._ctx)

                    self.state = 601
                    self.relationalExpression()
                    self.state = 605
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,64,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 602
                            self.match(ParaParser.WS) 
                        self.state = 607
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,64,self._ctx)
             
                self.state = 612
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,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 AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_andExpression

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

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




    def andExpression(self):

        localctx = ParaParser.AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_andExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 613
            self.equalityExpression()
            self.state = 617
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 614
                    self.match(ParaParser.WS) 
                self.state = 619
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)

            self.state = 636
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,69,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 620
                    self.match(ParaParser.And)
                    self.state = 624
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,67,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 621
                            self.match(ParaParser.WS) 
                        self.state = 626
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,67,self._ctx)

                    self.state = 627
                    self.equalityExpression()
                    self.state = 631
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,68,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 628
                            self.match(ParaParser.WS) 
                        self.state = 633
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,68,self._ctx)
             
                self.state = 638
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,69,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 ExclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_exclusiveOrExpression

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

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




    def exclusiveOrExpression(self):

        localctx = ParaParser.ExclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_exclusiveOrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.andExpression()
            self.state = 643
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,70,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 640
                    self.match(ParaParser.WS) 
                self.state = 645
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,70,self._ctx)

            self.state = 662
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,73,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 646
                    self.match(ParaParser.Caret)
                    self.state = 650
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,71,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 647
                            self.match(ParaParser.WS) 
                        self.state = 652
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,71,self._ctx)

                    self.state = 653
                    self.andExpression()
                    self.state = 657
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,72,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 654
                            self.match(ParaParser.WS) 
                        self.state = 659
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,72,self._ctx)
             
                self.state = 664
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,73,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 InclusiveOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_inclusiveOrExpression

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

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




    def inclusiveOrExpression(self):

        localctx = ParaParser.InclusiveOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_inclusiveOrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.exclusiveOrExpression()
            self.state = 669
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,74,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 666
                    self.match(ParaParser.WS) 
                self.state = 671
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,74,self._ctx)

            self.state = 688
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,77,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 672
                    self.match(ParaParser.Or)
                    self.state = 676
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 673
                            self.match(ParaParser.WS) 
                        self.state = 678
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,75,self._ctx)

                    self.state = 679
                    self.exclusiveOrExpression()
                    self.state = 683
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 680
                            self.match(ParaParser.WS) 
                        self.state = 685
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
             
                self.state = 690
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,77,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 LogicalAndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_logicalAndExpression

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

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




    def logicalAndExpression(self):

        localctx = ParaParser.LogicalAndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_logicalAndExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 691
            self.inclusiveOrExpression()
            self.state = 695
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 692
                    self.match(ParaParser.WS) 
                self.state = 697
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,78,self._ctx)

            self.state = 714
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,81,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 698
                    self.match(ParaParser.AndAnd)
                    self.state = 702
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,79,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 699
                            self.match(ParaParser.WS) 
                        self.state = 704
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,79,self._ctx)

                    self.state = 705
                    self.inclusiveOrExpression()
                    self.state = 709
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,80,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 706
                            self.match(ParaParser.WS) 
                        self.state = 711
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,80,self._ctx)
             
                self.state = 716
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,81,self._ctx)

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


    class LogicalOrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_logicalOrExpression

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

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




    def logicalOrExpression(self):

        localctx = ParaParser.LogicalOrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_logicalOrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 717
            self.logicalAndExpression()
            self.state = 721
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,82,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 718
                    self.match(ParaParser.WS) 
                self.state = 723
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,82,self._ctx)

            self.state = 740
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 724
                    self.match(ParaParser.OrOr)
                    self.state = 728
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,83,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 725
                            self.match(ParaParser.WS) 
                        self.state = 730
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,83,self._ctx)

                    self.state = 731
                    self.logicalAndExpression()
                    self.state = 735
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,84,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 732
                            self.match(ParaParser.WS) 
                        self.state = 737
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,84,self._ctx)
             
                self.state = 742
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,85,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 ConditionalExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_conditionalExpression

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

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




    def conditionalExpression(self):

        localctx = ParaParser.ConditionalExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_conditionalExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 743
            self.logicalOrExpression()
            self.state = 747
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,86,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 744
                    self.match(ParaParser.WS) 
                self.state = 749
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,86,self._ctx)

            self.state = 778
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,91,self._ctx)
            if la_ == 1:
                self.state = 750
                self.match(ParaParser.Question)
                self.state = 754
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,87,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 751
                        self.match(ParaParser.WS) 
                    self.state = 756
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,87,self._ctx)

                self.state = 757
                self.expression()
                self.state = 761
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 758
                    self.match(ParaParser.WS)
                    self.state = 763
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 764
                self.match(ParaParser.Colon)
                self.state = 768
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,89,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 765
                        self.match(ParaParser.WS) 
                    self.state = 770
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,89,self._ctx)

                self.state = 771
                self.conditionalExpression()
                self.state = 775
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,90,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 772
                        self.match(ParaParser.WS) 
                    self.state = 777
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,90,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 AssignmentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_assignmentExpression

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

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




    def assignmentExpression(self):

        localctx = ParaParser.AssignmentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_assignmentExpression)
        self._la = 0 # Token type
        try:
            self.state = 798
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 780
                self.conditionalExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 781
                self.unaryExpression()
                self.state = 785
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 782
                    self.match(ParaParser.WS)
                    self.state = 787
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 788
                self.assignmentOperator()
                self.state = 792
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,93,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 789
                        self.match(ParaParser.WS) 
                    self.state = 794
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,93,self._ctx)

                self.state = 795
                self.assignmentExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 797
                self.match(ParaParser.DigitSequence)
                pass


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


    class AssignmentOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_assignmentOperator

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

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




    def assignmentOperator(self):

        localctx = ParaParser.AssignmentOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_assignmentOperator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 800
            _la = self._input.LA(1)
            if not(((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & ((1 << (ParaParser.Assign - 81)) | (1 << (ParaParser.StarAssign - 81)) | (1 << (ParaParser.DivAssign - 81)) | (1 << (ParaParser.ModAssign - 81)) | (1 << (ParaParser.PlusAssign - 81)) | (1 << (ParaParser.MinusAssign - 81)) | (1 << (ParaParser.LeftShiftAssign - 81)) | (1 << (ParaParser.RightShiftAssign - 81)) | (1 << (ParaParser.AndAssign - 81)) | (1 << (ParaParser.XorAssign - 81)) | (1 << (ParaParser.OrAssign - 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


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_expression

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

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




    def expression(self):

        localctx = ParaParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 802
            self.assignmentExpression()
            self.state = 806
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,95,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 803
                    self.match(ParaParser.WS) 
                self.state = 808
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,95,self._ctx)

            self.state = 825
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,98,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 809
                    self.match(ParaParser.Comma)
                    self.state = 813
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,96,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 810
                            self.match(ParaParser.WS) 
                        self.state = 815
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,96,self._ctx)

                    self.state = 816
                    self.assignmentExpression()
                    self.state = 820
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 817
                            self.match(ParaParser.WS) 
                        self.state = 822
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
             
                self.state = 827
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,98,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 ConstantExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_constantExpression

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

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




    def constantExpression(self):

        localctx = ParaParser.ConstantExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_constantExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 828
            self.conditionalExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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

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


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


        def getRuleIndex(self):
            return ParaParser.RULE_declaration

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

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




    def declaration(self):

        localctx = ParaParser.DeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_declaration)
        self._la = 0 # Token type
        try:
            self.state = 843
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Bool, ParaParser.Char, ParaParser.Complex, ParaParser.Double, ParaParser.Entry, ParaParser.Float, ParaParser.Int, ParaParser.Lambda, ParaParser.Long, ParaParser.Signed, ParaParser.Short, ParaParser.Status, ParaParser.Unsigned, ParaParser.Void, ParaParser.Const, ParaParser.Volatile, ParaParser.Atomic, ParaParser.Auto, ParaParser.Register, ParaParser.Static, ParaParser.Extern, ParaParser.Enum, ParaParser.Restrict, ParaParser.Struct, ParaParser.Typeof, ParaParser.Typedef, ParaParser.Union, ParaParser.Alignas, ParaParser.Noreturn, ParaParser.ThreadLocal, ParaParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 830
                self.declarationSpecifiers()
                self.state = 834
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,99,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 831
                        self.match(ParaParser.WS) 
                    self.state = 836
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,99,self._ctx)

                self.state = 838
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 53)) & ~0x3f) == 0 and ((1 << (_la - 53)) & ((1 << (ParaParser.LeftParen - 53)) | (1 << (ParaParser.Star - 53)) | (1 << (ParaParser.Caret - 53)) | (1 << (ParaParser.Identifier - 53)) | (1 << (ParaParser.WS - 53)))) != 0):
                    self.state = 837
                    self.initDeclaratorList()


                self.state = 840
                self.endOfItem()
                pass
            elif token in [ParaParser.StaticAssert]:
                self.enterOuterAlt(localctx, 2)
                self.state = 842
                self.staticAssertDeclaration()
                pass
            else:
                raise NoViableAltException(self)

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


    class DeclarationSpecifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_declarationSpecifiers

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

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




    def declarationSpecifiers(self):

        localctx = ParaParser.DeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_declarationSpecifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 852 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 845
                    self.declarationSpecifier()
                    self.state = 849
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,102,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 846
                            self.match(ParaParser.WS) 
                        self.state = 851
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,102,self._ctx)


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

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


    class DeclarationSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


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


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


        def getRuleIndex(self):
            return ParaParser.RULE_declarationSpecifier

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

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




    def declarationSpecifier(self):

        localctx = ParaParser.DeclarationSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_declarationSpecifier)
        try:
            self.state = 861
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 856
                self.storageClassSpecifier()
                pass

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

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

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

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


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


    class InitDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_initDeclaratorList

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

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




    def initDeclaratorList(self):

        localctx = ParaParser.InitDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_initDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 863
            self.initDeclarator()
            self.state = 867
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 864
                self.match(ParaParser.WS)
                self.state = 869
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 886
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.Comma:
                self.state = 870
                self.match(ParaParser.Comma)
                self.state = 874
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,106,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 871
                        self.match(ParaParser.WS) 
                    self.state = 876
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,106,self._ctx)

                self.state = 877
                self.initDeclarator()
                self.state = 881
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 878
                    self.match(ParaParser.WS)
                    self.state = 883
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

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

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

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


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

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_initDeclarator

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

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




    def initDeclarator(self):

        localctx = ParaParser.InitDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_initDeclarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 889
            self.declarator()
            self.state = 893
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,109,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 890
                    self.match(ParaParser.WS) 
                self.state = 895
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,109,self._ctx)

            self.state = 910
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.Assign:
                self.state = 896
                self.match(ParaParser.Assign)
                self.state = 900
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,110,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 897
                        self.match(ParaParser.WS) 
                    self.state = 902
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,110,self._ctx)

                self.state = 903
                self.initializer()
                self.state = 907
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,111,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 904
                        self.match(ParaParser.WS) 
                    self.state = 909
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,111,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 StorageClassSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_storageClassSpecifier

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

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




    def storageClassSpecifier(self):

        localctx = ParaParser.StorageClassSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_storageClassSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 912
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Typedef) | (1 << ParaParser.ThreadLocal))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArraySpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_arraySpecifier

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

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




    def arraySpecifier(self):

        localctx = ParaParser.ArraySpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_arraySpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1020
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,130,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 914
                self.match(ParaParser.LeftBracket)
                self.state = 918
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,113,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 915
                        self.match(ParaParser.WS) 
                    self.state = 920
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,113,self._ctx)

                self.state = 922
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                    self.state = 921
                    self.typeQualifierList()


                self.state = 927
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,115,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 924
                        self.match(ParaParser.WS) 
                    self.state = 929
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,115,self._ctx)

                self.state = 931
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
                if la_ == 1:
                    self.state = 930
                    self.assignmentExpression()


                self.state = 936
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 933
                    self.match(ParaParser.WS)
                    self.state = 938
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 939
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 940
                self.match(ParaParser.LeftBracket)
                self.state = 944
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 941
                    self.match(ParaParser.WS)
                    self.state = 946
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 947
                self.match(ParaParser.Static)
                self.state = 951
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,119,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 948
                        self.match(ParaParser.WS) 
                    self.state = 953
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,119,self._ctx)

                self.state = 955
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                    self.state = 954
                    self.typeQualifierList()


                self.state = 960
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,121,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 957
                        self.match(ParaParser.WS) 
                    self.state = 962
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,121,self._ctx)

                self.state = 963
                self.assignmentExpression()
                self.state = 967
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 964
                    self.match(ParaParser.WS)
                    self.state = 969
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 970
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 972
                self.match(ParaParser.LeftBracket)
                self.state = 976
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 973
                    self.match(ParaParser.WS)
                    self.state = 978
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 979
                self.typeQualifierList()
                self.state = 983
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 980
                    self.match(ParaParser.WS)
                    self.state = 985
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 986
                self.match(ParaParser.Static)
                self.state = 987
                self.assignmentExpression()
                self.state = 991
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 988
                    self.match(ParaParser.WS)
                    self.state = 993
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 994
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 996
                self.match(ParaParser.LeftBracket)
                self.state = 1000
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,126,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 997
                        self.match(ParaParser.WS) 
                    self.state = 1002
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,126,self._ctx)

                self.state = 1004
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                    self.state = 1003
                    self.typeQualifierList()


                self.state = 1009
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1006
                    self.match(ParaParser.WS)
                    self.state = 1011
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1012
                self.match(ParaParser.Star)
                self.state = 1016
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1013
                    self.match(ParaParser.WS)
                    self.state = 1018
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1019
                self.match(ParaParser.RightBracket)
                pass


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


    class TypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def Status(self):
            return self.getToken(ParaParser.Status, 0)

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

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

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

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

        def Lambda(self):
            return self.getToken(ParaParser.Lambda, 0)

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

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


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

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

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

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

        def arraySpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.ArraySpecifierContext)
            else:
                return self.getTypedRuleContext(ParaParser.ArraySpecifierContext,i)


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

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


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


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


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


        def Typeof(self):
            return self.getToken(ParaParser.Typeof, 0)

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

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


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

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


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


        def getRuleIndex(self):
            return ParaParser.RULE_typeSpecifier

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

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



    def typeSpecifier(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ParaParser.TypeSpecifierContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 64
        self.enterRecursionRule(localctx, 64, self.RULE_typeSpecifier, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1093
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Bool, ParaParser.Char, ParaParser.Complex, ParaParser.Double, ParaParser.Float, ParaParser.Int, ParaParser.Lambda, ParaParser.Long, ParaParser.Signed, ParaParser.Short, ParaParser.Status, ParaParser.Unsigned, ParaParser.Void]:
                self.state = 1058
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [ParaParser.Void]:
                    self.state = 1023
                    self.match(ParaParser.Void)
                    pass
                elif token in [ParaParser.Char]:
                    self.state = 1024
                    self.match(ParaParser.Char)
                    pass
                elif token in [ParaParser.Short]:
                    self.state = 1025
                    self.match(ParaParser.Short)
                    pass
                elif token in [ParaParser.Int]:
                    self.state = 1026
                    self.match(ParaParser.Int)
                    pass
                elif token in [ParaParser.Status]:
                    self.state = 1027
                    self.match(ParaParser.Status)
                    pass
                elif token in [ParaParser.Long]:
                    self.state = 1028
                    self.match(ParaParser.Long)
                    pass
                elif token in [ParaParser.Float]:
                    self.state = 1029
                    self.match(ParaParser.Float)
                    pass
                elif token in [ParaParser.Double]:
                    self.state = 1030
                    self.match(ParaParser.Double)
                    pass
                elif token in [ParaParser.Signed]:
                    self.state = 1031
                    self.match(ParaParser.Signed)
                    pass
                elif token in [ParaParser.Lambda]:
                    self.state = 1032
                    self.match(ParaParser.Lambda)
                    self.state = 1036
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1033
                        self.match(ParaParser.WS)
                        self.state = 1038
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1039
                    self.match(ParaParser.Less)
                    self.state = 1043
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1040
                        self.match(ParaParser.WS)
                        self.state = 1045
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1046
                    self.parameterTypeList()
                    self.state = 1050
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1047
                        self.match(ParaParser.WS)
                        self.state = 1052
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1053
                    self.match(ParaParser.Greater)
                    pass
                elif token in [ParaParser.Unsigned]:
                    self.state = 1055
                    self.match(ParaParser.Unsigned)
                    pass
                elif token in [ParaParser.Bool]:
                    self.state = 1056
                    self.match(ParaParser.Bool)
                    pass
                elif token in [ParaParser.Complex]:
                    self.state = 1057
                    self.match(ParaParser.Complex)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1063
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,135,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1060
                        self.arraySpecifier() 
                    self.state = 1065
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,135,self._ctx)

                pass
            elif token in [ParaParser.Atomic]:
                self.state = 1066
                self.atomicTypeSpecifier()
                pass
            elif token in [ParaParser.Struct, ParaParser.Union]:
                self.state = 1067
                self.structOrUnionSpecifier()
                pass
            elif token in [ParaParser.Enum]:
                self.state = 1068
                self.enumSpecifier()
                pass
            elif token in [ParaParser.Identifier]:
                self.state = 1069
                self.typedefName()
                pass
            elif token in [ParaParser.Typeof]:
                self.state = 1070
                self.match(ParaParser.Typeof)
                self.state = 1074
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1071
                    self.match(ParaParser.WS)
                    self.state = 1076
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1077
                self.match(ParaParser.LeftParen)
                self.state = 1081
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,137,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1078
                        self.match(ParaParser.WS) 
                    self.state = 1083
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,137,self._ctx)

                self.state = 1084
                self.constantExpression()
                self.state = 1088
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1085
                    self.match(ParaParser.WS)
                    self.state = 1090
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1091
                self.match(ParaParser.RightParen)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1105
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,141,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = ParaParser.TypeSpecifierContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_typeSpecifier)
                    self.state = 1095
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 1099
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1096
                        self.match(ParaParser.WS)
                        self.state = 1101
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1102
                    self.pointer() 
                self.state = 1107
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,141,self._ctx)

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


    class StructOrUnionSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

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

        def structDeclarationList(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.StructDeclarationListContext)
            else:
                return self.getTypedRuleContext(ParaParser.StructDeclarationListContext,i)


        def getRuleIndex(self):
            return ParaParser.RULE_structOrUnionSpecifier

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

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




    def structOrUnionSpecifier(self):

        localctx = ParaParser.StructOrUnionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_structOrUnionSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1154
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,149,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1108
                self.structOrUnion()
                self.state = 1112
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1109
                    self.match(ParaParser.WS)
                    self.state = 1114
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1122
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.Identifier:
                    self.state = 1115
                    self.match(ParaParser.Identifier)
                    self.state = 1119
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1116
                        self.match(ParaParser.WS)
                        self.state = 1121
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1124
                self.match(ParaParser.LeftBrace)
                self.state = 1128
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1125
                        self.match(ParaParser.WS) 
                    self.state = 1130
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,145,self._ctx)

                self.state = 1134
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,146,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1131
                        self.structDeclarationList() 
                    self.state = 1136
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,146,self._ctx)

                self.state = 1140
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1137
                    self.match(ParaParser.WS)
                    self.state = 1142
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1143
                self.match(ParaParser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1145
                self.structOrUnion()
                self.state = 1149
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1146
                    self.match(ParaParser.WS)
                    self.state = 1151
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1152
                self.match(ParaParser.Identifier)
                pass


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


    class StructOrUnionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_structOrUnion

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

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




    def structOrUnion(self):

        localctx = ParaParser.StructOrUnionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_structOrUnion)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1156
            _la = self._input.LA(1)
            if not(_la==ParaParser.Struct or _la==ParaParser.Union):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StructDeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_structDeclarationList

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

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




    def structDeclarationList(self):

        localctx = ParaParser.StructDeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_structDeclarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1171 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1161
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1158
                        self.match(ParaParser.WS)
                        self.state = 1163
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1164
                    self.structDeclaration()
                    self.state = 1168
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,151,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1165
                            self.match(ParaParser.WS) 
                        self.state = 1170
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,151,self._ctx)


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

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

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


        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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

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


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


        def getRuleIndex(self):
            return ParaParser.RULE_structDeclaration

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

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




    def structDeclaration(self):

        localctx = ParaParser.StructDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_structDeclaration)
        self._la = 0 # Token type
        try:
            self.state = 1188
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Bool, ParaParser.Char, ParaParser.Complex, ParaParser.Double, ParaParser.Float, ParaParser.Int, ParaParser.Lambda, ParaParser.Long, ParaParser.Signed, ParaParser.Short, ParaParser.Status, ParaParser.Unsigned, ParaParser.Void, ParaParser.Const, ParaParser.Volatile, ParaParser.Atomic, ParaParser.Enum, ParaParser.Restrict, ParaParser.Struct, ParaParser.Typeof, ParaParser.Union, ParaParser.Identifier]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1175
                self.specifierQualifierList()
                self.state = 1179
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,153,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1176
                        self.match(ParaParser.WS) 
                    self.state = 1181
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

                self.state = 1183
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 53)) & ~0x3f) == 0 and ((1 << (_la - 53)) & ((1 << (ParaParser.LeftParen - 53)) | (1 << (ParaParser.Star - 53)) | (1 << (ParaParser.Caret - 53)) | (1 << (ParaParser.Colon - 53)) | (1 << (ParaParser.Identifier - 53)) | (1 << (ParaParser.WS - 53)))) != 0):
                    self.state = 1182
                    self.structDeclaratorList()


                self.state = 1185
                self.endOfItem()
                pass
            elif token in [ParaParser.StaticAssert]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1187
                self.staticAssertDeclaration()
                pass
            else:
                raise NoViableAltException(self)

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


    class SpecifierQualifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_specifierQualifierList

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

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




    def specifierQualifierList(self):

        localctx = ParaParser.SpecifierQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_specifierQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1192
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
            if la_ == 1:
                self.state = 1190
                self.typeSpecifier(0)
                pass

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


            self.state = 1197
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,157,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1194
                    self.match(ParaParser.WS) 
                self.state = 1199
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,157,self._ctx)

            self.state = 1201
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
            if la_ == 1:
                self.state = 1200
                self.specifierQualifierList()


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


    class StructDeclaratorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_structDeclaratorList

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

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




    def structDeclaratorList(self):

        localctx = ParaParser.StructDeclaratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_structDeclaratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1203
            self.structDeclarator()
            self.state = 1207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1204
                self.match(ParaParser.WS)
                self.state = 1209
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1220
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.Comma:
                self.state = 1210
                self.match(ParaParser.Comma)
                self.state = 1214
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,160,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1211
                        self.match(ParaParser.WS) 
                    self.state = 1216
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,160,self._ctx)

                self.state = 1217
                self.structDeclarator()
                self.state = 1222
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class StructDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_structDeclarator

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

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




    def structDeclarator(self):

        localctx = ParaParser.StructDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_structDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1241
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1223
                self.declarator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1225
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
                if la_ == 1:
                    self.state = 1224
                    self.declarator()


                self.state = 1230
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1227
                    self.match(ParaParser.WS)
                    self.state = 1232
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1233
                self.match(ParaParser.Colon)
                self.state = 1237
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,164,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1234
                        self.match(ParaParser.WS) 
                    self.state = 1239
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,164,self._ctx)

                self.state = 1240
                self.constantExpression()
                pass


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


    class EnumSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_enumSpecifier

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

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




    def enumSpecifier(self):

        localctx = ParaParser.EnumSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_enumSpecifier)
        self._la = 0 # Token type
        try:
            self.state = 1292
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1243
                self.match(ParaParser.Enum)
                self.state = 1247
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,166,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1244
                        self.match(ParaParser.WS) 
                    self.state = 1249
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,166,self._ctx)

                self.state = 1251
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.Identifier:
                    self.state = 1250
                    self.match(ParaParser.Identifier)


                self.state = 1256
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1253
                    self.match(ParaParser.WS)
                    self.state = 1258
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1259
                self.match(ParaParser.LeftBrace)
                self.state = 1263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1260
                    self.match(ParaParser.WS)
                    self.state = 1265
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1266
                self.enumeratorList()
                self.state = 1270
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,170,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1267
                        self.match(ParaParser.WS) 
                    self.state = 1272
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,170,self._ctx)

                self.state = 1274
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.Comma:
                    self.state = 1273
                    self.match(ParaParser.Comma)


                self.state = 1279
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1276
                    self.match(ParaParser.WS)
                    self.state = 1281
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1282
                self.match(ParaParser.RightBrace)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1284
                self.match(ParaParser.Enum)
                self.state = 1288
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1285
                    self.match(ParaParser.WS)
                    self.state = 1290
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1291
                self.match(ParaParser.Identifier)
                pass


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


    class EnumeratorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_enumeratorList

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

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




    def enumeratorList(self):

        localctx = ParaParser.EnumeratorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_enumeratorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1294
            self.enumerator()
            self.state = 1298
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,175,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1295
                    self.match(ParaParser.WS) 
                self.state = 1300
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,175,self._ctx)

            self.state = 1317
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,178,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1301
                    self.match(ParaParser.Comma)
                    self.state = 1305
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1302
                        self.match(ParaParser.WS)
                        self.state = 1307
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1308
                    self.enumerator()
                    self.state = 1312
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,177,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1309
                            self.match(ParaParser.WS) 
                        self.state = 1314
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,177,self._ctx)
             
                self.state = 1319
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,178,self._ctx)

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


    class EnumeratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_enumerator

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

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




    def enumerator(self):

        localctx = ParaParser.EnumeratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_enumerator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1320
            self.enumerationConstant()
            self.state = 1324
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,179,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1321
                    self.match(ParaParser.WS) 
                self.state = 1326
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,179,self._ctx)

            self.state = 1341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.Assign:
                self.state = 1327
                self.match(ParaParser.Assign)
                self.state = 1331
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,180,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1328
                        self.match(ParaParser.WS) 
                    self.state = 1333
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,180,self._ctx)

                self.state = 1334
                self.constantExpression()
                self.state = 1338
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,181,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1335
                        self.match(ParaParser.WS) 
                    self.state = 1340
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,181,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 EnumerationConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_enumerationConstant

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

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




    def enumerationConstant(self):

        localctx = ParaParser.EnumerationConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_enumerationConstant)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1343
            self.match(ParaParser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AtomicTypeSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_atomicTypeSpecifier

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

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




    def atomicTypeSpecifier(self):

        localctx = ParaParser.AtomicTypeSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_atomicTypeSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1345
            self.match(ParaParser.Atomic)
            self.state = 1349
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1346
                self.match(ParaParser.WS)
                self.state = 1351
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1352
            self.match(ParaParser.LeftParen)
            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1353
                self.match(ParaParser.WS)
                self.state = 1358
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1359
            self.typeName()
            self.state = 1363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1360
                self.match(ParaParser.WS)
                self.state = 1365
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1366
            self.match(ParaParser.RightParen)
            self.state = 1370
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,186,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1367
                    self.match(ParaParser.WS) 
                self.state = 1372
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,186,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 TypeQualifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_typeQualifier

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

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




    def typeQualifier(self):

        localctx = ParaParser.TypeQualifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_typeQualifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1373
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FunctionSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def Entry(self):
            return self.getToken(ParaParser.Entry, 0)

        def getRuleIndex(self):
            return ParaParser.RULE_functionSpecifier

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

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




    def functionSpecifier(self):

        localctx = ParaParser.FunctionSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_functionSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1375
            _la = self._input.LA(1)
            if not(_la==ParaParser.Entry or _la==ParaParser.Noreturn):
                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 AlignmentSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


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


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

        def getRuleIndex(self):
            return ParaParser.RULE_alignmentSpecifier

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

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




    def alignmentSpecifier(self):

        localctx = ParaParser.AlignmentSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_alignmentSpecifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1377
            self.match(ParaParser.Alignas)
            self.state = 1381
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1378
                self.match(ParaParser.WS)
                self.state = 1383
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1384
            self.match(ParaParser.LeftParen)
            self.state = 1388
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,188,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1385
                    self.match(ParaParser.WS) 
                self.state = 1390
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,188,self._ctx)

            self.state = 1393
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
            if la_ == 1:
                self.state = 1391
                self.typeName()
                pass

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


            self.state = 1398
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1395
                self.match(ParaParser.WS)
                self.state = 1400
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class DeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def getRuleIndex(self):
            return ParaParser.RULE_declarator

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

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




    def declarator(self):

        localctx = ParaParser.DeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.Star or _la==ParaParser.Caret:
                self.state = 1403
                self.pointer()


            self.state = 1409
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 1406
                self.match(ParaParser.WS)
                self.state = 1411
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class DirectDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

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

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

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


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


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


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


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


        def getRuleIndex(self):
            return ParaParser.RULE_directDeclarator

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

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



    def directDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ParaParser.DirectDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 98
        self.enterRecursionRule(localctx, 98, self.RULE_directDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1479
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,202,self._ctx)
            if la_ == 1:
                self.state = 1415
                self.match(ParaParser.Identifier)
                pass

            elif la_ == 2:
                self.state = 1416
                self.match(ParaParser.LeftParen)
                self.state = 1420
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,193,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1417
                        self.match(ParaParser.WS) 
                    self.state = 1422
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,193,self._ctx)

                self.state = 1423
                self.declarator()
                self.state = 1427
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1424
                    self.match(ParaParser.WS)
                    self.state = 1429
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1430
                self.match(ParaParser.RightParen)
                pass

            elif la_ == 3:
                self.state = 1432
                self.match(ParaParser.Identifier)
                self.state = 1436
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1433
                    self.match(ParaParser.WS)
                    self.state = 1438
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1439
                self.match(ParaParser.Colon)
                self.state = 1443
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1440
                    self.match(ParaParser.WS)
                    self.state = 1445
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1446
                self.match(ParaParser.DigitSequence)
                pass

            elif la_ == 4:
                self.state = 1447
                self.match(ParaParser.LeftParen)
                self.state = 1451
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,197,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1448
                        self.match(ParaParser.WS) 
                    self.state = 1453
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,197,self._ctx)

                self.state = 1455
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Atomic) | (1 << ParaParser.Enum) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Union))) != 0) or _la==ParaParser.Identifier:
                    self.state = 1454
                    self.typeSpecifier(0)


                self.state = 1460
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1457
                    self.match(ParaParser.WS)
                    self.state = 1462
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1463
                self.pointer()
                self.state = 1467
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1464
                    self.match(ParaParser.WS)
                    self.state = 1469
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1470
                self.directDeclarator(0)
                self.state = 1474
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1471
                    self.match(ParaParser.WS)
                    self.state = 1476
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1477
                self.match(ParaParser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1530
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,211,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 = 1528
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
                    if la_ == 1:
                        localctx = ParaParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 1481
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1485
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1482
                            self.match(ParaParser.WS)
                            self.state = 1487
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1488
                        self.match(ParaParser.LeftParen)
                        self.state = 1492
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1489
                            self.match(ParaParser.WS)
                            self.state = 1494
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1495
                        self.parameterTypeList()
                        self.state = 1499
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1496
                            self.match(ParaParser.WS)
                            self.state = 1501
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1502
                        self.match(ParaParser.RightParen)
                        pass

                    elif la_ == 2:
                        localctx = ParaParser.DirectDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directDeclarator)
                        self.state = 1504
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1508
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1505
                            self.match(ParaParser.WS)
                            self.state = 1510
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1511
                        self.match(ParaParser.LeftParen)
                        self.state = 1515
                        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 = 1512
                                self.match(ParaParser.WS) 
                            self.state = 1517
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,207,self._ctx)

                        self.state = 1519
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==ParaParser.Identifier:
                            self.state = 1518
                            self.identifierList()


                        self.state = 1524
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1521
                            self.match(ParaParser.WS)
                            self.state = 1526
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1527
                        self.match(ParaParser.RightParen)
                        pass

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

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

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_nestedParenthesesBlock

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

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




    def nestedParenthesesBlock(self):

        localctx = ParaParser.NestedParenthesesBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_nestedParenthesesBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1552
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,215,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1550
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [ParaParser.T__0, ParaParser.T__1, ParaParser.T__2, ParaParser.Bool, ParaParser.Char, ParaParser.Complex, ParaParser.Double, ParaParser.Entry, ParaParser.Float, ParaParser.Imaginary, ParaParser.Int, ParaParser.Lambda, ParaParser.Long, ParaParser.Signed, ParaParser.Short, ParaParser.Status, ParaParser.Unsigned, ParaParser.Void, ParaParser.Const, ParaParser.Volatile, ParaParser.Atomic, ParaParser.As, ParaParser.Auto, ParaParser.Register, ParaParser.Static, ParaParser.Extern, ParaParser.Switch, ParaParser.Case, ParaParser.Default, ParaParser.Break, ParaParser.Continue, ParaParser.Do, ParaParser.While, ParaParser.If, ParaParser.Else, ParaParser.For, ParaParser.Enum, ParaParser.Restrict, ParaParser.Return, ParaParser.ExtensionTask, ParaParser.Spawn, ParaParser.Struct, ParaParser.Sizeof, ParaParser.Typeof, ParaParser.Typedef, ParaParser.Union, ParaParser.Alignas, ParaParser.Alignof, ParaParser.Inline, ParaParser.Noreturn, ParaParser.StaticAssert, ParaParser.ThreadLocal, ParaParser.LeftBracket, ParaParser.RightBracket, ParaParser.LeftBrace, ParaParser.RightBrace, ParaParser.LeftShift, ParaParser.RightShift, ParaParser.Plus, ParaParser.PlusPlus, ParaParser.Minus, ParaParser.MinusMinus, ParaParser.Star, ParaParser.Div, ParaParser.Mod, ParaParser.And, ParaParser.Or, ParaParser.AndAnd, ParaParser.OrOr, ParaParser.Caret, ParaParser.Not, ParaParser.Tilde, ParaParser.DecoratorSign, ParaParser.LambdaStartBlock, ParaParser.Question, ParaParser.Colon, ParaParser.Semi, ParaParser.Comma, ParaParser.Assign, ParaParser.StarAssign, ParaParser.DivAssign, ParaParser.ModAssign, ParaParser.PlusAssign, ParaParser.MinusAssign, ParaParser.LeftShiftAssign, ParaParser.RightShiftAssign, ParaParser.AndAssign, ParaParser.XorAssign, ParaParser.OrAssign, ParaParser.Equal, ParaParser.NotEqual, ParaParser.Less, ParaParser.LessEqual, ParaParser.Greater, ParaParser.GreaterEqual, ParaParser.Arrow, ParaParser.Dot, ParaParser.Ellipsis, ParaParser.Identifier, ParaParser.Constant, ParaParser.DigitSequence, ParaParser.StringLiteral, ParaParser.AsmBlock, ParaParser.Directive, ParaParser.WS, ParaParser.Whitespace, ParaParser.Newline]:
                        self.state = 1533
                        _la = self._input.LA(1)
                        if _la <= 0 or _la==ParaParser.LeftParen or _la==ParaParser.RightParen:
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass
                    elif token in [ParaParser.LeftParen]:
                        self.state = 1534
                        self.match(ParaParser.LeftParen)
                        self.state = 1538
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,212,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1535
                                self.match(ParaParser.WS) 
                            self.state = 1540
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,212,self._ctx)

                        self.state = 1541
                        self.nestedParenthesesBlock()
                        self.state = 1545
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1542
                            self.match(ParaParser.WS)
                            self.state = 1547
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1548
                        self.match(ParaParser.RightParen)
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1554
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,215,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 PointerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_pointer

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

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




    def pointer(self):

        localctx = ParaParser.PointerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_pointer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1571 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1555
                    _la = self._input.LA(1)
                    if not(_la==ParaParser.Star or _la==ParaParser.Caret):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1559
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,216,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1556
                            self.match(ParaParser.WS) 
                        self.state = 1561
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,216,self._ctx)

                    self.state = 1563
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
                    if la_ == 1:
                        self.state = 1562
                        self.typeQualifierList()


                    self.state = 1568
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,218,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1565
                            self.match(ParaParser.WS) 
                        self.state = 1570
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,218,self._ctx)


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

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


    class TypeQualifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_typeQualifierList

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

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




    def typeQualifierList(self):

        localctx = ParaParser.TypeQualifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_typeQualifierList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1576 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1575
                    self.typeQualifier()

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

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


    class ParameterTypeListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_parameterTypeList

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

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




    def parameterTypeList(self):

        localctx = ParaParser.ParameterTypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_parameterTypeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1580
            self.parameterList()
            self.state = 1584
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,221,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1581
                    self.match(ParaParser.WS) 
                self.state = 1586
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,221,self._ctx)

            self.state = 1601
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.Comma:
                self.state = 1587
                self.match(ParaParser.Comma)
                self.state = 1591
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1588
                    self.match(ParaParser.WS)
                    self.state = 1593
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1594
                self.match(ParaParser.Ellipsis)
                self.state = 1598
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,223,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1595
                        self.match(ParaParser.WS) 
                    self.state = 1600
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,223,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 ParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_parameterList

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

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




    def parameterList(self):

        localctx = ParaParser.ParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_parameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1603
            self.parameterDeclaration()
            self.state = 1607
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,225,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1604
                    self.match(ParaParser.WS) 
                self.state = 1609
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,225,self._ctx)

            self.state = 1626
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,228,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1610
                    self.match(ParaParser.Comma)
                    self.state = 1614
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 1611
                        self.match(ParaParser.WS)
                        self.state = 1616
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1617
                    self.parameterDeclaration()
                    self.state = 1621
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,227,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1618
                            self.match(ParaParser.WS) 
                        self.state = 1623
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,227,self._ctx)
             
                self.state = 1628
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,228,self._ctx)

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


    class ParameterDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return ParaParser.RULE_parameterDeclaration

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class AbstractParameterDeclarationContext(ParameterDeclarationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.ParameterDeclarationContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(ParaParser.WS)
            else:
                return self.getToken(ParaParser.WS, i)
        def abstractDeclarator(self):
            return self.getTypedRuleContext(ParaParser.AbstractDeclaratorContext,0)


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

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


    class RegularParameterDeclarationContext(ParameterDeclarationContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.ParameterDeclarationContext
            super().__init__(parser)
            self.copyFrom(ctx)

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

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

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

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

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



    def parameterDeclaration(self):

        localctx = ParaParser.ParameterDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_parameterDeclaration)
        try:
            self.state = 1648
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,232,self._ctx)
            if la_ == 1:
                localctx = ParaParser.RegularParameterDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1629
                self.declarationSpecifiers()
                self.state = 1633
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,229,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1630
                        self.match(ParaParser.WS) 
                    self.state = 1635
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,229,self._ctx)

                self.state = 1636
                self.declarator()
                pass

            elif la_ == 2:
                localctx = ParaParser.AbstractParameterDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1638
                self.declarationSpecifiers()
                self.state = 1642
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,230,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1639
                        self.match(ParaParser.WS) 
                    self.state = 1644
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,230,self._ctx)

                self.state = 1646
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,231,self._ctx)
                if la_ == 1:
                    self.state = 1645
                    self.abstractDeclarator()


                pass


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


    class IdentifierListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_identifierList

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

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




    def identifierList(self):

        localctx = ParaParser.IdentifierListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_identifierList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1650
            self.match(ParaParser.Identifier)
            self.state = 1654
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,233,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1651
                    self.match(ParaParser.WS) 
                self.state = 1656
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,233,self._ctx)

            self.state = 1673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.Comma:
                self.state = 1657
                self.match(ParaParser.Comma)
                self.state = 1661
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1658
                    self.match(ParaParser.WS)
                    self.state = 1663
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1664
                self.match(ParaParser.Identifier)
                self.state = 1668
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,235,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1665
                        self.match(ParaParser.WS) 
                    self.state = 1670
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,235,self._ctx)

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

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


    class TypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_typeName

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

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




    def typeName(self):

        localctx = ParaParser.TypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_typeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1676
            self.specifierQualifierList()
            self.state = 1680
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,237,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1677
                    self.match(ParaParser.WS) 
                self.state = 1682
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,237,self._ctx)

            self.state = 1684
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                self.state = 1683
                self.abstractDeclarator()


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


    class AbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def getRuleIndex(self):
            return ParaParser.RULE_abstractDeclarator

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

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




    def abstractDeclarator(self):

        localctx = ParaParser.AbstractDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_abstractDeclarator)
        self._la = 0 # Token type
        try:
            self.state = 1697
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,241,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1686
                self.pointer()
                pass

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


                self.state = 1693
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1690
                    self.match(ParaParser.WS)
                    self.state = 1695
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1696
                self.directAbstractDeclarator(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 DirectAbstractDeclaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

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

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


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


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

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

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


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


        def getRuleIndex(self):
            return ParaParser.RULE_directAbstractDeclarator

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

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



    def directAbstractDeclarator(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ParaParser.DirectAbstractDeclaratorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 118
        self.enterRecursionRule(localctx, 118, self.RULE_directAbstractDeclarator, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1836
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,263,self._ctx)
            if la_ == 1:
                self.state = 1700
                self.match(ParaParser.LeftParen)
                self.state = 1704
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,242,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1701
                        self.match(ParaParser.WS) 
                    self.state = 1706
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,242,self._ctx)

                self.state = 1707
                self.abstractDeclarator()
                self.state = 1711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1708
                    self.match(ParaParser.WS)
                    self.state = 1713
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1714
                self.match(ParaParser.RightParen)
                pass

            elif la_ == 2:
                self.state = 1716
                self.match(ParaParser.LeftBracket)
                self.state = 1720
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,244,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1717
                        self.match(ParaParser.WS) 
                    self.state = 1722
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,244,self._ctx)

                self.state = 1724
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                    self.state = 1723
                    self.typeQualifierList()


                self.state = 1729
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,246,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1726
                        self.match(ParaParser.WS) 
                    self.state = 1731
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,246,self._ctx)

                self.state = 1733
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,247,self._ctx)
                if la_ == 1:
                    self.state = 1732
                    self.assignmentExpression()


                self.state = 1738
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1735
                    self.match(ParaParser.WS)
                    self.state = 1740
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1741
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 3:
                self.state = 1742
                self.match(ParaParser.LeftBracket)
                self.state = 1746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1743
                    self.match(ParaParser.WS)
                    self.state = 1748
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1749
                self.match(ParaParser.Static)
                self.state = 1753
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,250,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1750
                        self.match(ParaParser.WS) 
                    self.state = 1755
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,250,self._ctx)

                self.state = 1757
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                    self.state = 1756
                    self.typeQualifierList()


                self.state = 1762
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,252,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1759
                        self.match(ParaParser.WS) 
                    self.state = 1764
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,252,self._ctx)

                self.state = 1765
                self.assignmentExpression()
                self.state = 1769
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1766
                    self.match(ParaParser.WS)
                    self.state = 1771
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1772
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 4:
                self.state = 1774
                self.match(ParaParser.LeftBracket)
                self.state = 1778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1775
                    self.match(ParaParser.WS)
                    self.state = 1780
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1781
                self.typeQualifierList()
                self.state = 1785
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1782
                    self.match(ParaParser.WS)
                    self.state = 1787
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1788
                self.match(ParaParser.Static)
                self.state = 1792
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,256,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1789
                        self.match(ParaParser.WS) 
                    self.state = 1794
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,256,self._ctx)

                self.state = 1795
                self.assignmentExpression()
                self.state = 1799
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1796
                    self.match(ParaParser.WS)
                    self.state = 1801
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1802
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 5:
                self.state = 1804
                self.match(ParaParser.LeftBracket)
                self.state = 1808
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1805
                    self.match(ParaParser.WS)
                    self.state = 1810
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1811
                self.match(ParaParser.Star)
                self.state = 1815
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1812
                    self.match(ParaParser.WS)
                    self.state = 1817
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1818
                self.match(ParaParser.RightBracket)
                pass

            elif la_ == 6:
                self.state = 1819
                self.match(ParaParser.LeftParen)
                self.state = 1823
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,260,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1820
                        self.match(ParaParser.WS) 
                    self.state = 1825
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,260,self._ctx)

                self.state = 1827
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier:
                    self.state = 1826
                    self.parameterTypeList()


                self.state = 1832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 1829
                    self.match(ParaParser.WS)
                    self.state = 1834
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1835
                self.match(ParaParser.RightParen)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1995
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,289,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 = 1993
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,288,self._ctx)
                    if la_ == 1:
                        localctx = ParaParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1838
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1842
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1839
                            self.match(ParaParser.WS)
                            self.state = 1844
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1845
                        self.match(ParaParser.LeftBracket)
                        self.state = 1849
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,265,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1846
                                self.match(ParaParser.WS) 
                            self.state = 1851
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,265,self._ctx)

                        self.state = 1853
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                            self.state = 1852
                            self.typeQualifierList()


                        self.state = 1858
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,267,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1855
                                self.match(ParaParser.WS) 
                            self.state = 1860
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,267,self._ctx)

                        self.state = 1862
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,268,self._ctx)
                        if la_ == 1:
                            self.state = 1861
                            self.assignmentExpression()


                        self.state = 1867
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1864
                            self.match(ParaParser.WS)
                            self.state = 1869
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1870
                        self.match(ParaParser.RightBracket)
                        pass

                    elif la_ == 2:
                        localctx = ParaParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1871
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1875
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1872
                            self.match(ParaParser.WS)
                            self.state = 1877
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1878
                        self.match(ParaParser.LeftBracket)
                        self.state = 1882
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1879
                            self.match(ParaParser.WS)
                            self.state = 1884
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1885
                        self.match(ParaParser.Static)
                        self.state = 1889
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,272,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1886
                                self.match(ParaParser.WS) 
                            self.state = 1891
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,272,self._ctx)

                        self.state = 1893
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Restrict))) != 0):
                            self.state = 1892
                            self.typeQualifierList()


                        self.state = 1898
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,274,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1895
                                self.match(ParaParser.WS) 
                            self.state = 1900
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,274,self._ctx)

                        self.state = 1901
                        self.assignmentExpression()
                        self.state = 1905
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1902
                            self.match(ParaParser.WS)
                            self.state = 1907
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1908
                        self.match(ParaParser.RightBracket)
                        pass

                    elif la_ == 3:
                        localctx = ParaParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1910
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1914
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1911
                            self.match(ParaParser.WS)
                            self.state = 1916
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1917
                        self.match(ParaParser.LeftBracket)
                        self.state = 1921
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1918
                            self.match(ParaParser.WS)
                            self.state = 1923
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1924
                        self.typeQualifierList()
                        self.state = 1928
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1925
                            self.match(ParaParser.WS)
                            self.state = 1930
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1931
                        self.match(ParaParser.Static)
                        self.state = 1935
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,279,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1932
                                self.match(ParaParser.WS) 
                            self.state = 1937
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,279,self._ctx)

                        self.state = 1938
                        self.assignmentExpression()
                        self.state = 1942
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1939
                            self.match(ParaParser.WS)
                            self.state = 1944
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1945
                        self.match(ParaParser.RightBracket)
                        pass

                    elif la_ == 4:
                        localctx = ParaParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1947
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 1951
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1948
                            self.match(ParaParser.WS)
                            self.state = 1953
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1954
                        self.match(ParaParser.LeftBracket)
                        self.state = 1958
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1955
                            self.match(ParaParser.WS)
                            self.state = 1960
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1961
                        self.match(ParaParser.Star)
                        self.state = 1965
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1962
                            self.match(ParaParser.WS)
                            self.state = 1967
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1968
                        self.match(ParaParser.RightBracket)
                        pass

                    elif la_ == 5:
                        localctx = ParaParser.DirectAbstractDeclaratorContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_directAbstractDeclarator)
                        self.state = 1969
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 1973
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1970
                            self.match(ParaParser.WS)
                            self.state = 1975
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1976
                        self.match(ParaParser.LeftParen)
                        self.state = 1980
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,285,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 1977
                                self.match(ParaParser.WS) 
                            self.state = 1982
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,285,self._ctx)

                        self.state = 1984
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier:
                            self.state = 1983
                            self.parameterTypeList()


                        self.state = 1989
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.WS:
                            self.state = 1986
                            self.match(ParaParser.WS)
                            self.state = 1991
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        self.state = 1992
                        self.match(ParaParser.RightParen)
                        pass

             
                self.state = 1997
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,289,self._ctx)

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


    class TypedefNameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_typedefName

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

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




    def typedefName(self):

        localctx = ParaParser.TypedefNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_typedefName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1998
            self.match(ParaParser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_initializer

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

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




    def initializer(self):

        localctx = ParaParser.InitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_initializer)
        self._la = 0 # Token type
        try:
            self.state = 2027
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Spawn, ParaParser.Sizeof, ParaParser.Alignof, ParaParser.LeftParen, ParaParser.Plus, ParaParser.PlusPlus, ParaParser.Minus, ParaParser.MinusMinus, ParaParser.Star, ParaParser.And, ParaParser.Not, ParaParser.Tilde, ParaParser.Identifier, ParaParser.Constant, ParaParser.DigitSequence, ParaParser.StringLiteral, ParaParser.WS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2000
                self.assignmentExpression()
                pass
            elif token in [ParaParser.LeftBrace]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2001
                self.match(ParaParser.LeftBrace)
                self.state = 2005
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,290,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2002
                        self.match(ParaParser.WS) 
                    self.state = 2007
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,290,self._ctx)

                self.state = 2009
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,291,self._ctx)
                if la_ == 1:
                    self.state = 2008
                    self.initializerList()


                self.state = 2014
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,292,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2011
                        self.match(ParaParser.WS) 
                    self.state = 2016
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,292,self._ctx)

                self.state = 2018
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.Comma:
                    self.state = 2017
                    self.match(ParaParser.Comma)


                self.state = 2023
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2020
                    self.match(ParaParser.WS)
                    self.state = 2025
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2026
                self.match(ParaParser.RightBrace)
                pass
            else:
                raise NoViableAltException(self)

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


    class InitializerListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_initializerList

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

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




    def initializerList(self):

        localctx = ParaParser.InitializerListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_initializerList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2030
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.LeftBracket or _la==ParaParser.Dot:
                self.state = 2029
                self.designation()


            self.state = 2035
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,297,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2032
                    self.match(ParaParser.WS) 
                self.state = 2037
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,297,self._ctx)

            self.state = 2038
            self.initializer()
            self.state = 2042
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,298,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2039
                    self.match(ParaParser.WS) 
                self.state = 2044
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,298,self._ctx)

            self.state = 2070
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,303,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2045
                    self.match(ParaParser.Comma)
                    self.state = 2049
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,299,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2046
                            self.match(ParaParser.WS) 
                        self.state = 2051
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,299,self._ctx)

                    self.state = 2053
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==ParaParser.LeftBracket or _la==ParaParser.Dot:
                        self.state = 2052
                        self.designation()


                    self.state = 2058
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,301,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2055
                            self.match(ParaParser.WS) 
                        self.state = 2060
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,301,self._ctx)

                    self.state = 2061
                    self.initializer()
                    self.state = 2065
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,302,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2062
                            self.match(ParaParser.WS) 
                        self.state = 2067
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,302,self._ctx)
             
                self.state = 2072
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,303,self._ctx)

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


    class DesignationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_designation

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

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




    def designation(self):

        localctx = ParaParser.DesignationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_designation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2073
            self.designatorList()
            self.state = 2077
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2074
                self.match(ParaParser.WS)
                self.state = 2079
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2080
            self.match(ParaParser.Assign)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DesignatorListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_designatorList

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

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




    def designatorList(self):

        localctx = ParaParser.DesignatorListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_designatorList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2083 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2082
                self.designator()
                self.state = 2085 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==ParaParser.LeftBracket or _la==ParaParser.Dot):
                    break

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


    class DesignatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_designator

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

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




    def designator(self):

        localctx = ParaParser.DesignatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_designator)
        self._la = 0 # Token type
        try:
            self.state = 2111
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.LeftBracket]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2087
                self.match(ParaParser.LeftBracket)
                self.state = 2091
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,306,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2088
                        self.match(ParaParser.WS) 
                    self.state = 2093
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,306,self._ctx)

                self.state = 2094
                self.constantExpression()
                self.state = 2098
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2095
                    self.match(ParaParser.WS)
                    self.state = 2100
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2101
                self.match(ParaParser.RightBracket)
                pass
            elif token in [ParaParser.Dot]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2103
                self.match(ParaParser.Dot)
                self.state = 2107
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2104
                    self.match(ParaParser.WS)
                    self.state = 2109
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2110
                self.match(ParaParser.Identifier)
                pass
            else:
                raise NoViableAltException(self)

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


    class StaticAssertDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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

        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_staticAssertDeclaration

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

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




    def staticAssertDeclaration(self):

        localctx = ParaParser.StaticAssertDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_staticAssertDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2113
            self.match(ParaParser.StaticAssert)
            self.state = 2117
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2114
                self.match(ParaParser.WS)
                self.state = 2119
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2120
            self.match(ParaParser.LeftParen)
            self.state = 2124
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,311,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2121
                    self.match(ParaParser.WS) 
                self.state = 2126
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,311,self._ctx)

            self.state = 2127
            self.constantExpression()
            self.state = 2131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2128
                self.match(ParaParser.WS)
                self.state = 2133
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2134
            self.match(ParaParser.Comma)
            self.state = 2138
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2135
                self.match(ParaParser.WS)
                self.state = 2140
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2142 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2141
                self.match(ParaParser.StringLiteral)
                self.state = 2144 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==ParaParser.StringLiteral):
                    break

            self.state = 2149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2146
                self.match(ParaParser.WS)
                self.state = 2151
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2152
            self.match(ParaParser.RightParen)
            self.state = 2153
            self.endOfItem()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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


        def tryExceptStatement(self):
            return self.getTypedRuleContext(ParaParser.TryExceptStatementContext,0)


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


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


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


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

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

        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_statement

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

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




    def statement(self):

        localctx = ParaParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_statement)
        self._la = 0 # Token type
        try:
            self.state = 2245
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,330,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2155
                self.labeledStatement()
                pass

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

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

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2158
                self.tryExceptStatement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 2159
                self.selectionStatement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 2160
                self.iterationStatement()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 2161
                self.jumpStatement()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 2162
                self.match(ParaParser.LeftParen)
                self.state = 2166
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,316,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2163
                        self.match(ParaParser.WS) 
                    self.state = 2168
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,316,self._ctx)

                self.state = 2195
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,321,self._ctx)
                if la_ == 1:
                    self.state = 2169
                    self.logicalOrExpression()
                    self.state = 2173
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,317,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2170
                            self.match(ParaParser.WS) 
                        self.state = 2175
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,317,self._ctx)

                    self.state = 2192
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.Comma:
                        self.state = 2176
                        self.match(ParaParser.Comma)
                        self.state = 2180
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,318,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 2177
                                self.match(ParaParser.WS) 
                            self.state = 2182
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,318,self._ctx)

                        self.state = 2183
                        self.logicalOrExpression()
                        self.state = 2187
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,319,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 2184
                                self.match(ParaParser.WS) 
                            self.state = 2189
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,319,self._ctx)

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



                self.state = 2200
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,322,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2197
                        self.match(ParaParser.WS) 
                    self.state = 2202
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,322,self._ctx)

                self.state = 2234
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.Colon:
                    self.state = 2203
                    self.match(ParaParser.Colon)
                    self.state = 2207
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,323,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2204
                            self.match(ParaParser.WS) 
                        self.state = 2209
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,323,self._ctx)

                    self.state = 2230
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,327,self._ctx)
                    if la_ == 1:
                        self.state = 2210
                        self.logicalOrExpression()
                        self.state = 2214
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,324,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 2211
                                self.match(ParaParser.WS) 
                            self.state = 2216
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,324,self._ctx)

                        self.state = 2227
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==ParaParser.Comma:
                            self.state = 2217
                            self.match(ParaParser.Comma)
                            self.state = 2221
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,325,self._ctx)
                            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                                if _alt==1:
                                    self.state = 2218
                                    self.match(ParaParser.WS) 
                                self.state = 2223
                                self._errHandler.sync(self)
                                _alt = self._interp.adaptivePredict(self._input,325,self._ctx)

                            self.state = 2224
                            self.logicalOrExpression()
                            self.state = 2229
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)



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

                self.state = 2240
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2237
                    self.match(ParaParser.WS)
                    self.state = 2242
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2243
                self.match(ParaParser.RightParen)
                self.state = 2244
                self.endOfItem()
                pass


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


    class LabeledStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_labeledStatement

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

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




    def labeledStatement(self):

        localctx = ParaParser.LabeledStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_labeledStatement)
        self._la = 0 # Token type
        try:
            self.state = 2285
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Case]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2247
                self.match(ParaParser.Case)
                self.state = 2251
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,331,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2248
                        self.match(ParaParser.WS) 
                    self.state = 2253
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,331,self._ctx)

                self.state = 2254
                self.constantExpression()
                self.state = 2258
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2255
                    self.match(ParaParser.WS)
                    self.state = 2260
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2261
                self.match(ParaParser.Colon)
                self.state = 2265
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,333,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2262
                        self.match(ParaParser.WS) 
                    self.state = 2267
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,333,self._ctx)

                self.state = 2268
                self.statement()
                pass
            elif token in [ParaParser.Default]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2270
                self.match(ParaParser.Default)
                self.state = 2274
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2271
                    self.match(ParaParser.WS)
                    self.state = 2276
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2277
                self.match(ParaParser.Colon)
                self.state = 2281
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,335,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2278
                        self.match(ParaParser.WS) 
                    self.state = 2283
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,335,self._ctx)

                self.state = 2284
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

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


    class CompoundStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_compoundStatement

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

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




    def compoundStatement(self):

        localctx = ParaParser.CompoundStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_compoundStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2287
            self.match(ParaParser.LeftBrace)
            self.state = 2291
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,337,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2288
                    self.match(ParaParser.WS) 
                self.state = 2293
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,337,self._ctx)

            self.state = 2295
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,338,self._ctx)
            if la_ == 1:
                self.state = 2294
                self.blockItemList()


            self.state = 2300
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2297
                self.match(ParaParser.WS)
                self.state = 2302
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class BlockItemListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_blockItemList

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

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




    def blockItemList(self):

        localctx = ParaParser.BlockItemListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_blockItemList)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2306 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 2305
                    self.blockItem()

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

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

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


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


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

        def getRuleIndex(self):
            return ParaParser.RULE_blockItem

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

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




    def blockItem(self):

        localctx = ParaParser.BlockItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_blockItem)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2313
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,341,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2310
                    self.match(ParaParser.WS) 
                self.state = 2315
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,341,self._ctx)

            self.state = 2318
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,342,self._ctx)
            if la_ == 1:
                self.state = 2316
                self.statement()
                pass

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


            self.state = 2323
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,343,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2320
                    self.match(ParaParser.WS) 
                self.state = 2325
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,343,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 ExpressionStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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


        def getRuleIndex(self):
            return ParaParser.RULE_expressionStatement

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

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




    def expressionStatement(self):

        localctx = ParaParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_expressionStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2327
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Spawn) | (1 << ParaParser.Sizeof) | (1 << ParaParser.Alignof) | (1 << ParaParser.LeftParen) | (1 << ParaParser.Plus) | (1 << ParaParser.PlusPlus) | (1 << ParaParser.Minus))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (ParaParser.MinusMinus - 64)) | (1 << (ParaParser.Star - 64)) | (1 << (ParaParser.And - 64)) | (1 << (ParaParser.Not - 64)) | (1 << (ParaParser.Tilde - 64)) | (1 << (ParaParser.Identifier - 64)) | (1 << (ParaParser.Constant - 64)) | (1 << (ParaParser.DigitSequence - 64)) | (1 << (ParaParser.StringLiteral - 64)) | (1 << (ParaParser.WS - 64)))) != 0):
                self.state = 2326
                self.expression()


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


    class TryExceptStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def exceptBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.ExceptBlockContext)
            else:
                return self.getTypedRuleContext(ParaParser.ExceptBlockContext,i)


        def finallyBlock(self):
            return self.getTypedRuleContext(ParaParser.FinallyBlockContext,0)


        def elseBlock(self):
            return self.getTypedRuleContext(ParaParser.ElseBlockContext,0)


        def getRuleIndex(self):
            return ParaParser.RULE_tryExceptStatement

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

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




    def tryExceptStatement(self):

        localctx = ParaParser.TryExceptStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_tryExceptStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2331
            self.match(ParaParser.T__0)
            self.state = 2335
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2332
                self.match(ParaParser.WS)
                self.state = 2337
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2338
            self.compoundStatement()
            self.state = 2342
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2339
                self.match(ParaParser.WS)
                self.state = 2344
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2346 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2345
                self.exceptBlock()
                self.state = 2348 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==ParaParser.T__1):
                    break

            self.state = 2353
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,348,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2350
                    self.match(ParaParser.WS) 
                self.state = 2355
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,348,self._ctx)

            self.state = 2388
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,355,self._ctx)
            if la_ == 1:
                self.state = 2356
                self.finallyBlock()
                self.state = 2360
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,349,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2357
                        self.match(ParaParser.WS) 
                    self.state = 2362
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,349,self._ctx)

                self.state = 2364
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,350,self._ctx)
                if la_ == 1:
                    self.state = 2363
                    self.elseBlock()


                self.state = 2369
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,351,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2366
                        self.match(ParaParser.WS) 
                    self.state = 2371
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,351,self._ctx)


            elif la_ == 2:
                self.state = 2372
                self.elseBlock()
                self.state = 2376
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,352,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2373
                        self.match(ParaParser.WS) 
                    self.state = 2378
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,352,self._ctx)

                self.state = 2380
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==ParaParser.T__2:
                    self.state = 2379
                    self.finallyBlock()


                self.state = 2385
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,354,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2382
                        self.match(ParaParser.WS) 
                    self.state = 2387
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,354,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 ExceptBlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


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

        def As(self):
            return self.getToken(ParaParser.As, 0)

        def getRuleIndex(self):
            return ParaParser.RULE_exceptBlock

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

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




    def exceptBlock(self):

        localctx = ParaParser.ExceptBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_exceptBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2390
            self.match(ParaParser.T__1)
            self.state = 2394
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2391
                self.match(ParaParser.WS)
                self.state = 2396
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2397
            self.match(ParaParser.LeftParen)
            self.state = 2401
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2398
                self.match(ParaParser.WS)
                self.state = 2403
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2406
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,358,self._ctx)
            if la_ == 1:
                self.state = 2404
                self.match(ParaParser.Identifier)
                pass

            elif la_ == 2:
                self.state = 2405
                self.identifierList()
                pass


            self.state = 2411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2408
                self.match(ParaParser.WS)
                self.state = 2413
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2414
            self.match(ParaParser.RightParen)
            self.state = 2418
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,360,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2415
                    self.match(ParaParser.WS) 
                self.state = 2420
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,360,self._ctx)

            self.state = 2429
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.As:
                self.state = 2421
                self.match(ParaParser.As)
                self.state = 2425
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2422
                    self.match(ParaParser.WS)
                    self.state = 2427
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2428
                self.match(ParaParser.Identifier)


            self.state = 2434
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2431
                self.match(ParaParser.WS)
                self.state = 2436
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_finallyBlock

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

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




    def finallyBlock(self):

        localctx = ParaParser.FinallyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_finallyBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2439
            self.match(ParaParser.T__2)
            self.state = 2443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2440
                self.match(ParaParser.WS)
                self.state = 2445
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_elseBlock

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

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




    def elseBlock(self):

        localctx = ParaParser.ElseBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_elseBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2448
            self.match(ParaParser.Else)
            self.state = 2452
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2449
                self.match(ParaParser.WS)
                self.state = 2454
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

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

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

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

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


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

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


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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_selectionStatement

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

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




    def selectionStatement(self):

        localctx = ParaParser.SelectionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_selectionStatement)
        self._la = 0 # Token type
        try:
            self.state = 2532
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.If]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2457
                self.match(ParaParser.If)
                self.state = 2461
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2458
                    self.match(ParaParser.WS)
                    self.state = 2463
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2464
                self.match(ParaParser.LeftParen)
                self.state = 2468
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,367,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2465
                        self.match(ParaParser.WS) 
                    self.state = 2470
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,367,self._ctx)

                self.state = 2471
                self.expression()
                self.state = 2475
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2472
                    self.match(ParaParser.WS)
                    self.state = 2477
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2478
                self.match(ParaParser.RightParen)
                self.state = 2482
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,369,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2479
                        self.match(ParaParser.WS) 
                    self.state = 2484
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,369,self._ctx)

                self.state = 2485
                self.statement()
                self.state = 2489
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,370,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2486
                        self.match(ParaParser.WS) 
                    self.state = 2491
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,370,self._ctx)

                self.state = 2500
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,372,self._ctx)
                if la_ == 1:
                    self.state = 2492
                    self.match(ParaParser.Else)
                    self.state = 2496
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,371,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 2493
                            self.match(ParaParser.WS) 
                        self.state = 2498
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,371,self._ctx)

                    self.state = 2499
                    self.statement()


                pass
            elif token in [ParaParser.Switch]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2502
                self.match(ParaParser.Switch)
                self.state = 2506
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2503
                    self.match(ParaParser.WS)
                    self.state = 2508
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2509
                self.match(ParaParser.LeftParen)
                self.state = 2513
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,374,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2510
                        self.match(ParaParser.WS) 
                    self.state = 2515
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,374,self._ctx)

                self.state = 2516
                self.expression()
                self.state = 2520
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2517
                    self.match(ParaParser.WS)
                    self.state = 2522
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2523
                self.match(ParaParser.RightParen)
                self.state = 2527
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,376,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2524
                        self.match(ParaParser.WS) 
                    self.state = 2529
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,376,self._ctx)

                self.state = 2530
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

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


    class IterationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


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

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

        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_iterationStatement

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

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




    def iterationStatement(self):

        localctx = ParaParser.IterationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_iterationStatement)
        self._la = 0 # Token type
        try:
            self.state = 2632
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.While]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2534
                self.match(ParaParser.While)
                self.state = 2538
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2535
                    self.match(ParaParser.WS)
                    self.state = 2540
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2541
                self.match(ParaParser.LeftParen)
                self.state = 2545
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,379,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2542
                        self.match(ParaParser.WS) 
                    self.state = 2547
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,379,self._ctx)

                self.state = 2548
                self.expression()
                self.state = 2552
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2549
                    self.match(ParaParser.WS)
                    self.state = 2554
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2555
                self.match(ParaParser.RightParen)
                self.state = 2559
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,381,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2556
                        self.match(ParaParser.WS) 
                    self.state = 2561
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,381,self._ctx)

                self.state = 2562
                self.statement()
                pass
            elif token in [ParaParser.Do]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2564
                self.match(ParaParser.Do)
                self.state = 2568
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,382,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2565
                        self.match(ParaParser.WS) 
                    self.state = 2570
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,382,self._ctx)

                self.state = 2571
                self.statement()
                self.state = 2575
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2572
                    self.match(ParaParser.WS)
                    self.state = 2577
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2578
                self.match(ParaParser.While)
                self.state = 2582
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2579
                    self.match(ParaParser.WS)
                    self.state = 2584
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2585
                self.match(ParaParser.LeftParen)
                self.state = 2589
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,385,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2586
                        self.match(ParaParser.WS) 
                    self.state = 2591
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,385,self._ctx)

                self.state = 2592
                self.expression()
                self.state = 2596
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2593
                    self.match(ParaParser.WS)
                    self.state = 2598
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2599
                self.match(ParaParser.RightParen)
                self.state = 2600
                self.endOfItem()
                pass
            elif token in [ParaParser.For]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2602
                self.match(ParaParser.For)
                self.state = 2606
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2603
                    self.match(ParaParser.WS)
                    self.state = 2608
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2609
                self.match(ParaParser.LeftParen)
                self.state = 2613
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,388,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2610
                        self.match(ParaParser.WS) 
                    self.state = 2615
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,388,self._ctx)

                self.state = 2616
                self.forCondition()
                self.state = 2620
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2617
                    self.match(ParaParser.WS)
                    self.state = 2622
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2623
                self.match(ParaParser.RightParen)
                self.state = 2627
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,390,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2624
                        self.match(ParaParser.WS) 
                    self.state = 2629
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,390,self._ctx)

                self.state = 2630
                self.statement()
                pass
            else:
                raise NoViableAltException(self)

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


    class ForConditionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def endOfItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.EndOfItemContext)
            else:
                return self.getTypedRuleContext(ParaParser.EndOfItemContext,i)


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


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


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


        def getRuleIndex(self):
            return ParaParser.RULE_forCondition

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

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




    def forCondition(self):

        localctx = ParaParser.ForConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_forCondition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2638
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,393,self._ctx)
            if la_ == 1:
                self.state = 2634
                self.forDeclaration()
                pass

            elif la_ == 2:
                self.state = 2636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Spawn) | (1 << ParaParser.Sizeof) | (1 << ParaParser.Alignof) | (1 << ParaParser.LeftParen) | (1 << ParaParser.Plus) | (1 << ParaParser.PlusPlus) | (1 << ParaParser.Minus))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (ParaParser.MinusMinus - 64)) | (1 << (ParaParser.Star - 64)) | (1 << (ParaParser.And - 64)) | (1 << (ParaParser.Not - 64)) | (1 << (ParaParser.Tilde - 64)) | (1 << (ParaParser.Identifier - 64)) | (1 << (ParaParser.Constant - 64)) | (1 << (ParaParser.DigitSequence - 64)) | (1 << (ParaParser.StringLiteral - 64)) | (1 << (ParaParser.WS - 64)))) != 0):
                    self.state = 2635
                    self.expression()


                pass


            self.state = 2640
            self.endOfItem()
            self.state = 2642
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Spawn) | (1 << ParaParser.Sizeof) | (1 << ParaParser.Alignof) | (1 << ParaParser.LeftParen) | (1 << ParaParser.Plus) | (1 << ParaParser.PlusPlus) | (1 << ParaParser.Minus))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (ParaParser.MinusMinus - 64)) | (1 << (ParaParser.Star - 64)) | (1 << (ParaParser.And - 64)) | (1 << (ParaParser.Not - 64)) | (1 << (ParaParser.Tilde - 64)) | (1 << (ParaParser.Identifier - 64)) | (1 << (ParaParser.Constant - 64)) | (1 << (ParaParser.DigitSequence - 64)) | (1 << (ParaParser.StringLiteral - 64)) | (1 << (ParaParser.WS - 64)))) != 0):
                self.state = 2641
                self.forExpression()


            self.state = 2644
            self.endOfItem()
            self.state = 2646
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,395,self._ctx)
            if la_ == 1:
                self.state = 2645
                self.forExpression()


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


    class ForDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_forDeclaration

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

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




    def forDeclaration(self):

        localctx = ParaParser.ForDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_forDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2648
            self.declarationSpecifiers()
            self.state = 2652
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,396,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2649
                    self.match(ParaParser.WS) 
                self.state = 2654
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,396,self._ctx)

            self.state = 2656
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 53)) & ~0x3f) == 0 and ((1 << (_la - 53)) & ((1 << (ParaParser.LeftParen - 53)) | (1 << (ParaParser.Star - 53)) | (1 << (ParaParser.Caret - 53)) | (1 << (ParaParser.Identifier - 53)) | (1 << (ParaParser.WS - 53)))) != 0):
                self.state = 2655
                self.initDeclaratorList()


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


    class ForExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return ParaParser.RULE_forExpression

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

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




    def forExpression(self):

        localctx = ParaParser.ForExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_forExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2658
            self.assignmentExpression()
            self.state = 2662
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,398,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2659
                    self.match(ParaParser.WS) 
                self.state = 2664
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,398,self._ctx)

            self.state = 2681
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.Comma:
                self.state = 2665
                self.match(ParaParser.Comma)
                self.state = 2669
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,399,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2666
                        self.match(ParaParser.WS) 
                    self.state = 2671
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,399,self._ctx)

                self.state = 2672
                self.assignmentExpression()
                self.state = 2676
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,400,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2673
                        self.match(ParaParser.WS) 
                    self.state = 2678
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,400,self._ctx)

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

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


    class JumpStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)


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

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

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

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_jumpStatement

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

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




    def jumpStatement(self):

        localctx = ParaParser.JumpStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_jumpStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2695
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [ParaParser.Break, ParaParser.Continue]:
                self.state = 2684
                _la = self._input.LA(1)
                if not(_la==ParaParser.Break or _la==ParaParser.Continue):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            elif token in [ParaParser.Return]:
                self.state = 2685
                self.match(ParaParser.Return)
                self.state = 2689
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,402,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2686
                        self.match(ParaParser.WS) 
                    self.state = 2691
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,402,self._ctx)

                self.state = 2693
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Spawn) | (1 << ParaParser.Sizeof) | (1 << ParaParser.Alignof) | (1 << ParaParser.LeftParen) | (1 << ParaParser.Plus) | (1 << ParaParser.PlusPlus) | (1 << ParaParser.Minus))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (ParaParser.MinusMinus - 64)) | (1 << (ParaParser.Star - 64)) | (1 << (ParaParser.And - 64)) | (1 << (ParaParser.Not - 64)) | (1 << (ParaParser.Tilde - 64)) | (1 << (ParaParser.Identifier - 64)) | (1 << (ParaParser.Constant - 64)) | (1 << (ParaParser.DigitSequence - 64)) | (1 << (ParaParser.StringLiteral - 64)) | (1 << (ParaParser.WS - 64)))) != 0):
                    self.state = 2692
                    self.expression()


                pass
            else:
                raise NoViableAltException(self)

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


    class CompilationUnitContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return ParaParser.RULE_compilationUnit

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

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




    def compilationUnit(self):

        localctx = ParaParser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_compilationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2700
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.ExtensionTask) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.StaticAssert) | (1 << ParaParser.ThreadLocal) | (1 << ParaParser.LeftParen))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (ParaParser.Star - 65)) | (1 << (ParaParser.Caret - 65)) | (1 << (ParaParser.DecoratorSign - 65)) | (1 << (ParaParser.Semi - 65)) | (1 << (ParaParser.Identifier - 65)) | (1 << (ParaParser.WS - 65)) | (1 << (ParaParser.Whitespace - 65)))) != 0):
                self.state = 2699
                self.translationUnit()


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


    class TranslationUnitContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def externalItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.ExternalItemContext)
            else:
                return self.getTypedRuleContext(ParaParser.ExternalItemContext,i)


        def endOfItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.EndOfItemContext)
            else:
                return self.getTypedRuleContext(ParaParser.EndOfItemContext,i)


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

        def getRuleIndex(self):
            return ParaParser.RULE_translationUnit

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

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




    def translationUnit(self):

        localctx = ParaParser.TranslationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_translationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2711 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2711
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,407,self._ctx)
                if la_ == 1:
                    self.state = 2704
                    self.externalItem()
                    pass

                elif la_ == 2:
                    self.state = 2705
                    self.endOfItem()
                    pass

                elif la_ == 3:
                    self.state = 2707 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 2706
                            self.match(ParaParser.WS)

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

                    pass


                self.state = 2713 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.ExtensionTask) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.StaticAssert) | (1 << ParaParser.ThreadLocal) | (1 << ParaParser.LeftParen))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (ParaParser.Star - 65)) | (1 << (ParaParser.Caret - 65)) | (1 << (ParaParser.DecoratorSign - 65)) | (1 << (ParaParser.Semi - 65)) | (1 << (ParaParser.Identifier - 65)) | (1 << (ParaParser.WS - 65)) | (1 << (ParaParser.Whitespace - 65)))) != 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 ExternalItemContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return ParaParser.RULE_externalItem

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ExternalFunctionDefinitionContext(ExternalItemContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.ExternalItemContext
            super().__init__(parser)
            self.copyFrom(ctx)

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


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

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


    class ExternalDeclarationContext(ExternalItemContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.ExternalItemContext
            super().__init__(parser)
            self.copyFrom(ctx)

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


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

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


    class ExternalExtTaskDefinitionContext(ExternalItemContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.ExternalItemContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def extensionTaskDefinition(self):
            return self.getTypedRuleContext(ParaParser.ExtensionTaskDefinitionContext,0)


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

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



    def externalItem(self):

        localctx = ParaParser.ExternalItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_externalItem)
        try:
            self.state = 2718
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,409,self._ctx)
            if la_ == 1:
                localctx = ParaParser.ExternalFunctionDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2715
                self.functionDefinition()
                pass

            elif la_ == 2:
                localctx = ParaParser.ExternalDeclarationContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2716
                self.declaration()
                pass

            elif la_ == 3:
                localctx = ParaParser.ExternalExtTaskDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 2717
                self.extensionTaskDefinition()
                pass


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


    class FunctionDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return ParaParser.RULE_functionDefinition

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class StandardFunctionDefinitionContext(FunctionDefinitionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.FunctionDefinitionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionDeclarationSpecifiers(self):
            return self.getTypedRuleContext(ParaParser.FunctionDeclarationSpecifiersContext,0)

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

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

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(ParaParser.WS)
            else:
                return self.getToken(ParaParser.WS, i)
        def declarationList(self):
            return self.getTypedRuleContext(ParaParser.DeclarationListContext,0)


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

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


    class SimpleFunctionDefinitionContext(FunctionDefinitionContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a ParaParser.FunctionDefinitionContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def functionDeclarationSpecifiers(self):
            return self.getTypedRuleContext(ParaParser.FunctionDeclarationSpecifiersContext,0)

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

        def expressionLambda(self):
            return self.getTypedRuleContext(ParaParser.ExpressionLambdaContext,0)

        def endOfItem(self):
            return self.getTypedRuleContext(ParaParser.EndOfItemContext,0)

        def WS(self, i:int=None):
            if i is None:
                return self.getTokens(ParaParser.WS)
            else:
                return self.getToken(ParaParser.WS, i)
        def declarationList(self):
            return self.getTypedRuleContext(ParaParser.DeclarationListContext,0)


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

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



    def functionDefinition(self):

        localctx = ParaParser.FunctionDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_functionDefinition)
        self._la = 0 # Token type
        try:
            self.state = 2771
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,418,self._ctx)
            if la_ == 1:
                localctx = ParaParser.StandardFunctionDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 2720
                self.functionDeclarationSpecifiers()
                self.state = 2724
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,410,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2721
                        self.match(ParaParser.WS) 
                    self.state = 2726
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,410,self._ctx)

                self.state = 2727
                self.declarator()
                self.state = 2731
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,411,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2728
                        self.match(ParaParser.WS) 
                    self.state = 2733
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,411,self._ctx)

                self.state = 2735
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.StaticAssert) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier:
                    self.state = 2734
                    self.declarationList()


                self.state = 2740
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2737
                    self.match(ParaParser.WS)
                    self.state = 2742
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2743
                self.compoundStatement()
                pass

            elif la_ == 2:
                localctx = ParaParser.SimpleFunctionDefinitionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 2745
                self.functionDeclarationSpecifiers()
                self.state = 2749
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,414,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2746
                        self.match(ParaParser.WS) 
                    self.state = 2751
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,414,self._ctx)

                self.state = 2752
                self.declarator()
                self.state = 2756
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,415,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2753
                        self.match(ParaParser.WS) 
                    self.state = 2758
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,415,self._ctx)

                self.state = 2760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.StaticAssert) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier:
                    self.state = 2759
                    self.declarationList()


                self.state = 2765
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2762
                    self.match(ParaParser.WS)
                    self.state = 2767
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2768
                self.expressionLambda()
                self.state = 2769
                self.endOfItem()
                pass


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


    class FunctionDeclarationSpecifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def decoratorSpecifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.DecoratorSpecifierContext)
            else:
                return self.getTypedRuleContext(ParaParser.DecoratorSpecifierContext,i)


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_functionDeclarationSpecifiers

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

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




    def functionDeclarationSpecifiers(self):

        localctx = ParaParser.FunctionDeclarationSpecifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_functionDeclarationSpecifiers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2776
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.DecoratorSign:
                self.state = 2773
                self.decoratorSpecifier()
                self.state = 2778
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2782
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,420,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2779
                    self.match(ParaParser.WS) 
                self.state = 2784
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,420,self._ctx)

            self.state = 2786
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,421,self._ctx)
            if la_ == 1:
                self.state = 2785
                self.declarationSpecifiers()


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


    class DecoratorSpecifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DecoratorSign(self):
            return self.getToken(ParaParser.DecoratorSign, 0)

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

        def getRuleIndex(self):
            return ParaParser.RULE_decoratorSpecifier

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

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




    def decoratorSpecifier(self):

        localctx = ParaParser.DecoratorSpecifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_decoratorSpecifier)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2788
            self.match(ParaParser.DecoratorSign)
            self.state = 2789
            self.match(ParaParser.Identifier)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExtensionTaskDefinitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ExtensionTask(self):
            return self.getToken(ParaParser.ExtensionTask, 0)

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

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


        def extensionTaskParameterList(self):
            return self.getTypedRuleContext(ParaParser.ExtensionTaskParameterListContext,0)


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

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


        def getRuleIndex(self):
            return ParaParser.RULE_extensionTaskDefinition

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

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




    def extensionTaskDefinition(self):

        localctx = ParaParser.ExtensionTaskDefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_extensionTaskDefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2791
            self.match(ParaParser.ExtensionTask)
            self.state = 2795
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2792
                self.match(ParaParser.WS)
                self.state = 2797
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2798
            self.match(ParaParser.Identifier)
            self.state = 2802
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2799
                self.match(ParaParser.WS)
                self.state = 2804
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2805
            self.directDeclarator(0)
            self.state = 2809
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,424,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2806
                    self.match(ParaParser.WS) 
                self.state = 2811
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,424,self._ctx)

            self.state = 2813
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.StaticAssert) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier:
                self.state = 2812
                self.declarationList()


            self.state = 2818
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2815
                self.match(ParaParser.WS)
                self.state = 2820
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class ExtensionTaskParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def extensionTaskParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ParaParser.ExtensionTaskParameterContext)
            else:
                return self.getTypedRuleContext(ParaParser.ExtensionTaskParameterContext,i)


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

        def getRuleIndex(self):
            return ParaParser.RULE_extensionTaskParameterList

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

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




    def extensionTaskParameterList(self):

        localctx = ParaParser.ExtensionTaskParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_extensionTaskParameterList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2823
            self.match(ParaParser.LeftBrace)
            self.state = 2827
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2824
                self.match(ParaParser.WS)
                self.state = 2829
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2856
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==ParaParser.Identifier:
                self.state = 2830
                self.extensionTaskParameter()
                self.state = 2834
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.WS:
                    self.state = 2831
                    self.match(ParaParser.WS)
                    self.state = 2836
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2853
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==ParaParser.Comma:
                    self.state = 2837
                    self.match(ParaParser.Comma)
                    self.state = 2841
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 2838
                        self.match(ParaParser.WS)
                        self.state = 2843
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 2844
                    self.extensionTaskParameter()
                    self.state = 2848
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==ParaParser.WS:
                        self.state = 2845
                        self.match(ParaParser.WS)
                        self.state = 2850
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

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



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


    class ExtensionTaskParameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_extensionTaskParameter

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

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




    def extensionTaskParameter(self):

        localctx = ParaParser.ExtensionTaskParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_extensionTaskParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2860
            self.match(ParaParser.Identifier)
            self.state = 2864
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2861
                self.match(ParaParser.WS)
                self.state = 2866
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2867
            self.match(ParaParser.Colon)
            self.state = 2871
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.WS:
                self.state = 2868
                self.match(ParaParser.WS)
                self.state = 2873
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class DeclarationListContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return ParaParser.RULE_declarationList

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

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




    def declarationList(self):

        localctx = ParaParser.DeclarationListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_declarationList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2883 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2876
                self.declaration()
                self.state = 2880
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,435,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2877
                        self.match(ParaParser.WS) 
                    self.state = 2882
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,435,self._ctx)

                self.state = 2885 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << ParaParser.Bool) | (1 << ParaParser.Char) | (1 << ParaParser.Complex) | (1 << ParaParser.Double) | (1 << ParaParser.Entry) | (1 << ParaParser.Float) | (1 << ParaParser.Int) | (1 << ParaParser.Lambda) | (1 << ParaParser.Long) | (1 << ParaParser.Signed) | (1 << ParaParser.Short) | (1 << ParaParser.Status) | (1 << ParaParser.Unsigned) | (1 << ParaParser.Void) | (1 << ParaParser.Const) | (1 << ParaParser.Volatile) | (1 << ParaParser.Atomic) | (1 << ParaParser.Auto) | (1 << ParaParser.Register) | (1 << ParaParser.Static) | (1 << ParaParser.Extern) | (1 << ParaParser.Enum) | (1 << ParaParser.Restrict) | (1 << ParaParser.Struct) | (1 << ParaParser.Typeof) | (1 << ParaParser.Typedef) | (1 << ParaParser.Union) | (1 << ParaParser.Alignas) | (1 << ParaParser.Noreturn) | (1 << ParaParser.StaticAssert) | (1 << ParaParser.ThreadLocal))) != 0) or _la==ParaParser.Identifier):
                    break

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


    class EndOfItemContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def getRuleIndex(self):
            return ParaParser.RULE_endOfItem

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

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




    def endOfItem(self):

        localctx = ParaParser.EndOfItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_endOfItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2890
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==ParaParser.Whitespace:
                self.state = 2887
                self.match(ParaParser.Whitespace)
                self.state = 2892
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2893
            self.match(ParaParser.Semi)
            self.state = 2897
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,438,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2894
                    self.match(ParaParser.Whitespace) 
                self.state = 2899
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,438,self._ctx)

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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[9] = self.castOrConvertExpression_sempred
        self._predicates[32] = self.typeSpecifier_sempred
        self._predicates[49] = self.directDeclarator_sempred
        self._predicates[59] = self.directAbstractDeclarator_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def castOrConvertExpression_sempred(self, localctx:CastOrConvertExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 3)
         

    def typeSpecifier_sempred(self, localctx:TypeSpecifierContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 1)
         

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

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

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

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

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

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

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




