//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 4.13.1
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// Generated from CIL.g4 by ANTLR 4.13.1

// Unreachable code detected
#pragma warning disable 0162
// The variable '...' is assigned but its value is never used
#pragma warning disable 0219
// Missing XML comment for publicly visible type or member '...'
#pragma warning disable 1591
// Ambiguous reference in cref attribute
#pragma warning disable 419

namespace ILAssembler {
using System;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Collections.Generic;
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Tree;
using DFA = Antlr4.Runtime.Dfa.DFA;

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.13.1")]
[System.CLSCompliant(false)]
public partial class CILParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
		T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 
		T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, 
		T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, 
		T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, 
		T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, 
		T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, 
		T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, 
		T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, 
		T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 
		T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 
		T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 
		T__107=108, T__108=109, T__109=110, T__110=111, T__111=112, T__112=113, 
		T__113=114, T__114=115, T__115=116, T__116=117, T__117=118, T__118=119, 
		T__119=120, T__120=121, T__121=122, T__122=123, T__123=124, T__124=125, 
		T__125=126, T__126=127, T__127=128, T__128=129, T__129=130, T__130=131, 
		T__131=132, T__132=133, T__133=134, T__134=135, T__135=136, T__136=137, 
		T__137=138, T__138=139, T__139=140, T__140=141, T__141=142, T__142=143, 
		T__143=144, T__144=145, T__145=146, T__146=147, T__147=148, T__148=149, 
		T__149=150, T__150=151, T__151=152, T__152=153, T__153=154, T__154=155, 
		T__155=156, T__156=157, T__157=158, T__158=159, T__159=160, T__160=161, 
		T__161=162, T__162=163, T__163=164, T__164=165, T__165=166, T__166=167, 
		T__167=168, T__168=169, T__169=170, T__170=171, INT32=172, INT64=173, 
		FLOAT64=174, DCOLON=175, ELLIPSIS=176, NULL=177, NULLREF=178, HASH=179, 
		CHAR=180, STRING=181, BOOL=182, INT8=183, INT16=184, INT32_=185, INT64_=186, 
		FLOAT32=187, FLOAT64_=188, UINT8=189, UINT16=190, UINT32=191, UINT64=192, 
		INT=193, UINT=194, TYPE=195, OBJECT=196, MODULE=197, VALUE=198, VALUETYPE=199, 
		VOID=200, ENUM=201, CUSTOM=202, FIXED=203, SYSSTRING=204, ARRAY=205, VARIANT=206, 
		CURRENCY=207, SYSCHAR=208, ERROR=209, DECIMAL=210, DATE=211, BSTR=212, 
		LPSTR=213, LPWSTR=214, LPTSTR=215, OBJECTREF=216, IUNKNOWN=217, IDISPATCH=218, 
		STRUCT=219, INTERFACE=220, SAFEARRAY=221, BYVALSTR=222, ANSI=223, TBSTR=224, 
		METHOD=225, ANY=226, LPSTRUCT=227, VECTOR=228, HRESULT=229, CARRAY=230, 
		USERDEFINED=231, RECORD=232, FILETIME=233, BLOB=234, STREAM=235, STORAGE=236, 
		STREAMED_OBJECT=237, STORED_OBJECT=238, BLOB_OBJECT=239, CF=240, CLSID=241, 
		INSTANCE=242, EXPLICIT=243, DEFAULT=244, VARARG=245, UNMANAGED=246, CDECL=247, 
		STDCALL=248, THISCALL=249, FASTCALL=250, TYPE_PARAMETER=251, METHOD_TYPE_PARAMETER=252, 
		TYPEDREF=253, PARAM=254, CONSTRAINT=255, THIS=256, BASE=257, NESTER=258, 
		REF=259, ARRAY_TYPE_NO_BOUNDS=260, PTR=261, QSTRING=262, SQSTRING=263, 
		DOT=264, PLUS=265, PP_DEFINE=266, PP_UNDEF=267, PP_IFDEF=268, PP_IFNDEF=269, 
		PP_ELSE=270, PP_ENDIF=271, PP_INCLUDE=272, MRESOURCE=273, INSTR_NONE=274, 
		INSTR_VAR=275, INSTR_I=276, INSTR_I8=277, INSTR_R=278, INSTR_METHOD=279, 
		INSTR_SIG=280, INSTR_BRTARGET=281, INSTR_SWITCH=282, INSTR_TYPE=283, INSTR_STRING=284, 
		INSTR_FIELD=285, INSTR_TOK=286, DOTTEDNAME=287, ID=288, HEXBYTE=289, WS=290, 
		SINGLE_LINE_COMMENT=291, COMMENT=292, PERMISSION=293, PERMISSIONSET=294, 
		EMITBYTE=295, MAXSTACK=296, ENTRYPOINT=297, ZEROINIT=298, LOCALS=299, 
		EXPORT=300, OVERRIDE=301, VTENTRY=302, IncludedFileEof=303, SyntheticIncludedFileEof=304;
	public const int
		RULE_id = 0, RULE_dottedName = 1, RULE_dottedNamePart = 2, RULE_compQstring = 3, 
		RULE_decls = 4, RULE_decl = 5, RULE_subsystem = 6, RULE_corflags = 7, 
		RULE_alignment = 8, RULE_imagebase = 9, RULE_stackreserve = 10, RULE_assemblyBlock = 11, 
		RULE_mscorlib = 12, RULE_languageDecl = 13, RULE_languageString = 14, 
		RULE_typelist = 15, RULE_int32 = 16, RULE_int64 = 17, RULE_float64 = 18, 
		RULE_intOrWildcard = 19, RULE_compControl = 20, RULE_typedefDecl = 21, 
		RULE_customDescr = 22, RULE_customDescrWithOwner = 23, RULE_customType = 24, 
		RULE_ownerType = 25, RULE_customBlobDescr = 26, RULE_customBlobArgs = 27, 
		RULE_customBlobNVPairs = 28, RULE_fieldOrProp = 29, RULE_serializType = 30, 
		RULE_serializTypeElement = 31, RULE_moduleHead = 32, RULE_vtfixupDecl = 33, 
		RULE_vtfixupAttr = 34, RULE_vtableDecl = 35, RULE_nameSpaceHead = 36, 
		RULE_classHead = 37, RULE_classAttr = 38, RULE_extendsClause = 39, RULE_implClause = 40, 
		RULE_classDecls = 41, RULE_implList = 42, RULE_esHead = 43, RULE_extSourceSpec = 44, 
		RULE_fileDecl = 45, RULE_fileAttr = 46, RULE_fileEntry = 47, RULE_asmAttrAny = 48, 
		RULE_asmAttr = 49, RULE_instr_none = 50, RULE_instr_var = 51, RULE_instr_i = 52, 
		RULE_instr_i8 = 53, RULE_instr_r = 54, RULE_instr_brtarget = 55, RULE_instr_method = 56, 
		RULE_instr_field = 57, RULE_instr_type = 58, RULE_instr_string = 59, RULE_instr_sig = 60, 
		RULE_instr_tok = 61, RULE_instr_switch = 62, RULE_instr = 63, RULE_labels = 64, 
		RULE_typeArgs = 65, RULE_bounds = 66, RULE_sigArgs = 67, RULE_sigArg = 68, 
		RULE_className = 69, RULE_slashedName = 70, RULE_assemblyDecls = 71, RULE_assemblyDecl = 72, 
		RULE_typeSpec = 73, RULE_nativeType = 74, RULE_nativeTypeArrayPointerInfo = 75, 
		RULE_nativeTypeElement = 76, RULE_iidParamIndex = 77, RULE_variantType = 78, 
		RULE_variantTypeElement = 79, RULE_type = 80, RULE_typeModifiers = 81, 
		RULE_elementType = 82, RULE_simpleType = 83, RULE_bound = 84, RULE_nativeInt = 85, 
		RULE_nativeUint = 86, RULE_secDecl = 87, RULE_secAttrSetBlob = 88, RULE_secAttrBlob = 89, 
		RULE_nameValPairs = 90, RULE_nameValPair = 91, RULE_truefalse = 92, RULE_caValue = 93, 
		RULE_secAction = 94, RULE_methodRef = 95, RULE_callConv = 96, RULE_callKind = 97, 
		RULE_mdtoken = 98, RULE_memberRef = 99, RULE_fieldRef = 100, RULE_typeList = 101, 
		RULE_typarsClause = 102, RULE_typarAttrib = 103, RULE_typarAttribs = 104, 
		RULE_typar = 105, RULE_typars = 106, RULE_tyBound = 107, RULE_genArity = 108, 
		RULE_genArityNotEmpty = 109, RULE_classDecl = 110, RULE_fieldDecl = 111, 
		RULE_fieldAttr = 112, RULE_atOpt = 113, RULE_initOpt = 114, RULE_repeatOpt = 115, 
		RULE_eventHead = 116, RULE_eventAttr = 117, RULE_eventDecls = 118, RULE_eventDecl = 119, 
		RULE_propHead = 120, RULE_propAttr = 121, RULE_propDecls = 122, RULE_propDecl = 123, 
		RULE_marshalClause = 124, RULE_marshalBlob = 125, RULE_paramAttr = 126, 
		RULE_paramAttrElement = 127, RULE_methodHead = 128, RULE_methAttr = 129, 
		RULE_pinvImpl = 130, RULE_pinvAttr = 131, RULE_methodName = 132, RULE_implAttr = 133, 
		RULE_methodDecls = 134, RULE_methodDecl = 135, RULE_labelDecl = 136, RULE_customDescrInMethodBody = 137, 
		RULE_scopeBlock = 138, RULE_sehBlock = 139, RULE_sehClauses = 140, RULE_tryBlock = 141, 
		RULE_sehClause = 142, RULE_filterClause = 143, RULE_catchClause = 144, 
		RULE_finallyClause = 145, RULE_faultClause = 146, RULE_handlerBlock = 147, 
		RULE_dataDecl = 148, RULE_ddHead = 149, RULE_tls = 150, RULE_ddBody = 151, 
		RULE_ddItemList = 152, RULE_ddItemCount = 153, RULE_ddItem = 154, RULE_fieldSerInit = 155, 
		RULE_bytes = 156, RULE_hexbyte = 157, RULE_fieldInit = 158, RULE_serInit = 159, 
		RULE_f32seq = 160, RULE_f64seq = 161, RULE_i64seq = 162, RULE_i32seq = 163, 
		RULE_i16seq = 164, RULE_i8seq = 165, RULE_boolSeq = 166, RULE_sqstringSeq = 167, 
		RULE_classSeq = 168, RULE_classSeqElement = 169, RULE_objSeq = 170, RULE_customAttrDecl = 171, 
		RULE_asmOrRefDecl = 172, RULE_assemblyRefHead = 173, RULE_assemblyRefDecls = 174, 
		RULE_assemblyRefDecl = 175, RULE_exptypeHead = 176, RULE_exportHead = 177, 
		RULE_exptAttr = 178, RULE_exptypeDecls = 179, RULE_exptypeDecl = 180, 
		RULE_manifestResHead = 181, RULE_manresAttr = 182, RULE_manifestResDecls = 183, 
		RULE_manifestResDecl = 184;
	public static readonly string[] ruleNames = {
		"id", "dottedName", "dottedNamePart", "compQstring", "decls", "decl", 
		"subsystem", "corflags", "alignment", "imagebase", "stackreserve", "assemblyBlock", 
		"mscorlib", "languageDecl", "languageString", "typelist", "int32", "int64", 
		"float64", "intOrWildcard", "compControl", "typedefDecl", "customDescr", 
		"customDescrWithOwner", "customType", "ownerType", "customBlobDescr", 
		"customBlobArgs", "customBlobNVPairs", "fieldOrProp", "serializType", 
		"serializTypeElement", "moduleHead", "vtfixupDecl", "vtfixupAttr", "vtableDecl", 
		"nameSpaceHead", "classHead", "classAttr", "extendsClause", "implClause", 
		"classDecls", "implList", "esHead", "extSourceSpec", "fileDecl", "fileAttr", 
		"fileEntry", "asmAttrAny", "asmAttr", "instr_none", "instr_var", "instr_i", 
		"instr_i8", "instr_r", "instr_brtarget", "instr_method", "instr_field", 
		"instr_type", "instr_string", "instr_sig", "instr_tok", "instr_switch", 
		"instr", "labels", "typeArgs", "bounds", "sigArgs", "sigArg", "className", 
		"slashedName", "assemblyDecls", "assemblyDecl", "typeSpec", "nativeType", 
		"nativeTypeArrayPointerInfo", "nativeTypeElement", "iidParamIndex", "variantType", 
		"variantTypeElement", "type", "typeModifiers", "elementType", "simpleType", 
		"bound", "nativeInt", "nativeUint", "secDecl", "secAttrSetBlob", "secAttrBlob", 
		"nameValPairs", "nameValPair", "truefalse", "caValue", "secAction", "methodRef", 
		"callConv", "callKind", "mdtoken", "memberRef", "fieldRef", "typeList", 
		"typarsClause", "typarAttrib", "typarAttribs", "typar", "typars", "tyBound", 
		"genArity", "genArityNotEmpty", "classDecl", "fieldDecl", "fieldAttr", 
		"atOpt", "initOpt", "repeatOpt", "eventHead", "eventAttr", "eventDecls", 
		"eventDecl", "propHead", "propAttr", "propDecls", "propDecl", "marshalClause", 
		"marshalBlob", "paramAttr", "paramAttrElement", "methodHead", "methAttr", 
		"pinvImpl", "pinvAttr", "methodName", "implAttr", "methodDecls", "methodDecl", 
		"labelDecl", "customDescrInMethodBody", "scopeBlock", "sehBlock", "sehClauses", 
		"tryBlock", "sehClause", "filterClause", "catchClause", "finallyClause", 
		"faultClause", "handlerBlock", "dataDecl", "ddHead", "tls", "ddBody", 
		"ddItemList", "ddItemCount", "ddItem", "fieldSerInit", "bytes", "hexbyte", 
		"fieldInit", "serInit", "f32seq", "f64seq", "i64seq", "i32seq", "i16seq", 
		"i8seq", "boolSeq", "sqstringSeq", "classSeq", "classSeqElement", "objSeq", 
		"customAttrDecl", "asmOrRefDecl", "assemblyRefHead", "assemblyRefDecls", 
		"assemblyRefDecl", "exptypeHead", "exportHead", "exptAttr", "exptypeDecls", 
		"exptypeDecl", "manifestResHead", "manresAttr", "manifestResDecls", "manifestResDecl"
	};

	private static readonly string[] _LiteralNames = {
		null, "'native'", "'cil'", "'optil'", "'managed'", "'forwardref'", "'preservesig'", 
		"'runtime'", "'internalcall'", "'synchronized'", "'noinlining'", "'aggressiveinlining'", 
		"'nooptimization'", "'aggressiveoptimization'", "'async'", "'extended'", 
		"'{'", "'}'", "'.subsystem'", "'.corflags'", "'.file'", "'alignment'", 
		"'.imagebase'", "'.stackreserve'", "'.assembly'", "'.mscorlib'", "'.language'", 
		"','", "'.typelist'", "'('", "')'", "';'", "'.typedef'", "'as'", "'.custom'", 
		"'='", "'field'", "'property'", "'class'", "'extern'", "'.vtfixup'", "'['", 
		"']'", "'at'", "'fromunmanaged'", "'callmostderived'", "'retainappdomain'", 
		"'.vtable'", "'.namespace'", "'.class'", "'public'", "'private'", "'sealed'", 
		"'abstract'", "'auto'", "'sequential'", "'unicode'", "'autochar'", "'import'", 
		"'serializable'", "'windowsruntime'", "'nested'", "'family'", "'assembly'", 
		"'famandassem'", "'famorassem'", "'beforefieldinit'", "'specialname'", 
		"'rtspecialname'", "'flags'", "'extends'", "'implements'", "'.line'", 
		"'#line'", "':'", "'nometadata'", "'retargetable'", "'noplatform'", "'legacy library'", 
		"'x86'", "'amd64'", "'arm'", "'arm64'", "'bytearray'", "'()'", "'<'", 
		"'>'", "'/'", "'algorithm'", "'iidparam'", "'pinned'", "'modreq'", "'modopt'", 
		"'unsigned'", "'true'", "'false'", "'request'", "'demand'", "'assert'", 
		"'deny'", "'permitonly'", "'linkcheck'", "'inheritcheck'", "'reqmin'", 
		"'reqopt'", "'reqrefuse'", "'prejitgrant'", "'prejitdeny'", "'noncasdemand'", 
		"'noncaslinkdemand'", "'noncasinheritance'", "'callconv'", "'mdtoken'", 
		"'-'", "'byreflike'", "'.ctor'", "'.size'", "'.pack'", "'with'", "'.interfaceimpl'", 
		"'.field'", "'marshal'", "'static'", "'initonly'", "'privatescope'", "'literal'", 
		"'notserialized'", "'volatile'", "'.event'", "'.addon'", "'.removeon'", 
		"'.fire'", "'.other'", "'.property'", "'.set'", "'.get'", "'in'", "'out'", 
		"'opt'", "'.method'", "'final'", "'virtual'", "'strict'", "'hidebysig'", 
		"'newslot'", "'unmanagedexp'", "'reqsecobj'", "'pinvokeimpl'", "'nomangle'", 
		"'lasterr'", "'winapi'", "'bestfit'", "'on'", "'off'", "'charmaperror'", 
		"'.cctor'", "'il'", "'init'", "'.try'", "'to'", "'filter'", "'catch'", 
		"'finally'", "'fault'", "'handler'", "'.data'", "'tls'", "'.publicKey'", 
		"'.ver'", "'.locale'", "'.publickeytoken'", "'forwarder'", null, null, 
		null, "'::'", "'...'", "'null'", "'nullref'", "'.hash'", null, "'string'", 
		"'bool'", "'int8'", "'int16'", "'int32'", "'int64'", "'float32'", "'float64'", 
		"'uint8'", "'uint16'", "'uint32'", "'uint64'", "'int'", "'uint'", "'type'", 
		"'object'", "'.module'", "'value'", "'valuetype'", "'void'", "'enum'", 
		"'custom'", "'fixed'", "'systring'", "'array'", "'variant'", "'currency'", 
		"'syschar'", "'error'", "'decimal'", "'date'", "'bstr'", "'lpstr'", "'lpwstr'", 
		"'lptstr'", "'objectref'", "'iunknown'", "'idispatch'", "'struct'", "'interface'", 
		"'safearray'", "'byvalstr'", "'ansi'", "'tbstr'", "'method'", "'any'", 
		"'lpstruct'", "'vector'", "'hresult'", "'carray'", "'userdefined'", "'record'", 
		"'filetime'", "'blob'", "'stream'", "'storage'", "'streamed_object'", 
		"'stored_object'", "'blob_object'", "'cf'", "'clsid'", "'instance'", "'explicit'", 
		"'default'", "'vararg'", "'unmanaged'", "'cdecl'", "'stdcall'", "'thiscall'", 
		"'fastcall'", "'!'", null, null, "'.param'", "'constraint'", "'.this'", 
		"'.base'", "'.nester'", "'&'", null, "'*'", null, null, "'.'", "'+'", 
		"'#define'", "'#undef'", "'#ifdef'", "'#ifndef'", "'#else'", "'#endif'", 
		"'#include'", "'.mresource'", null, null, null, "'ldc.i8'", null, null, 
		"'calli'", null, "'switch'", null, "'ldstr'", null, "'ldtoken'", null, 
		null, null, null, null, null, "'.permission'", "'.permissionset'", "'.emitbyte'", 
		"'.maxstack'", "'.entrypoint'", "'.zeroinit'", "'.locals'", "'.export'", 
		"'.override'", "'.vtentry'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, "INT32", "INT64", "FLOAT64", "DCOLON", "ELLIPSIS", 
		"NULL", "NULLREF", "HASH", "CHAR", "STRING", "BOOL", "INT8", "INT16", 
		"INT32_", "INT64_", "FLOAT32", "FLOAT64_", "UINT8", "UINT16", "UINT32", 
		"UINT64", "INT", "UINT", "TYPE", "OBJECT", "MODULE", "VALUE", "VALUETYPE", 
		"VOID", "ENUM", "CUSTOM", "FIXED", "SYSSTRING", "ARRAY", "VARIANT", "CURRENCY", 
		"SYSCHAR", "ERROR", "DECIMAL", "DATE", "BSTR", "LPSTR", "LPWSTR", "LPTSTR", 
		"OBJECTREF", "IUNKNOWN", "IDISPATCH", "STRUCT", "INTERFACE", "SAFEARRAY", 
		"BYVALSTR", "ANSI", "TBSTR", "METHOD", "ANY", "LPSTRUCT", "VECTOR", "HRESULT", 
		"CARRAY", "USERDEFINED", "RECORD", "FILETIME", "BLOB", "STREAM", "STORAGE", 
		"STREAMED_OBJECT", "STORED_OBJECT", "BLOB_OBJECT", "CF", "CLSID", "INSTANCE", 
		"EXPLICIT", "DEFAULT", "VARARG", "UNMANAGED", "CDECL", "STDCALL", "THISCALL", 
		"FASTCALL", "TYPE_PARAMETER", "METHOD_TYPE_PARAMETER", "TYPEDREF", "PARAM", 
		"CONSTRAINT", "THIS", "BASE", "NESTER", "REF", "ARRAY_TYPE_NO_BOUNDS", 
		"PTR", "QSTRING", "SQSTRING", "DOT", "PLUS", "PP_DEFINE", "PP_UNDEF", 
		"PP_IFDEF", "PP_IFNDEF", "PP_ELSE", "PP_ENDIF", "PP_INCLUDE", "MRESOURCE", 
		"INSTR_NONE", "INSTR_VAR", "INSTR_I", "INSTR_I8", "INSTR_R", "INSTR_METHOD", 
		"INSTR_SIG", "INSTR_BRTARGET", "INSTR_SWITCH", "INSTR_TYPE", "INSTR_STRING", 
		"INSTR_FIELD", "INSTR_TOK", "DOTTEDNAME", "ID", "HEXBYTE", "WS", "SINGLE_LINE_COMMENT", 
		"COMMENT", "PERMISSION", "PERMISSIONSET", "EMITBYTE", "MAXSTACK", "ENTRYPOINT", 
		"ZEROINIT", "LOCALS", "EXPORT", "OVERRIDE", "VTENTRY", "IncludedFileEof", 
		"SyntheticIncludedFileEof"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

	[NotNull]
	public override IVocabulary Vocabulary
	{
		get
		{
			return DefaultVocabulary;
		}
	}

	public override string GrammarFileName { get { return "CIL.g4"; } }

	public override string[] RuleNames { get { return ruleNames; } }

	public override int[] SerializedAtn { get { return _serializedATN; } }

	static CILParser() {
		decisionToDFA = new DFA[_ATN.NumberOfDecisions];
		for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
			decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
		}
	}

		public CILParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

		public CILParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}

	public partial class IdContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CILParser.ID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNMANAGED() { return GetToken(CILParser.UNMANAGED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTANCE() { return GetToken(CILParser.INSTANCE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		public IdContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_id; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitId(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public IdContext id() {
		IdContext _localctx = new IdContext(Context, State);
		EnterRule(_localctx, 0, RULE_id);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 370;
			_la = TokenStream.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DottedNameContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOTTEDNAME() { return GetToken(CILParser.DOTTEDNAME, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNamePartContext[] dottedNamePart() {
			return GetRuleContexts<DottedNamePartContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNamePartContext dottedNamePart(int i) {
			return GetRuleContext<DottedNamePartContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DOT() { return GetTokens(CILParser.DOT); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOT(int i) {
			return GetToken(CILParser.DOT, i);
		}
		public DottedNameContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dottedName; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDottedName(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DottedNameContext dottedName() {
		DottedNameContext _localctx = new DottedNameContext(Context, State);
		EnterRule(_localctx, 2, RULE_dottedName);
		try {
			int _alt;
			State = 382;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case DOTTEDNAME:
				EnterOuterAlt(_localctx, 1);
				{
				State = 372;
				Match(DOTTEDNAME);
				}
				break;
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case ID:
				EnterOuterAlt(_localctx, 2);
				{
				{
				State = 378;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,0,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 373;
						dottedNamePart();
						State = 374;
						Match(DOT);
						}
						} 
					}
					State = 380;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,0,Context);
				}
				State = 381;
				dottedNamePart();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DottedNamePartContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CILParser.ID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTANCE() { return GetToken(CILParser.INSTANCE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		public DottedNamePartContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dottedNamePart; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDottedNamePart(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DottedNamePartContext dottedNamePart() {
		DottedNamePartContext _localctx = new DottedNamePartContext(Context, State);
		EnterRule(_localctx, 4, RULE_dottedNamePart);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 384;
			_la = TokenStream.LA(1);
			if ( !(_la==VALUE || _la==INSTANCE || _la==SQSTRING || _la==ID) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CompQstringContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] QSTRING() { return GetTokens(CILParser.QSTRING); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode QSTRING(int i) {
			return GetToken(CILParser.QSTRING, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] PLUS() { return GetTokens(CILParser.PLUS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS(int i) {
			return GetToken(CILParser.PLUS, i);
		}
		public CompQstringContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_compQstring; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompQstring(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CompQstringContext compQstring() {
		CompQstringContext _localctx = new CompQstringContext(Context, State);
		EnterRule(_localctx, 6, RULE_compQstring);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 390;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,2,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 386;
					Match(QSTRING);
					State = 387;
					Match(PLUS);
					}
					} 
				}
				State = 392;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,2,Context);
			}
			State = 393;
			Match(QSTRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DeclContext[] decl() {
			return GetRuleContexts<DeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DeclContext decl(int i) {
			return GetRuleContext<DeclContext>(i);
		}
		public DeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_decls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DeclsContext decls() {
		DeclsContext _localctx = new DeclsContext(Context, State);
		EnterRule(_localctx, 8, RULE_decls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 398;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 986285952729088L) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 281474976710659L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 864691128522244097L) != 0) || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & 6860956837609473L) != 0)) {
				{
				{
				State = 395;
				decl();
				}
				}
				State = 400;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ClassHeadContext classHead() {
			return GetRuleContext<ClassHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassDeclsContext classDecls() {
			return GetRuleContext<ClassDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public NameSpaceHeadContext nameSpaceHead() {
			return GetRuleContext<NameSpaceHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DeclsContext decls() {
			return GetRuleContext<DeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodHeadContext methodHead() {
			return GetRuleContext<MethodHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodDeclsContext methodDecls() {
			return GetRuleContext<MethodDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDeclContext fieldDecl() {
			return GetRuleContext<FieldDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DataDeclContext dataDecl() {
			return GetRuleContext<DataDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public VtableDeclContext vtableDecl() {
			return GetRuleContext<VtableDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public VtfixupDeclContext vtfixupDecl() {
			return GetRuleContext<VtfixupDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() {
			return GetRuleContext<ExtSourceSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FileDeclContext fileDecl() {
			return GetRuleContext<FileDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyBlockContext assemblyBlock() {
			return GetRuleContext<AssemblyBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyRefHeadContext assemblyRefHead() {
			return GetRuleContext<AssemblyRefHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclsContext assemblyRefDecls() {
			return GetRuleContext<AssemblyRefDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptypeHeadContext exptypeHead() {
			return GetRuleContext<ExptypeHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclsContext exptypeDecls() {
			return GetRuleContext<ExptypeDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManifestResHeadContext manifestResHead() {
			return GetRuleContext<ManifestResHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclsContext manifestResDecls() {
			return GetRuleContext<ManifestResDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ModuleHeadContext moduleHead() {
			return GetRuleContext<ModuleHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() {
			return GetRuleContext<SecDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl() {
			return GetRuleContext<CustomAttrDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SubsystemContext subsystem() {
			return GetRuleContext<SubsystemContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CorflagsContext corflags() {
			return GetRuleContext<CorflagsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AlignmentContext alignment() {
			return GetRuleContext<AlignmentContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ImagebaseContext imagebase() {
			return GetRuleContext<ImagebaseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public StackreserveContext stackreserve() {
			return GetRuleContext<StackreserveContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() {
			return GetRuleContext<LanguageDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypedefDeclContext typedefDecl() {
			return GetRuleContext<TypedefDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypelistContext typelist() {
			return GetRuleContext<TypelistContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MscorlibContext mscorlib() {
			return GetRuleContext<MscorlibContext>(0);
		}
		public DeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_decl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DeclContext decl() {
		DeclContext _localctx = new DeclContext(Context, State);
		EnterRule(_localctx, 10, RULE_decl);
		try {
			State = 451;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,4,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 401;
				classHead();
				State = 402;
				Match(T__15);
				State = 403;
				classDecls();
				State = 404;
				Match(T__16);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 406;
				nameSpaceHead();
				State = 407;
				Match(T__15);
				State = 408;
				decls();
				State = 409;
				Match(T__16);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 411;
				methodHead();
				State = 412;
				Match(T__15);
				State = 413;
				methodDecls();
				State = 414;
				Match(T__16);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 416;
				fieldDecl();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 417;
				dataDecl();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 418;
				vtableDecl();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 419;
				vtfixupDecl();
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 420;
				extSourceSpec();
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 421;
				fileDecl();
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 422;
				assemblyBlock();
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 423;
				assemblyRefHead();
				State = 424;
				Match(T__15);
				State = 425;
				assemblyRefDecls();
				State = 426;
				Match(T__16);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 428;
				exptypeHead();
				State = 429;
				Match(T__15);
				State = 430;
				exptypeDecls();
				State = 431;
				Match(T__16);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 433;
				manifestResHead();
				State = 434;
				Match(T__15);
				State = 435;
				manifestResDecls();
				State = 436;
				Match(T__16);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 438;
				moduleHead();
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 439;
				secDecl();
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 440;
				customAttrDecl();
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 441;
				subsystem();
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 442;
				corflags();
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 443;
				alignment();
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 444;
				imagebase();
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 445;
				stackreserve();
				}
				break;
			case 22:
				EnterOuterAlt(_localctx, 22);
				{
				State = 446;
				languageDecl();
				}
				break;
			case 23:
				EnterOuterAlt(_localctx, 23);
				{
				State = 447;
				typedefDecl();
				}
				break;
			case 24:
				EnterOuterAlt(_localctx, 24);
				{
				State = 448;
				compControl();
				}
				break;
			case 25:
				EnterOuterAlt(_localctx, 25);
				{
				State = 449;
				typelist();
				}
				break;
			case 26:
				EnterOuterAlt(_localctx, 26);
				{
				State = 450;
				mscorlib();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SubsystemContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public SubsystemContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_subsystem; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSubsystem(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SubsystemContext subsystem() {
		SubsystemContext _localctx = new SubsystemContext(Context, State);
		EnterRule(_localctx, 12, RULE_subsystem);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 453;
			Match(T__17);
			State = 454;
			int32();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CorflagsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public CorflagsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_corflags; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCorflags(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CorflagsContext corflags() {
		CorflagsContext _localctx = new CorflagsContext(Context, State);
		EnterRule(_localctx, 14, RULE_corflags);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 456;
			Match(T__18);
			State = 457;
			int32();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AlignmentContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public AlignmentContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_alignment; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAlignment(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AlignmentContext alignment() {
		AlignmentContext _localctx = new AlignmentContext(Context, State);
		EnterRule(_localctx, 16, RULE_alignment);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 459;
			Match(T__19);
			State = 460;
			Match(T__20);
			State = 461;
			int32();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ImagebaseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() {
			return GetRuleContext<Int64Context>(0);
		}
		public ImagebaseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_imagebase; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitImagebase(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ImagebaseContext imagebase() {
		ImagebaseContext _localctx = new ImagebaseContext(Context, State);
		EnterRule(_localctx, 18, RULE_imagebase);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 463;
			Match(T__21);
			State = 464;
			int64();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StackreserveContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() {
			return GetRuleContext<Int64Context>(0);
		}
		public StackreserveContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_stackreserve; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStackreserve(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StackreserveContext stackreserve() {
		StackreserveContext _localctx = new StackreserveContext(Context, State);
		EnterRule(_localctx, 20, RULE_stackreserve);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 466;
			Match(T__22);
			State = 467;
			int64();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssemblyBlockContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AsmAttrContext asmAttr() {
			return GetRuleContext<AsmAttrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyDeclsContext assemblyDecls() {
			return GetRuleContext<AssemblyDeclsContext>(0);
		}
		public AssemblyBlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assemblyBlock; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssemblyBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssemblyBlockContext assemblyBlock() {
		AssemblyBlockContext _localctx = new AssemblyBlockContext(Context, State);
		EnterRule(_localctx, 22, RULE_assemblyBlock);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 469;
			Match(T__23);
			State = 470;
			asmAttr();
			State = 471;
			dottedName();
			State = 472;
			Match(T__15);
			State = 473;
			assemblyDecls();
			State = 474;
			Match(T__16);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MscorlibContext : ParserRuleContext {
		public MscorlibContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_mscorlib; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMscorlib(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MscorlibContext mscorlib() {
		MscorlibContext _localctx = new MscorlibContext(Context, State);
		EnterRule(_localctx, 24, RULE_mscorlib);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 476;
			Match(T__24);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class LanguageDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public LanguageStringContext[] languageString() {
			return GetRuleContexts<LanguageStringContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public LanguageStringContext languageString(int i) {
			return GetRuleContext<LanguageStringContext>(i);
		}
		public LanguageDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_languageDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLanguageDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public LanguageDeclContext languageDecl() {
		LanguageDeclContext _localctx = new LanguageDeclContext(Context, State);
		EnterRule(_localctx, 26, RULE_languageDecl);
		try {
			State = 492;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,5,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 478;
				Match(T__25);
				State = 479;
				languageString();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 480;
				Match(T__25);
				State = 481;
				languageString();
				State = 482;
				Match(T__26);
				State = 483;
				languageString();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 485;
				Match(T__25);
				State = 486;
				languageString();
				State = 487;
				Match(T__26);
				State = 488;
				languageString();
				State = 489;
				Match(T__26);
				State = 490;
				languageString();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class LanguageStringContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode QSTRING() { return GetToken(CILParser.QSTRING, 0); }
		public LanguageStringContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_languageString; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLanguageString(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public LanguageStringContext languageString() {
		LanguageStringContext _localctx = new LanguageStringContext(Context, State);
		EnterRule(_localctx, 28, RULE_languageString);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 494;
			_la = TokenStream.LA(1);
			if ( !(_la==QSTRING || _la==SQSTRING) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypelistContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext[] className() {
			return GetRuleContexts<ClassNameContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className(int i) {
			return GetRuleContext<ClassNameContext>(i);
		}
		public TypelistContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typelist; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypelist(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypelistContext typelist() {
		TypelistContext _localctx = new TypelistContext(Context, State);
		EnterRule(_localctx, 30, RULE_typelist);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 496;
			Match(T__27);
			State = 497;
			Match(T__15);
			State = 501;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__40 || _la==T__111 || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 2017630225248026625L) != 0) || ((((_la - 263)) & ~0x3f) == 0 && ((1L << (_la - 263)) & 50331649L) != 0)) {
				{
				{
				State = 498;
				className();
				}
				}
				State = 503;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 504;
			Match(T__16);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Int32Context : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32() { return GetToken(CILParser.INT32, 0); }
		public Int32Context(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_int32; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInt32(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Int32Context int32() {
		Int32Context _localctx = new Int32Context(Context, State);
		EnterRule(_localctx, 32, RULE_int32);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 506;
			Match(INT32);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Int64Context : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64() { return GetToken(CILParser.INT64, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32() { return GetToken(CILParser.INT32, 0); }
		public Int64Context(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_int64; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInt64(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Int64Context int64() {
		Int64Context _localctx = new Int64Context(Context, State);
		EnterRule(_localctx, 34, RULE_int64);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 508;
			_la = TokenStream.LA(1);
			if ( !(_la==INT32 || _la==INT64) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Float64Context : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64() { return GetToken(CILParser.FLOAT64, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DOT() { return GetToken(CILParser.DOT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() {
			return GetRuleContext<Int64Context>(0);
		}
		public Float64Context(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_float64; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFloat64(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Float64Context float64() {
		Float64Context _localctx = new Float64Context(Context, State);
		EnterRule(_localctx, 36, RULE_float64);
		try {
			State = 525;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 510;
				Match(FLOAT64);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 511;
				int32();
				State = 512;
				Match(DOT);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 514;
				int32();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 515;
				Match(FLOAT32);
				State = 516;
				Match(T__28);
				State = 517;
				int32();
				State = 518;
				Match(T__29);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 520;
				Match(FLOAT64_);
				State = 521;
				Match(T__28);
				State = 522;
				int64();
				State = 523;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IntOrWildcardContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		public IntOrWildcardContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_intOrWildcard; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIntOrWildcard(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public IntOrWildcardContext intOrWildcard() {
		IntOrWildcardContext _localctx = new IntOrWildcardContext(Context, State);
		EnterRule(_localctx, 38, RULE_intOrWildcard);
		try {
			State = 529;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case INT32:
				EnterOuterAlt(_localctx, 1);
				{
				State = 527;
				int32();
				}
				break;
			case PTR:
				EnterOuterAlt(_localctx, 2);
				{
				State = 528;
				Match(PTR);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CompControlContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_DEFINE() { return GetToken(CILParser.PP_DEFINE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CILParser.ID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode QSTRING() { return GetToken(CILParser.QSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_UNDEF() { return GetToken(CILParser.PP_UNDEF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_IFDEF() { return GetToken(CILParser.PP_IFDEF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_IFNDEF() { return GetToken(CILParser.PP_IFNDEF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_ELSE() { return GetToken(CILParser.PP_ELSE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_ENDIF() { return GetToken(CILParser.PP_ENDIF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PP_INCLUDE() { return GetToken(CILParser.PP_INCLUDE, 0); }
		public CompControlContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_compControl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCompControl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CompControlContext compControl() {
		CompControlContext _localctx = new CompControlContext(Context, State);
		EnterRule(_localctx, 40, RULE_compControl);
		try {
			State = 547;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,9,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 531;
				Match(PP_DEFINE);
				State = 532;
				Match(ID);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 533;
				Match(PP_DEFINE);
				State = 534;
				Match(ID);
				State = 535;
				Match(QSTRING);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 536;
				Match(PP_UNDEF);
				State = 537;
				Match(ID);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 538;
				Match(PP_IFDEF);
				State = 539;
				Match(ID);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 540;
				Match(PP_IFNDEF);
				State = 541;
				Match(ID);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 542;
				Match(PP_ELSE);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 543;
				Match(PP_ENDIF);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 544;
				Match(PP_INCLUDE);
				State = 545;
				Match(QSTRING);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 546;
				Match(T__30);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypedefDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MemberRefContext memberRef() {
			return GetRuleContext<MemberRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() {
			return GetRuleContext<CustomDescrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrWithOwnerContext customDescrWithOwner() {
			return GetRuleContext<CustomDescrWithOwnerContext>(0);
		}
		public TypedefDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typedefDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypedefDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypedefDeclContext typedefDecl() {
		TypedefDeclContext _localctx = new TypedefDeclContext(Context, State);
		EnterRule(_localctx, 42, RULE_typedefDecl);
		try {
			State = 574;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 549;
				Match(T__31);
				State = 550;
				type();
				State = 551;
				Match(T__32);
				State = 552;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 554;
				Match(T__31);
				State = 555;
				className();
				State = 556;
				Match(T__32);
				State = 557;
				dottedName();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 559;
				Match(T__31);
				State = 560;
				memberRef();
				State = 561;
				Match(T__32);
				State = 562;
				dottedName();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 564;
				Match(T__31);
				State = 565;
				customDescr();
				State = 566;
				Match(T__32);
				State = 567;
				dottedName();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 569;
				Match(T__31);
				State = 570;
				customDescrWithOwner();
				State = 571;
				Match(T__32);
				State = 572;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomDescrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CustomTypeContext customType() {
			return GetRuleContext<CustomTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomBlobDescrContext customBlobDescr() {
			return GetRuleContext<CustomBlobDescrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		public CustomDescrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customDescr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomDescr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomDescrContext customDescr() {
		CustomDescrContext _localctx = new CustomDescrContext(Context, State);
		EnterRule(_localctx, 44, RULE_customDescr);
		try {
			State = 597;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 576;
				Match(T__33);
				State = 577;
				customType();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 578;
				Match(T__33);
				State = 579;
				customType();
				State = 580;
				Match(T__34);
				State = 581;
				compQstring();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 583;
				Match(T__33);
				State = 584;
				customType();
				State = 585;
				Match(T__34);
				State = 586;
				Match(T__15);
				State = 587;
				customBlobDescr();
				State = 588;
				Match(T__16);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 590;
				Match(T__33);
				State = 591;
				customType();
				State = 592;
				Match(T__34);
				State = 593;
				Match(T__28);
				State = 594;
				bytes();
				State = 595;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomDescrWithOwnerContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() {
			return GetRuleContext<OwnerTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomTypeContext customType() {
			return GetRuleContext<CustomTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomBlobDescrContext customBlobDescr() {
			return GetRuleContext<CustomBlobDescrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		public CustomDescrWithOwnerContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customDescrWithOwner; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomDescrWithOwner(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomDescrWithOwnerContext customDescrWithOwner() {
		CustomDescrWithOwnerContext _localctx = new CustomDescrWithOwnerContext(Context, State);
		EnterRule(_localctx, 46, RULE_customDescrWithOwner);
		try {
			State = 633;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 599;
				Match(T__33);
				State = 600;
				Match(T__28);
				State = 601;
				ownerType();
				State = 602;
				Match(T__29);
				State = 603;
				customType();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 605;
				Match(T__33);
				State = 606;
				Match(T__28);
				State = 607;
				ownerType();
				State = 608;
				Match(T__29);
				State = 609;
				customType();
				State = 610;
				Match(T__34);
				State = 611;
				compQstring();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 613;
				Match(T__33);
				State = 614;
				Match(T__28);
				State = 615;
				ownerType();
				State = 616;
				Match(T__29);
				State = 617;
				customType();
				State = 618;
				Match(T__34);
				State = 619;
				Match(T__15);
				State = 620;
				customBlobDescr();
				State = 621;
				Match(T__16);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 623;
				Match(T__33);
				State = 624;
				Match(T__28);
				State = 625;
				ownerType();
				State = 626;
				Match(T__29);
				State = 627;
				customType();
				State = 628;
				Match(T__34);
				State = 629;
				Match(T__28);
				State = 630;
				bytes();
				State = 631;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() {
			return GetRuleContext<MethodRefContext>(0);
		}
		public CustomTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomTypeContext customType() {
		CustomTypeContext _localctx = new CustomTypeContext(Context, State);
		EnterRule(_localctx, 48, RULE_customType);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 635;
			methodRef();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class OwnerTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MemberRefContext memberRef() {
			return GetRuleContext<MemberRefContext>(0);
		}
		public OwnerTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ownerType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitOwnerType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public OwnerTypeContext ownerType() {
		OwnerTypeContext _localctx = new OwnerTypeContext(Context, State);
		EnterRule(_localctx, 50, RULE_ownerType);
		try {
			State = 639;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 637;
				typeSpec();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 638;
				memberRef();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomBlobDescrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CustomBlobArgsContext customBlobArgs() {
			return GetRuleContext<CustomBlobArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomBlobNVPairsContext customBlobNVPairs() {
			return GetRuleContext<CustomBlobNVPairsContext>(0);
		}
		public CustomBlobDescrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customBlobDescr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomBlobDescr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomBlobDescrContext customBlobDescr() {
		CustomBlobDescrContext _localctx = new CustomBlobDescrContext(Context, State);
		EnterRule(_localctx, 52, RULE_customBlobDescr);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 641;
			customBlobArgs();
			State = 642;
			customBlobNVPairs();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomBlobArgsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() {
			return GetRuleContexts<SerInitContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit(int i) {
			return GetRuleContext<SerInitContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext[] compControl() {
			return GetRuleContexts<CompControlContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl(int i) {
			return GetRuleContext<CompControlContext>(i);
		}
		public CustomBlobArgsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customBlobArgs; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomBlobArgs(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomBlobArgsContext customBlobArgs() {
		CustomBlobArgsContext _localctx = new CustomBlobArgsContext(Context, State);
		EnterRule(_localctx, 54, RULE_customBlobArgs);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 648;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,15,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					State = 646;
					ErrorHandler.Sync(this);
					switch (TokenStream.LA(1)) {
					case T__82:
					case CHAR:
					case STRING:
					case BOOL:
					case INT8:
					case INT16:
					case INT32_:
					case INT64_:
					case FLOAT32:
					case FLOAT64_:
					case UINT8:
					case UINT16:
					case UINT32:
					case UINT64:
					case TYPE:
					case OBJECT:
						{
						State = 644;
						serInit();
						}
						break;
					case T__30:
					case PP_DEFINE:
					case PP_UNDEF:
					case PP_IFDEF:
					case PP_IFNDEF:
					case PP_ELSE:
					case PP_ENDIF:
					case PP_INCLUDE:
						{
						State = 645;
						compControl();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					} 
				}
				State = 650;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,15,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomBlobNVPairsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public FieldOrPropContext[] fieldOrProp() {
			return GetRuleContexts<FieldOrPropContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldOrPropContext fieldOrProp(int i) {
			return GetRuleContext<FieldOrPropContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SerializTypeContext[] serializType() {
			return GetRuleContexts<SerializTypeContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SerializTypeContext serializType(int i) {
			return GetRuleContext<SerializTypeContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() {
			return GetRuleContexts<DottedNameContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName(int i) {
			return GetRuleContext<DottedNameContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() {
			return GetRuleContexts<SerInitContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit(int i) {
			return GetRuleContext<SerInitContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext[] compControl() {
			return GetRuleContexts<CompControlContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl(int i) {
			return GetRuleContext<CompControlContext>(i);
		}
		public CustomBlobNVPairsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customBlobNVPairs; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomBlobNVPairs(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomBlobNVPairsContext customBlobNVPairs() {
		CustomBlobNVPairsContext _localctx = new CustomBlobNVPairsContext(Context, State);
		EnterRule(_localctx, 56, RULE_customBlobNVPairs);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 660;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 208305913856L) != 0) || ((((_la - 266)) & ~0x3f) == 0 && ((1L << (_la - 266)) & 127L) != 0)) {
				{
				State = 658;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case T__35:
				case T__36:
					{
					State = 651;
					fieldOrProp();
					State = 652;
					serializType();
					State = 653;
					dottedName();
					State = 654;
					Match(T__34);
					State = 655;
					serInit();
					}
					break;
				case T__30:
				case PP_DEFINE:
				case PP_UNDEF:
				case PP_IFDEF:
				case PP_IFNDEF:
				case PP_ELSE:
				case PP_ENDIF:
				case PP_INCLUDE:
					{
					State = 657;
					compControl();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 662;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldOrPropContext : ParserRuleContext {
		public FieldOrPropContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldOrProp; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFieldOrProp(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FieldOrPropContext fieldOrProp() {
		FieldOrPropContext _localctx = new FieldOrPropContext(Context, State);
		EnterRule(_localctx, 58, RULE_fieldOrProp);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 663;
			_la = TokenStream.LA(1);
			if ( !(_la==T__35 || _la==T__36) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SerializTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SerializTypeElementContext serializTypeElement() {
			return GetRuleContext<SerializTypeElementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_TYPE_NO_BOUNDS() { return GetToken(CILParser.ARRAY_TYPE_NO_BOUNDS, 0); }
		public SerializTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_serializType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSerializType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SerializTypeContext serializType() {
		SerializTypeContext _localctx = new SerializTypeContext(Context, State);
		EnterRule(_localctx, 60, RULE_serializType);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 665;
			serializTypeElement();
			State = 667;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==ARRAY_TYPE_NO_BOUNDS) {
				{
				State = 666;
				Match(ARRAY_TYPE_NO_BOUNDS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SerializTypeElementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SimpleTypeContext simpleType() {
			return GetRuleContext<SimpleTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OBJECT() { return GetToken(CILParser.OBJECT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENUM() { return GetToken(CILParser.ENUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		public SerializTypeElementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_serializTypeElement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSerializTypeElement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SerializTypeElementContext serializTypeElement() {
		SerializTypeElementContext _localctx = new SerializTypeElementContext(Context, State);
		EnterRule(_localctx, 62, RULE_serializTypeElement);
		try {
			State = 678;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 669;
				simpleType();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 670;
				dottedName();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 671;
				Match(TYPE);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 672;
				Match(OBJECT);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 673;
				Match(ENUM);
				State = 674;
				Match(T__37);
				State = 675;
				Match(SQSTRING);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 676;
				Match(ENUM);
				State = 677;
				className();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ModuleHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MODULE() { return GetToken(CILParser.MODULE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public ModuleHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_moduleHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitModuleHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ModuleHeadContext moduleHead() {
		ModuleHeadContext _localctx = new ModuleHeadContext(Context, State);
		EnterRule(_localctx, 64, RULE_moduleHead);
		try {
			State = 686;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 680;
				Match(MODULE);
				State = 681;
				Match(T__38);
				State = 682;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 683;
				Match(MODULE);
				State = 684;
				dottedName();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 685;
				Match(MODULE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VtfixupDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public VtfixupAttrContext vtfixupAttr() {
			return GetRuleContext<VtfixupAttrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		public VtfixupDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_vtfixupDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVtfixupDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VtfixupDeclContext vtfixupDecl() {
		VtfixupDeclContext _localctx = new VtfixupDeclContext(Context, State);
		EnterRule(_localctx, 66, RULE_vtfixupDecl);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 688;
			Match(T__39);
			State = 689;
			Match(T__40);
			State = 690;
			int32();
			State = 691;
			Match(T__41);
			State = 692;
			vtfixupAttr(0);
			State = 693;
			Match(T__42);
			State = 694;
			id();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VtfixupAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public VtfixupAttrContext vtfixupAttr() {
			return GetRuleContext<VtfixupAttrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		public VtfixupAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_vtfixupAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVtfixupAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VtfixupAttrContext vtfixupAttr() {
		return vtfixupAttr(0);
	}

	private VtfixupAttrContext vtfixupAttr(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		VtfixupAttrContext _localctx = new VtfixupAttrContext(Context, _parentState);
		VtfixupAttrContext _prevctx = _localctx;
		int _startState = 68;
		EnterRecursionRule(_localctx, 68, RULE_vtfixupAttr, _p);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			{
			}
			Context.Stop = TokenStream.LT(-1);
			State = 709;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,22,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 707;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,21,Context) ) {
					case 1:
						{
						_localctx = new VtfixupAttrContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr);
						State = 697;
						if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)");
						State = 698;
						Match(INT32_);
						}
						break;
					case 2:
						{
						_localctx = new VtfixupAttrContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr);
						State = 699;
						if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)");
						State = 700;
						Match(INT64_);
						}
						break;
					case 3:
						{
						_localctx = new VtfixupAttrContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr);
						State = 701;
						if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)");
						State = 702;
						Match(T__43);
						}
						break;
					case 4:
						{
						_localctx = new VtfixupAttrContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr);
						State = 703;
						if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)");
						State = 704;
						Match(T__44);
						}
						break;
					case 5:
						{
						_localctx = new VtfixupAttrContext(_parentctx, _parentState);
						PushNewRecursionContext(_localctx, _startState, RULE_vtfixupAttr);
						State = 705;
						if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)");
						State = 706;
						Match(T__45);
						}
						break;
					}
					} 
				}
				State = 711;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,22,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class VtableDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		public VtableDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_vtableDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVtableDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VtableDeclContext vtableDecl() {
		VtableDeclContext _localctx = new VtableDeclContext(Context, State);
		EnterRule(_localctx, 70, RULE_vtableDecl);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 712;
			Match(T__46);
			State = 713;
			Match(T__34);
			State = 714;
			Match(T__28);
			State = 715;
			bytes();
			State = 716;
			Match(T__29);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NameSpaceHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public NameSpaceHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nameSpaceHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNameSpaceHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NameSpaceHeadContext nameSpaceHead() {
		NameSpaceHeadContext _localctx = new NameSpaceHeadContext(Context, State);
		EnterRule(_localctx, 72, RULE_nameSpaceHead);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 718;
			Match(T__47);
			State = 719;
			dottedName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TyparsClauseContext typarsClause() {
			return GetRuleContext<TyparsClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExtendsClauseContext extendsClause() {
			return GetRuleContext<ExtendsClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ImplClauseContext implClause() {
			return GetRuleContext<ImplClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassAttrContext[] classAttr() {
			return GetRuleContexts<ClassAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassAttrContext classAttr(int i) {
			return GetRuleContext<ClassAttrContext>(i);
		}
		public ClassHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_classHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassHeadContext classHead() {
		ClassHeadContext _localctx = new ClassHeadContext(Context, State);
		EnterRule(_localctx, 74, RULE_classHead);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 721;
			Match(T__48);
			State = 725;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,23,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 722;
					classAttr();
					}
					} 
				}
				State = 727;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,23,Context);
			}
			State = 728;
			dottedName();
			State = 729;
			typarsClause();
			State = 730;
			extendsClause();
			State = 731;
			implClause();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENUM() { return GetToken(CILParser.ENUM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTERFACE() { return GetToken(CILParser.INTERFACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPLICIT() { return GetToken(CILParser.EXPLICIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public ClassAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_classAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassAttrContext classAttr() {
		ClassAttrContext _localctx = new ClassAttrContext(Context, State);
		EnterRule(_localctx, 76, RULE_classAttr);
		try {
			State = 770;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 733;
				Match(T__49);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 734;
				Match(T__50);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 735;
				Match(VALUE);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 736;
				Match(ENUM);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 737;
				Match(INTERFACE);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 738;
				Match(T__51);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 739;
				Match(T__52);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 740;
				Match(T__53);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 741;
				Match(T__54);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 742;
				Match(EXPLICIT);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 743;
				Match(T__14);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 744;
				Match(ANSI);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 745;
				Match(T__55);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 746;
				Match(T__56);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 747;
				Match(T__57);
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 748;
				Match(T__58);
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 749;
				Match(T__59);
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 750;
				Match(T__60);
				State = 751;
				Match(T__49);
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 752;
				Match(T__60);
				State = 753;
				Match(T__50);
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 754;
				Match(T__60);
				State = 755;
				Match(T__61);
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 756;
				Match(T__60);
				State = 757;
				Match(T__62);
				}
				break;
			case 22:
				EnterOuterAlt(_localctx, 22);
				{
				State = 758;
				Match(T__60);
				State = 759;
				Match(T__63);
				}
				break;
			case 23:
				EnterOuterAlt(_localctx, 23);
				{
				State = 760;
				Match(T__60);
				State = 761;
				Match(T__64);
				}
				break;
			case 24:
				EnterOuterAlt(_localctx, 24);
				{
				State = 762;
				Match(T__65);
				}
				break;
			case 25:
				EnterOuterAlt(_localctx, 25);
				{
				State = 763;
				Match(T__66);
				}
				break;
			case 26:
				EnterOuterAlt(_localctx, 26);
				{
				State = 764;
				Match(T__67);
				}
				break;
			case 27:
				EnterOuterAlt(_localctx, 27);
				{
				State = 765;
				Match(T__68);
				State = 766;
				Match(T__28);
				State = 767;
				int32();
				State = 768;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExtendsClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		public ExtendsClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_extendsClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExtendsClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExtendsClauseContext extendsClause() {
		ExtendsClauseContext _localctx = new ExtendsClauseContext(Context, State);
		EnterRule(_localctx, 78, RULE_extendsClause);
		try {
			State = 775;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__15:
			case T__70:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__69:
				EnterOuterAlt(_localctx, 2);
				{
				State = 773;
				Match(T__69);
				State = 774;
				typeSpec();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ImplClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ImplListContext implList() {
			return GetRuleContext<ImplListContext>(0);
		}
		public ImplClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_implClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitImplClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ImplClauseContext implClause() {
		ImplClauseContext _localctx = new ImplClauseContext(Context, State);
		EnterRule(_localctx, 80, RULE_implClause);
		try {
			State = 780;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__15:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__70:
				EnterOuterAlt(_localctx, 2);
				{
				State = 778;
				Match(T__70);
				State = 779;
				implList();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ClassDeclContext[] classDecl() {
			return GetRuleContexts<ClassDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassDeclContext classDecl(int i) {
			return GetRuleContext<ClassDeclContext>(i);
		}
		public ClassDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_classDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassDeclsContext classDecls() {
		ClassDeclsContext _localctx = new ClassDeclsContext(Context, State);
		EnterRule(_localctx, 82, RULE_classDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 785;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 562969347883008L) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 2378375592274821123L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 576460752370532353L) != 0) || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & 871552083145265153L) != 0)) {
				{
				{
				State = 782;
				classDecl();
				}
				}
				State = 787;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ImplListContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() {
			return GetRuleContexts<TypeSpecContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec(int i) {
			return GetRuleContext<TypeSpecContext>(i);
		}
		public ImplListContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_implList; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitImplList(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ImplListContext implList() {
		ImplListContext _localctx = new ImplListContext(Context, State);
		EnterRule(_localctx, 84, RULE_implList);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 793;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,28,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 788;
					typeSpec();
					State = 789;
					Match(T__26);
					}
					} 
				}
				State = 795;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,28,Context);
			}
			State = 796;
			typeSpec();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EsHeadContext : ParserRuleContext {
		public EsHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_esHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEsHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EsHeadContext esHead() {
		EsHeadContext _localctx = new EsHeadContext(Context, State);
		EnterRule(_localctx, 86, RULE_esHead);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 798;
			_la = TokenStream.LA(1);
			if ( !(_la==T__71 || _la==T__72) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExtSourceSpecContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public EsHeadContext esHead() {
			return GetRuleContext<EsHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode QSTRING() { return GetToken(CILParser.QSTRING, 0); }
		public ExtSourceSpecContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_extSourceSpec; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExtSourceSpec(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExtSourceSpecContext extSourceSpec() {
		ExtSourceSpecContext _localctx = new ExtSourceSpecContext(Context, State);
		EnterRule(_localctx, 88, RULE_extSourceSpec);
		try {
			State = 903;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 800;
				esHead();
				State = 801;
				int32();
				State = 802;
				Match(SQSTRING);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 804;
				esHead();
				State = 805;
				int32();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 807;
				esHead();
				State = 808;
				int32();
				State = 809;
				Match(T__73);
				State = 810;
				int32();
				State = 811;
				Match(SQSTRING);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 813;
				esHead();
				State = 814;
				int32();
				State = 815;
				Match(T__73);
				State = 816;
				int32();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 818;
				esHead();
				State = 819;
				int32();
				State = 820;
				Match(T__73);
				State = 821;
				int32();
				State = 822;
				Match(T__26);
				State = 823;
				int32();
				State = 824;
				Match(SQSTRING);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 826;
				esHead();
				State = 827;
				int32();
				State = 828;
				Match(T__73);
				State = 829;
				int32();
				State = 830;
				Match(T__26);
				State = 831;
				int32();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 833;
				esHead();
				State = 834;
				int32();
				State = 835;
				Match(T__26);
				State = 836;
				int32();
				State = 837;
				Match(T__73);
				State = 838;
				int32();
				State = 839;
				Match(SQSTRING);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 841;
				esHead();
				State = 842;
				int32();
				State = 843;
				Match(T__26);
				State = 844;
				int32();
				State = 845;
				Match(T__73);
				State = 846;
				int32();
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 848;
				esHead();
				State = 849;
				int32();
				State = 850;
				Match(T__26);
				State = 851;
				int32();
				State = 852;
				Match(T__73);
				State = 853;
				int32();
				State = 854;
				Match(T__26);
				State = 855;
				int32();
				State = 856;
				Match(SQSTRING);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 858;
				esHead();
				State = 859;
				int32();
				State = 860;
				Match(T__26);
				State = 861;
				int32();
				State = 862;
				Match(T__73);
				State = 863;
				int32();
				State = 864;
				Match(T__26);
				State = 865;
				int32();
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 867;
				esHead();
				State = 868;
				int32();
				State = 869;
				Match(QSTRING);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 871;
				esHead();
				State = 872;
				int32();
				State = 873;
				Match(T__73);
				State = 874;
				int32();
				State = 875;
				Match(QSTRING);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 877;
				esHead();
				State = 878;
				int32();
				State = 879;
				Match(T__73);
				State = 880;
				int32();
				State = 881;
				Match(T__26);
				State = 882;
				int32();
				State = 883;
				Match(QSTRING);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 885;
				esHead();
				State = 886;
				int32();
				State = 887;
				Match(T__26);
				State = 888;
				int32();
				State = 889;
				Match(T__73);
				State = 890;
				int32();
				State = 891;
				Match(QSTRING);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 893;
				esHead();
				State = 894;
				int32();
				State = 895;
				Match(T__26);
				State = 896;
				int32();
				State = 897;
				Match(T__73);
				State = 898;
				int32();
				State = 899;
				Match(T__26);
				State = 900;
				int32();
				State = 901;
				Match(QSTRING);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FileDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FileEntryContext[] fileEntry() {
			return GetRuleContexts<FileEntryContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FileEntryContext fileEntry(int i) {
			return GetRuleContext<FileEntryContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HASH() { return GetToken(CILParser.HASH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FileAttrContext[] fileAttr() {
			return GetRuleContexts<FileAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FileAttrContext fileAttr(int i) {
			return GetRuleContext<FileAttrContext>(i);
		}
		public FileDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fileDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFileDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FileDeclContext fileDecl() {
		FileDeclContext _localctx = new FileDeclContext(Context, State);
		EnterRule(_localctx, 90, RULE_fileDecl);
		int _la;
		try {
			State = 931;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,32,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 905;
				Match(T__19);
				State = 909;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__74) {
					{
					{
					State = 906;
					fileAttr();
					}
					}
					State = 911;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 912;
				dottedName();
				State = 913;
				fileEntry();
				State = 914;
				Match(HASH);
				State = 915;
				Match(T__34);
				State = 916;
				Match(T__28);
				State = 917;
				bytes();
				State = 918;
				Match(T__29);
				State = 919;
				fileEntry();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 921;
				Match(T__19);
				State = 925;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__74) {
					{
					{
					State = 922;
					fileAttr();
					}
					}
					State = 927;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 928;
				dottedName();
				State = 929;
				fileEntry();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FileAttrContext : ParserRuleContext {
		public FileAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fileAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFileAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FileAttrContext fileAttr() {
		FileAttrContext _localctx = new FileAttrContext(Context, State);
		EnterRule(_localctx, 92, RULE_fileAttr);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 933;
			Match(T__74);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FileEntryContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENTRYPOINT() { return GetToken(CILParser.ENTRYPOINT, 0); }
		public FileEntryContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fileEntry; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFileEntry(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FileEntryContext fileEntry() {
		FileEntryContext _localctx = new FileEntryContext(Context, State);
		EnterRule(_localctx, 94, RULE_fileEntry);
		try {
			State = 937;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__16:
			case T__17:
			case T__18:
			case T__19:
			case T__21:
			case T__22:
			case T__23:
			case T__24:
			case T__25:
			case T__27:
			case T__30:
			case T__31:
			case T__33:
			case T__39:
			case T__46:
			case T__47:
			case T__48:
			case T__71:
			case T__72:
			case T__119:
			case T__138:
			case T__164:
			case HASH:
			case MODULE:
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
			case MRESOURCE:
			case DOTTEDNAME:
			case ID:
			case PERMISSION:
			case PERMISSIONSET:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case ENTRYPOINT:
				EnterOuterAlt(_localctx, 2);
				{
				State = 936;
				Match(ENTRYPOINT);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AsmAttrAnyContext : ParserRuleContext {
		public AsmAttrAnyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_asmAttrAny; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAsmAttrAny(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AsmAttrAnyContext asmAttrAny() {
		AsmAttrAnyContext _localctx = new AsmAttrAnyContext(Context, State);
		EnterRule(_localctx, 96, RULE_asmAttrAny);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 939;
			_la = TokenStream.LA(1);
			if ( !(_la==T__1 || _la==T__59 || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 127L) != 0)) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AsmAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AsmAttrAnyContext[] asmAttrAny() {
			return GetRuleContexts<AsmAttrAnyContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public AsmAttrAnyContext asmAttrAny(int i) {
			return GetRuleContext<AsmAttrAnyContext>(i);
		}
		public AsmAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_asmAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAsmAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AsmAttrContext asmAttr() {
		AsmAttrContext _localctx = new AsmAttrContext(Context, State);
		EnterRule(_localctx, 98, RULE_asmAttr);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 944;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__1 || _la==T__59 || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & 127L) != 0)) {
				{
				{
				State = 941;
				asmAttrAny();
				}
				}
				State = 946;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_noneContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_NONE() { return GetToken(CILParser.INSTR_NONE, 0); }
		public Instr_noneContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_none; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_none(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_noneContext instr_none() {
		Instr_noneContext _localctx = new Instr_noneContext(Context, State);
		EnterRule(_localctx, 100, RULE_instr_none);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 947;
			Match(INSTR_NONE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_varContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_VAR() { return GetToken(CILParser.INSTR_VAR, 0); }
		public Instr_varContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_var; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_var(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_varContext instr_var() {
		Instr_varContext _localctx = new Instr_varContext(Context, State);
		EnterRule(_localctx, 102, RULE_instr_var);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 949;
			Match(INSTR_VAR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_iContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_I() { return GetToken(CILParser.INSTR_I, 0); }
		public Instr_iContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_i; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_i(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_iContext instr_i() {
		Instr_iContext _localctx = new Instr_iContext(Context, State);
		EnterRule(_localctx, 104, RULE_instr_i);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 951;
			Match(INSTR_I);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_i8Context : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_I8() { return GetToken(CILParser.INSTR_I8, 0); }
		public Instr_i8Context(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_i8; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_i8(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_i8Context instr_i8() {
		Instr_i8Context _localctx = new Instr_i8Context(Context, State);
		EnterRule(_localctx, 106, RULE_instr_i8);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 953;
			Match(INSTR_I8);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_rContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_R() { return GetToken(CILParser.INSTR_R, 0); }
		public Instr_rContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_r; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_r(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_rContext instr_r() {
		Instr_rContext _localctx = new Instr_rContext(Context, State);
		EnterRule(_localctx, 108, RULE_instr_r);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 955;
			Match(INSTR_R);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_brtargetContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_BRTARGET() { return GetToken(CILParser.INSTR_BRTARGET, 0); }
		public Instr_brtargetContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_brtarget; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_brtarget(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_brtargetContext instr_brtarget() {
		Instr_brtargetContext _localctx = new Instr_brtargetContext(Context, State);
		EnterRule(_localctx, 110, RULE_instr_brtarget);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 957;
			Match(INSTR_BRTARGET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_methodContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_METHOD() { return GetToken(CILParser.INSTR_METHOD, 0); }
		public Instr_methodContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_method; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_method(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_methodContext instr_method() {
		Instr_methodContext _localctx = new Instr_methodContext(Context, State);
		EnterRule(_localctx, 112, RULE_instr_method);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 959;
			Match(INSTR_METHOD);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_fieldContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_FIELD() { return GetToken(CILParser.INSTR_FIELD, 0); }
		public Instr_fieldContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_field; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_field(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_fieldContext instr_field() {
		Instr_fieldContext _localctx = new Instr_fieldContext(Context, State);
		EnterRule(_localctx, 114, RULE_instr_field);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 961;
			Match(INSTR_FIELD);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_typeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TYPE() { return GetToken(CILParser.INSTR_TYPE, 0); }
		public Instr_typeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_type; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_type(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_typeContext instr_type() {
		Instr_typeContext _localctx = new Instr_typeContext(Context, State);
		EnterRule(_localctx, 116, RULE_instr_type);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 963;
			Match(INSTR_TYPE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_stringContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_STRING() { return GetToken(CILParser.INSTR_STRING, 0); }
		public Instr_stringContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_string; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_string(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_stringContext instr_string() {
		Instr_stringContext _localctx = new Instr_stringContext(Context, State);
		EnterRule(_localctx, 118, RULE_instr_string);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 965;
			Match(INSTR_STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_sigContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SIG() { return GetToken(CILParser.INSTR_SIG, 0); }
		public Instr_sigContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_sig; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_sig(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_sigContext instr_sig() {
		Instr_sigContext _localctx = new Instr_sigContext(Context, State);
		EnterRule(_localctx, 120, RULE_instr_sig);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 967;
			Match(INSTR_SIG);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_tokContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_TOK() { return GetToken(CILParser.INSTR_TOK, 0); }
		public Instr_tokContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_tok; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_tok(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_tokContext instr_tok() {
		Instr_tokContext _localctx = new Instr_tokContext(Context, State);
		EnterRule(_localctx, 122, RULE_instr_tok);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 969;
			Match(INSTR_TOK);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Instr_switchContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTR_SWITCH() { return GetToken(CILParser.INSTR_SWITCH, 0); }
		public Instr_switchContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr_switch; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr_switch(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Instr_switchContext instr_switch() {
		Instr_switchContext _localctx = new Instr_switchContext(Context, State);
		EnterRule(_localctx, 124, RULE_instr_switch);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 971;
			Match(INSTR_SWITCH);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InstrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Instr_noneContext instr_none() {
			return GetRuleContext<Instr_noneContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_varContext instr_var() {
			return GetRuleContext<Instr_varContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_iContext instr_i() {
			return GetRuleContext<Instr_iContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_i8Context instr_i8() {
			return GetRuleContext<Instr_i8Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() {
			return GetRuleContext<Int64Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_rContext instr_r() {
			return GetRuleContext<Instr_rContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() {
			return GetRuleContext<Float64Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_brtargetContext instr_brtarget() {
			return GetRuleContext<Instr_brtargetContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_methodContext instr_method() {
			return GetRuleContext<Instr_methodContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() {
			return GetRuleContext<MethodRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_fieldContext instr_field() {
			return GetRuleContext<Instr_fieldContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldRefContext fieldRef() {
			return GetRuleContext<FieldRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() {
			return GetRuleContext<MdtokenContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_typeContext instr_type() {
			return GetRuleContext<Instr_typeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_stringContext instr_string() {
			return GetRuleContext<Instr_stringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Instr_sigContext instr_sig() {
			return GetRuleContext<Instr_sigContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() {
			return GetRuleContext<SigArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_tokContext instr_tok() {
			return GetRuleContext<Instr_tokContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public OwnerTypeContext ownerType() {
			return GetRuleContext<OwnerTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Instr_switchContext instr_switch() {
			return GetRuleContext<Instr_switchContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LabelsContext labels() {
			return GetRuleContext<LabelsContext>(0);
		}
		public InstrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_instr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInstr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InstrContext instr() {
		InstrContext _localctx = new InstrContext(Context, State);
		EnterRule(_localctx, 126, RULE_instr);
		try {
			State = 1052;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,35,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 973;
				instr_none();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 974;
				instr_var();
				State = 975;
				int32();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 977;
				instr_var();
				State = 978;
				id();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 980;
				instr_i();
				State = 981;
				int32();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 983;
				instr_i8();
				State = 984;
				int64();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 986;
				instr_r();
				State = 987;
				float64();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 989;
				instr_r();
				State = 990;
				int64();
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 992;
				instr_r();
				State = 993;
				Match(T__28);
				State = 994;
				bytes();
				State = 995;
				Match(T__29);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 997;
				instr_r();
				State = 998;
				Match(T__82);
				State = 999;
				Match(T__28);
				State = 1000;
				bytes();
				State = 1001;
				Match(T__29);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 1003;
				instr_brtarget();
				State = 1004;
				int32();
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 1006;
				instr_brtarget();
				State = 1007;
				id();
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 1009;
				instr_method();
				State = 1010;
				methodRef();
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 1012;
				instr_field();
				State = 1013;
				fieldRef();
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 1015;
				instr_field();
				State = 1016;
				mdtoken();
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 1018;
				instr_type();
				State = 1019;
				typeSpec();
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 1021;
				instr_string();
				State = 1022;
				compQstring();
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 1024;
				instr_string();
				State = 1025;
				Match(ANSI);
				State = 1026;
				Match(T__28);
				State = 1027;
				compQstring();
				State = 1028;
				Match(T__29);
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 1030;
				instr_string();
				State = 1031;
				Match(T__82);
				State = 1032;
				Match(T__28);
				State = 1033;
				bytes();
				State = 1034;
				Match(T__29);
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 1036;
				instr_sig();
				State = 1037;
				callConv();
				State = 1038;
				type();
				State = 1039;
				sigArgs();
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 1041;
				instr_tok();
				State = 1042;
				ownerType();
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 1044;
				instr_switch();
				State = 1045;
				Match(T__28);
				State = 1046;
				labels();
				State = 1047;
				Match(T__29);
				}
				break;
			case 22:
				EnterOuterAlt(_localctx, 22);
				{
				State = 1049;
				instr_switch();
				State = 1050;
				Match(T__83);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class LabelsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public IdContext[] id() {
			return GetRuleContexts<IdContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id(int i) {
			return GetRuleContext<IdContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public LabelsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_labels; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLabels(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public LabelsContext labels() {
		LabelsContext _localctx = new LabelsContext(Context, State);
		EnterRule(_localctx, 128, RULE_labels);
		try {
			int _alt;
			State = 1070;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__29:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__0:
			case T__1:
			case T__2:
			case T__3:
			case T__4:
			case T__5:
			case T__6:
			case T__7:
			case T__8:
			case T__9:
			case T__10:
			case T__11:
			case T__12:
			case T__13:
			case T__14:
			case INT32:
			case VALUE:
			case INSTANCE:
			case UNMANAGED:
			case SQSTRING:
			case ID:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1063;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,37,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1057;
						ErrorHandler.Sync(this);
						switch (TokenStream.LA(1)) {
						case T__0:
						case T__1:
						case T__2:
						case T__3:
						case T__4:
						case T__5:
						case T__6:
						case T__7:
						case T__8:
						case T__9:
						case T__10:
						case T__11:
						case T__12:
						case T__13:
						case T__14:
						case VALUE:
						case INSTANCE:
						case UNMANAGED:
						case SQSTRING:
						case ID:
							{
							State = 1055;
							id();
							}
							break;
						case INT32:
							{
							State = 1056;
							int32();
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						State = 1059;
						Match(T__26);
						}
						} 
					}
					State = 1065;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,37,Context);
				}
				State = 1068;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case T__0:
				case T__1:
				case T__2:
				case T__3:
				case T__4:
				case T__5:
				case T__6:
				case T__7:
				case T__8:
				case T__9:
				case T__10:
				case T__11:
				case T__12:
				case T__13:
				case T__14:
				case VALUE:
				case INSTANCE:
				case UNMANAGED:
				case SQSTRING:
				case ID:
					{
					State = 1066;
					id();
					}
					break;
				case INT32:
					{
					State = 1067;
					int32();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeArgsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext[] type() {
			return GetRuleContexts<TypeContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type(int i) {
			return GetRuleContext<TypeContext>(i);
		}
		public TypeArgsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typeArgs; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypeArgs(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypeArgsContext typeArgs() {
		TypeArgsContext _localctx = new TypeArgsContext(Context, State);
		EnterRule(_localctx, 130, RULE_typeArgs);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1072;
			Match(T__84);
			State = 1078;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,40,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1073;
					type();
					State = 1074;
					Match(T__26);
					}
					} 
				}
				State = 1080;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,40,Context);
			}
			State = 1081;
			type();
			State = 1082;
			Match(T__85);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BoundsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public BoundContext[] bound() {
			return GetRuleContexts<BoundContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public BoundContext bound(int i) {
			return GetRuleContext<BoundContext>(i);
		}
		public BoundsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_bounds; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBounds(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BoundsContext bounds() {
		BoundsContext _localctx = new BoundsContext(Context, State);
		EnterRule(_localctx, 132, RULE_bounds);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1084;
			Match(T__40);
			State = 1090;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,41,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1085;
					bound();
					State = 1086;
					Match(T__26);
					}
					} 
				}
				State = 1092;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,41,Context);
			}
			State = 1093;
			bound();
			State = 1094;
			Match(T__41);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SigArgsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SigArgContext[] sigArg() {
			return GetRuleContexts<SigArgContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgContext sigArg(int i) {
			return GetRuleContext<SigArgContext>(i);
		}
		public SigArgsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sigArgs; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSigArgs(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SigArgsContext sigArgs() {
		SigArgsContext _localctx = new SigArgsContext(Context, State);
		EnterRule(_localctx, 134, RULE_sigArgs);
		try {
			int _alt;
			State = 1109;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__28:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1096;
				Match(T__28);
				State = 1102;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,42,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1097;
						sigArg();
						State = 1098;
						Match(T__26);
						}
						} 
					}
					State = 1104;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,42,Context);
				}
				State = 1105;
				sigArg();
				State = 1106;
				Match(T__29);
				}
				break;
			case T__83:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1108;
				Match(T__83);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SigArgContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELLIPSIS() { return GetToken(CILParser.ELLIPSIS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ParamAttrContext paramAttr() {
			return GetRuleContext<ParamAttrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MarshalClauseContext marshalClause() {
			return GetRuleContext<MarshalClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		public SigArgContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sigArg; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSigArg(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SigArgContext sigArg() {
		SigArgContext _localctx = new SigArgContext(Context, State);
		EnterRule(_localctx, 136, RULE_sigArg);
		int _la;
		try {
			State = 1118;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,45,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1111;
				Match(ELLIPSIS);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1112;
				paramAttr();
				State = 1113;
				type();
				State = 1114;
				marshalClause();
				State = 1116;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65534L) != 0) || ((((_la - 198)) & ~0x3f) == 0 && ((1L << (_la - 198)) & 299067162755073L) != 0) || _la==SQSTRING || _la==ID) {
					{
					State = 1115;
					id();
					}
				}

				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassNameContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SlashedNameContext slashedName() {
			return GetRuleContext<SlashedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() {
			return GetRuleContext<MdtokenContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MODULE() { return GetToken(CILParser.MODULE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode THIS() { return GetToken(CILParser.THIS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BASE() { return GetToken(CILParser.BASE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NESTER() { return GetToken(CILParser.NESTER, 0); }
		public ClassNameContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_className; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassName(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassNameContext className() {
		ClassNameContext _localctx = new ClassNameContext(Context, State);
		EnterRule(_localctx, 138, RULE_className);
		try {
			State = 1145;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,46,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1120;
				Match(T__40);
				State = 1121;
				dottedName();
				State = 1122;
				Match(T__41);
				State = 1123;
				slashedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1125;
				Match(T__40);
				State = 1126;
				mdtoken();
				State = 1127;
				Match(T__41);
				State = 1128;
				slashedName();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1130;
				Match(T__40);
				State = 1131;
				Match(PTR);
				State = 1132;
				Match(T__41);
				State = 1133;
				slashedName();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1134;
				Match(T__40);
				State = 1135;
				Match(MODULE);
				State = 1136;
				dottedName();
				State = 1137;
				Match(T__41);
				State = 1138;
				slashedName();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1140;
				slashedName();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1141;
				mdtoken();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1142;
				Match(THIS);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1143;
				Match(BASE);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 1144;
				Match(NESTER);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SlashedNameContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() {
			return GetRuleContexts<DottedNameContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName(int i) {
			return GetRuleContext<DottedNameContext>(i);
		}
		public SlashedNameContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_slashedName; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSlashedName(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SlashedNameContext slashedName() {
		SlashedNameContext _localctx = new SlashedNameContext(Context, State);
		EnterRule(_localctx, 140, RULE_slashedName);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1152;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,47,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1147;
					dottedName();
					State = 1148;
					Match(T__86);
					}
					} 
				}
				State = 1154;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,47,Context);
			}
			State = 1155;
			dottedName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssemblyDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyDeclContext[] assemblyDecl() {
			return GetRuleContexts<AssemblyDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyDeclContext assemblyDecl(int i) {
			return GetRuleContext<AssemblyDeclContext>(i);
		}
		public AssemblyDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assemblyDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssemblyDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssemblyDeclsContext assemblyDecls() {
		AssemblyDeclsContext _localctx = new AssemblyDeclsContext(Context, State);
		EnterRule(_localctx, 142, RULE_assemblyDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1160;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__30 || _la==T__33 || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 2147487751L) != 0) || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & 6860954690125825L) != 0)) {
				{
				{
				State = 1157;
				assemblyDecl();
				}
				}
				State = 1162;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssemblyDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HASH() { return GetToken(CILParser.HASH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() {
			return GetRuleContext<SecDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AsmOrRefDeclContext asmOrRefDecl() {
			return GetRuleContext<AsmOrRefDeclContext>(0);
		}
		public AssemblyDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assemblyDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssemblyDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssemblyDeclContext assemblyDecl() {
		AssemblyDeclContext _localctx = new AssemblyDeclContext(Context, State);
		EnterRule(_localctx, 144, RULE_assemblyDecl);
		try {
			State = 1168;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case HASH:
				EnterOuterAlt(_localctx, 1);
				{
				{
				State = 1163;
				Match(HASH);
				State = 1164;
				Match(T__87);
				State = 1165;
				int32();
				}
				}
				break;
			case PERMISSION:
			case PERMISSIONSET:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1166;
				secDecl();
				}
				break;
			case T__30:
			case T__33:
			case T__166:
			case T__167:
			case T__168:
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1167;
				asmOrRefDecl();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeSpecContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MODULE() { return GetToken(CILParser.MODULE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		public TypeSpecContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typeSpec; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypeSpec(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypeSpecContext typeSpec() {
		TypeSpecContext _localctx = new TypeSpecContext(Context, State);
		EnterRule(_localctx, 146, RULE_typeSpec);
		try {
			State = 1181;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,50,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1170;
				className();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1171;
				Match(T__40);
				State = 1172;
				dottedName();
				State = 1173;
				Match(T__41);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1175;
				Match(T__40);
				State = 1176;
				Match(MODULE);
				State = 1177;
				dottedName();
				State = 1178;
				Match(T__41);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1180;
				type();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NativeTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public NativeTypeElementContext nativeTypeElement() {
			return GetRuleContext<NativeTypeElementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public NativeTypeArrayPointerInfoContext[] nativeTypeArrayPointerInfo() {
			return GetRuleContexts<NativeTypeArrayPointerInfoContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo(int i) {
			return GetRuleContext<NativeTypeArrayPointerInfoContext>(i);
		}
		public NativeTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nativeType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNativeType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NativeTypeContext nativeType() {
		NativeTypeContext _localctx = new NativeTypeContext(Context, State);
		EnterRule(_localctx, 148, RULE_nativeType);
		try {
			int _alt;
			State = 1191;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,52,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1184;
				nativeTypeElement();
				State = 1188;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,51,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1185;
						nativeTypeArrayPointerInfo();
						}
						} 
					}
					State = 1190;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,51,Context);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NativeTypeArrayPointerInfoContext : ParserRuleContext {
		public NativeTypeArrayPointerInfoContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nativeTypeArrayPointerInfo; } }
	 
		public NativeTypeArrayPointerInfoContext() { }
		public virtual void CopyFrom(NativeTypeArrayPointerInfoContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class PointerArrayTypeSizeContext : NativeTypeArrayPointerInfoContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public PointerArrayTypeSizeContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeSize(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class PointerArrayTypeParamIndexContext : NativeTypeArrayPointerInfoContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(CILParser.PLUS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public PointerArrayTypeParamIndexContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeParamIndex(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class PointerNativeTypeContext : NativeTypeArrayPointerInfoContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		public PointerNativeTypeContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPointerNativeType(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class PointerArrayTypeSizeParamIndexContext : NativeTypeArrayPointerInfoContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(CILParser.PLUS, 0); }
		public PointerArrayTypeSizeParamIndexContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeSizeParamIndex(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class PointerArrayTypeNoSizeDataContext : NativeTypeArrayPointerInfoContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_TYPE_NO_BOUNDS() { return GetToken(CILParser.ARRAY_TYPE_NO_BOUNDS, 0); }
		public PointerArrayTypeNoSizeDataContext(NativeTypeArrayPointerInfoContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPointerArrayTypeNoSizeData(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NativeTypeArrayPointerInfoContext nativeTypeArrayPointerInfo() {
		NativeTypeArrayPointerInfoContext _localctx = new NativeTypeArrayPointerInfoContext(Context, State);
		EnterRule(_localctx, 150, RULE_nativeTypeArrayPointerInfo);
		try {
			State = 1210;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,53,Context) ) {
			case 1:
				_localctx = new PointerNativeTypeContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 1193;
				Match(PTR);
				}
				break;
			case 2:
				_localctx = new PointerArrayTypeNoSizeDataContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 1194;
				Match(ARRAY_TYPE_NO_BOUNDS);
				}
				break;
			case 3:
				_localctx = new PointerArrayTypeSizeContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 1195;
				Match(T__40);
				State = 1196;
				int32();
				State = 1197;
				Match(T__41);
				}
				break;
			case 4:
				_localctx = new PointerArrayTypeSizeParamIndexContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 1199;
				Match(T__40);
				State = 1200;
				int32();
				State = 1201;
				Match(PLUS);
				State = 1202;
				int32();
				State = 1203;
				Match(T__41);
				}
				break;
			case 5:
				_localctx = new PointerArrayTypeParamIndexContext(_localctx);
				EnterOuterAlt(_localctx, 5);
				{
				State = 1205;
				Match(T__40);
				State = 1206;
				Match(PLUS);
				State = 1207;
				int32();
				State = 1208;
				Match(T__41);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NativeTypeElementContext : ParserRuleContext {
		public IToken marshalType;
		public IToken marshalBool;
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext[] compQstring() {
			return GetRuleContexts<CompQstringContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring(int i) {
			return GetRuleContext<CompQstringContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CUSTOM() { return GetToken(CILParser.CUSTOM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FIXED() { return GetToken(CILParser.FIXED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SYSSTRING() { return GetToken(CILParser.SYSSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public NativeTypeContext nativeType() {
			return GetRuleContext<NativeTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY() { return GetToken(CILParser.ARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARIANT() { return GetToken(CILParser.VARIANT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CURRENCY() { return GetToken(CILParser.CURRENCY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SYSCHAR() { return GetToken(CILParser.SYSCHAR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VOID() { return GetToken(CILParser.VOID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(CILParser.BOOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ERROR() { return GetToken(CILParser.ERROR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT8() { return GetToken(CILParser.UINT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT16() { return GetToken(CILParser.UINT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT32() { return GetToken(CILParser.UINT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT64() { return GetToken(CILParser.UINT64, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DECIMAL() { return GetToken(CILParser.DECIMAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATE() { return GetToken(CILParser.DATE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BSTR() { return GetToken(CILParser.BSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPSTR() { return GetToken(CILParser.LPSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPWSTR() { return GetToken(CILParser.LPWSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPTSTR() { return GetToken(CILParser.LPTSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OBJECTREF() { return GetToken(CILParser.OBJECTREF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IidParamIndexContext iidParamIndex() {
			return GetRuleContext<IidParamIndexContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IUNKNOWN() { return GetToken(CILParser.IUNKNOWN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDISPATCH() { return GetToken(CILParser.IDISPATCH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRUCT() { return GetToken(CILParser.STRUCT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INTERFACE() { return GetToken(CILParser.INTERFACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public VariantTypeContext variantType() {
			return GetRuleContext<VariantTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SAFEARRAY() { return GetToken(CILParser.SAFEARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(CILParser.UINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BYVALSTR() { return GetToken(CILParser.BYVALSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TBSTR() { return GetToken(CILParser.TBSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD() { return GetToken(CILParser.METHOD, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPSTRUCT() { return GetToken(CILParser.LPSTRUCT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANY() { return GetToken(CILParser.ANY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public NativeTypeElementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nativeTypeElement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNativeTypeElement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NativeTypeElementContext nativeTypeElement() {
		NativeTypeElementContext _localctx = new NativeTypeElementContext(Context, State);
		EnterRule(_localctx, 152, RULE_nativeTypeElement);
		try {
			State = 1296;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,54,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1213;
				_localctx.marshalType = Match(CUSTOM);
				State = 1214;
				Match(T__28);
				State = 1215;
				compQstring();
				State = 1216;
				Match(T__26);
				State = 1217;
				compQstring();
				State = 1218;
				Match(T__26);
				State = 1219;
				compQstring();
				State = 1220;
				Match(T__26);
				State = 1221;
				compQstring();
				State = 1222;
				Match(T__29);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1224;
				_localctx.marshalType = Match(CUSTOM);
				State = 1225;
				Match(T__28);
				State = 1226;
				compQstring();
				State = 1227;
				Match(T__26);
				State = 1228;
				compQstring();
				State = 1229;
				Match(T__29);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1231;
				Match(FIXED);
				State = 1232;
				_localctx.marshalType = Match(SYSSTRING);
				State = 1233;
				Match(T__40);
				State = 1234;
				int32();
				State = 1235;
				Match(T__41);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1237;
				Match(FIXED);
				State = 1238;
				_localctx.marshalType = Match(ARRAY);
				State = 1239;
				Match(T__40);
				State = 1240;
				int32();
				State = 1241;
				Match(T__41);
				State = 1242;
				nativeType();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1244;
				_localctx.marshalType = Match(VARIANT);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1245;
				_localctx.marshalType = Match(CURRENCY);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1246;
				_localctx.marshalType = Match(SYSCHAR);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 1247;
				_localctx.marshalType = Match(VOID);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 1248;
				_localctx.marshalType = Match(BOOL);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 1249;
				_localctx.marshalType = Match(INT8);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 1250;
				_localctx.marshalType = Match(INT16);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 1251;
				_localctx.marshalType = Match(INT32_);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 1252;
				_localctx.marshalType = Match(INT64_);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 1253;
				_localctx.marshalType = Match(FLOAT32);
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 1254;
				_localctx.marshalType = Match(FLOAT64_);
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 1255;
				_localctx.marshalType = Match(ERROR);
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 1256;
				_localctx.marshalType = Match(UINT8);
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 1257;
				_localctx.marshalType = Match(UINT16);
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 1258;
				_localctx.marshalType = Match(UINT32);
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 1259;
				_localctx.marshalType = Match(UINT64);
				}
				break;
			case 22:
				EnterOuterAlt(_localctx, 22);
				{
				State = 1260;
				_localctx.marshalType = Match(DECIMAL);
				}
				break;
			case 23:
				EnterOuterAlt(_localctx, 23);
				{
				State = 1261;
				_localctx.marshalType = Match(DATE);
				}
				break;
			case 24:
				EnterOuterAlt(_localctx, 24);
				{
				State = 1262;
				_localctx.marshalType = Match(BSTR);
				}
				break;
			case 25:
				EnterOuterAlt(_localctx, 25);
				{
				State = 1263;
				_localctx.marshalType = Match(LPSTR);
				}
				break;
			case 26:
				EnterOuterAlt(_localctx, 26);
				{
				State = 1264;
				_localctx.marshalType = Match(LPWSTR);
				}
				break;
			case 27:
				EnterOuterAlt(_localctx, 27);
				{
				State = 1265;
				_localctx.marshalType = Match(LPTSTR);
				}
				break;
			case 28:
				EnterOuterAlt(_localctx, 28);
				{
				State = 1266;
				_localctx.marshalType = Match(OBJECTREF);
				}
				break;
			case 29:
				EnterOuterAlt(_localctx, 29);
				{
				State = 1267;
				_localctx.marshalType = Match(IUNKNOWN);
				State = 1268;
				iidParamIndex();
				}
				break;
			case 30:
				EnterOuterAlt(_localctx, 30);
				{
				State = 1269;
				_localctx.marshalType = Match(IDISPATCH);
				State = 1270;
				iidParamIndex();
				}
				break;
			case 31:
				EnterOuterAlt(_localctx, 31);
				{
				State = 1271;
				_localctx.marshalType = Match(STRUCT);
				}
				break;
			case 32:
				EnterOuterAlt(_localctx, 32);
				{
				State = 1272;
				_localctx.marshalType = Match(INTERFACE);
				State = 1273;
				iidParamIndex();
				}
				break;
			case 33:
				EnterOuterAlt(_localctx, 33);
				{
				State = 1274;
				_localctx.marshalType = Match(SAFEARRAY);
				State = 1275;
				variantType();
				}
				break;
			case 34:
				EnterOuterAlt(_localctx, 34);
				{
				State = 1276;
				_localctx.marshalType = Match(SAFEARRAY);
				State = 1277;
				variantType();
				State = 1278;
				Match(T__26);
				State = 1279;
				compQstring();
				}
				break;
			case 35:
				EnterOuterAlt(_localctx, 35);
				{
				State = 1281;
				_localctx.marshalType = Match(INT);
				}
				break;
			case 36:
				EnterOuterAlt(_localctx, 36);
				{
				State = 1282;
				_localctx.marshalType = Match(UINT);
				}
				break;
			case 37:
				EnterOuterAlt(_localctx, 37);
				{
				State = 1283;
				Match(T__60);
				State = 1284;
				_localctx.marshalType = Match(STRUCT);
				}
				break;
			case 38:
				EnterOuterAlt(_localctx, 38);
				{
				State = 1285;
				_localctx.marshalType = Match(BYVALSTR);
				}
				break;
			case 39:
				EnterOuterAlt(_localctx, 39);
				{
				State = 1286;
				Match(ANSI);
				State = 1287;
				_localctx.marshalType = Match(BSTR);
				}
				break;
			case 40:
				EnterOuterAlt(_localctx, 40);
				{
				State = 1288;
				_localctx.marshalType = Match(TBSTR);
				}
				break;
			case 41:
				EnterOuterAlt(_localctx, 41);
				{
				State = 1289;
				Match(VARIANT);
				State = 1290;
				_localctx.marshalBool = Match(BOOL);
				}
				break;
			case 42:
				EnterOuterAlt(_localctx, 42);
				{
				State = 1291;
				_localctx.marshalType = Match(METHOD);
				}
				break;
			case 43:
				EnterOuterAlt(_localctx, 43);
				{
				State = 1292;
				_localctx.marshalType = Match(LPSTRUCT);
				}
				break;
			case 44:
				EnterOuterAlt(_localctx, 44);
				{
				State = 1293;
				Match(T__32);
				State = 1294;
				_localctx.marshalType = Match(ANY);
				}
				break;
			case 45:
				EnterOuterAlt(_localctx, 45);
				{
				State = 1295;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IidParamIndexContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public IidParamIndexContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_iidParamIndex; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIidParamIndex(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public IidParamIndexContext iidParamIndex() {
		IidParamIndexContext _localctx = new IidParamIndexContext(Context, State);
		EnterRule(_localctx, 154, RULE_iidParamIndex);
		try {
			State = 1305;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__29:
			case T__40:
			case ARRAY_TYPE_NO_BOUNDS:
			case PTR:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__28:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1299;
				Match(T__28);
				State = 1300;
				Match(T__88);
				State = 1301;
				Match(T__34);
				State = 1302;
				int32();
				State = 1303;
				Match(T__29);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VariantTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public VariantTypeElementContext variantTypeElement() {
			return GetRuleContext<VariantTypeElementContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] ARRAY_TYPE_NO_BOUNDS() { return GetTokens(CILParser.ARRAY_TYPE_NO_BOUNDS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_TYPE_NO_BOUNDS(int i) {
			return GetToken(CILParser.ARRAY_TYPE_NO_BOUNDS, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] VECTOR() { return GetTokens(CILParser.VECTOR); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VECTOR(int i) {
			return GetToken(CILParser.VECTOR, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] REF() { return GetTokens(CILParser.REF); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REF(int i) {
			return GetToken(CILParser.REF, i);
		}
		public VariantTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variantType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariantType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VariantTypeContext variantType() {
		VariantTypeContext _localctx = new VariantTypeContext(Context, State);
		EnterRule(_localctx, 156, RULE_variantType);
		int _la;
		try {
			int _alt;
			State = 1315;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,57,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1308;
				variantTypeElement();
				State = 1312;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,56,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1309;
						_la = TokenStream.LA(1);
						if ( !(((((_la - 228)) & ~0x3f) == 0 && ((1L << (_la - 228)) & 6442450945L) != 0)) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						}
						} 
					}
					State = 1314;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,56,Context);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VariantTypeElementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULL() { return GetToken(CILParser.NULL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARIANT() { return GetToken(CILParser.VARIANT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CURRENCY() { return GetToken(CILParser.CURRENCY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VOID() { return GetToken(CILParser.VOID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(CILParser.BOOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT8() { return GetToken(CILParser.UINT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT16() { return GetToken(CILParser.UINT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT32() { return GetToken(CILParser.UINT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT64() { return GetToken(CILParser.UINT64, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DECIMAL() { return GetToken(CILParser.DECIMAL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DATE() { return GetToken(CILParser.DATE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BSTR() { return GetToken(CILParser.BSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPSTR() { return GetToken(CILParser.LPSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPWSTR() { return GetToken(CILParser.LPWSTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IUNKNOWN() { return GetToken(CILParser.IUNKNOWN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDISPATCH() { return GetToken(CILParser.IDISPATCH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SAFEARRAY() { return GetToken(CILParser.SAFEARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(CILParser.UINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ERROR() { return GetToken(CILParser.ERROR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HRESULT() { return GetToken(CILParser.HRESULT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CARRAY() { return GetToken(CILParser.CARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode USERDEFINED() { return GetToken(CILParser.USERDEFINED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RECORD() { return GetToken(CILParser.RECORD, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FILETIME() { return GetToken(CILParser.FILETIME, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BLOB() { return GetToken(CILParser.BLOB, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STREAM() { return GetToken(CILParser.STREAM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STORAGE() { return GetToken(CILParser.STORAGE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STREAMED_OBJECT() { return GetToken(CILParser.STREAMED_OBJECT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STORED_OBJECT() { return GetToken(CILParser.STORED_OBJECT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BLOB_OBJECT() { return GetToken(CILParser.BLOB_OBJECT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CF() { return GetToken(CILParser.CF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CLSID() { return GetToken(CILParser.CLSID, 0); }
		public VariantTypeElementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variantTypeElement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariantTypeElement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VariantTypeElementContext variantTypeElement() {
		VariantTypeElementContext _localctx = new VariantTypeElementContext(Context, State);
		EnterRule(_localctx, 158, RULE_variantTypeElement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1317;
			_la = TokenStream.LA(1);
			if ( !(((((_la - 177)) & ~0x3f) == 0 && ((1L << (_la - 177)) & -4482436704239647L) != 0) || _la==CLSID || _la==PTR) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ElementTypeContext elementType() {
			return GetRuleContext<ElementTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeModifiersContext[] typeModifiers() {
			return GetRuleContexts<TypeModifiersContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeModifiersContext typeModifiers(int i) {
			return GetRuleContext<TypeModifiersContext>(i);
		}
		public TypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_type; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypeContext type() {
		TypeContext _localctx = new TypeContext(Context, State);
		EnterRule(_localctx, 160, RULE_type);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1319;
			elementType();
			State = 1323;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,58,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1320;
					typeModifiers();
					}
					} 
				}
				State = 1325;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,58,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeModifiersContext : ParserRuleContext {
		public TypeModifiersContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typeModifiers; } }
	 
		public TypeModifiersContext() { }
		public virtual void CopyFrom(TypeModifiersContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class OptionalModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		public OptionalModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitOptionalModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class SZArrayModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY_TYPE_NO_BOUNDS() { return GetToken(CILParser.ARRAY_TYPE_NO_BOUNDS, 0); }
		public SZArrayModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSZArrayModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class RequiredModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		public RequiredModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitRequiredModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class PtrModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		public PtrModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPtrModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class PinnedModifierContext : TypeModifiersContext {
		public PinnedModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPinnedModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class GenericArgumentsModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeArgsContext typeArgs() {
			return GetRuleContext<TypeArgsContext>(0);
		}
		public GenericArgumentsModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitGenericArgumentsModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ByRefModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REF() { return GetToken(CILParser.REF, 0); }
		public ByRefModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitByRefModifier(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ArrayModifierContext : TypeModifiersContext {
		[System.Diagnostics.DebuggerNonUserCode] public BoundsContext bounds() {
			return GetRuleContext<BoundsContext>(0);
		}
		public ArrayModifierContext(TypeModifiersContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitArrayModifier(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypeModifiersContext typeModifiers() {
		TypeModifiersContext _localctx = new TypeModifiersContext(Context, State);
		EnterRule(_localctx, 162, RULE_typeModifiers);
		try {
			State = 1344;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,59,Context) ) {
			case 1:
				_localctx = new SZArrayModifierContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 1326;
				Match(ARRAY_TYPE_NO_BOUNDS);
				}
				break;
			case 2:
				_localctx = new SZArrayModifierContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 1327;
				Match(T__40);
				State = 1328;
				Match(T__41);
				}
				break;
			case 3:
				_localctx = new ArrayModifierContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 1329;
				bounds();
				}
				break;
			case 4:
				_localctx = new ByRefModifierContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 1330;
				Match(REF);
				}
				break;
			case 5:
				_localctx = new PtrModifierContext(_localctx);
				EnterOuterAlt(_localctx, 5);
				{
				State = 1331;
				Match(PTR);
				}
				break;
			case 6:
				_localctx = new PinnedModifierContext(_localctx);
				EnterOuterAlt(_localctx, 6);
				{
				State = 1332;
				Match(T__89);
				}
				break;
			case 7:
				_localctx = new RequiredModifierContext(_localctx);
				EnterOuterAlt(_localctx, 7);
				{
				State = 1333;
				Match(T__90);
				State = 1334;
				Match(T__28);
				State = 1335;
				typeSpec();
				State = 1336;
				Match(T__29);
				}
				break;
			case 8:
				_localctx = new OptionalModifierContext(_localctx);
				EnterOuterAlt(_localctx, 8);
				{
				State = 1338;
				Match(T__91);
				State = 1339;
				Match(T__28);
				State = 1340;
				typeSpec();
				State = 1341;
				Match(T__29);
				}
				break;
			case 9:
				_localctx = new GenericArgumentsModifierContext(_localctx);
				EnterOuterAlt(_localctx, 9);
				{
				State = 1343;
				typeArgs();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ElementTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OBJECT() { return GetToken(CILParser.OBJECT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUE() { return GetToken(CILParser.VALUE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUETYPE() { return GetToken(CILParser.VALUETYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD() { return GetToken(CILParser.METHOD, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() {
			return GetRuleContext<SigArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD_TYPE_PARAMETER() { return GetToken(CILParser.METHOD_TYPE_PARAMETER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE_PARAMETER() { return GetToken(CILParser.TYPE_PARAMETER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPEDREF() { return GetToken(CILParser.TYPEDREF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VOID() { return GetToken(CILParser.VOID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public NativeIntContext nativeInt() {
			return GetRuleContext<NativeIntContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public NativeUintContext nativeUint() {
			return GetRuleContext<NativeUintContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SimpleTypeContext simpleType() {
			return GetRuleContext<SimpleTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELLIPSIS() { return GetToken(CILParser.ELLIPSIS, 0); }
		public ElementTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_elementType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitElementType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ElementTypeContext elementType() {
		ElementTypeContext _localctx = new ElementTypeContext(Context, State);
		EnterRule(_localctx, 164, RULE_elementType);
		try {
			State = 1376;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,60,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1346;
				Match(T__37);
				State = 1347;
				className();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1348;
				Match(OBJECT);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1349;
				Match(VALUE);
				State = 1350;
				Match(T__37);
				State = 1351;
				className();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1352;
				Match(VALUETYPE);
				State = 1353;
				className();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1354;
				Match(METHOD);
				State = 1355;
				callConv();
				State = 1356;
				type();
				State = 1357;
				Match(PTR);
				State = 1358;
				sigArgs();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1360;
				Match(METHOD_TYPE_PARAMETER);
				State = 1361;
				int32();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1362;
				Match(TYPE_PARAMETER);
				State = 1363;
				int32();
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1364;
				Match(METHOD_TYPE_PARAMETER);
				State = 1365;
				dottedName();
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 1366;
				Match(TYPE_PARAMETER);
				State = 1367;
				dottedName();
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 1368;
				Match(TYPEDREF);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 1369;
				Match(VOID);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 1370;
				nativeInt();
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 1371;
				nativeUint();
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 1372;
				simpleType();
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 1373;
				dottedName();
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 1374;
				Match(ELLIPSIS);
				State = 1375;
				type();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SimpleTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(CILParser.CHAR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(CILParser.STRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(CILParser.BOOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT8() { return GetToken(CILParser.UINT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT16() { return GetToken(CILParser.UINT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT32() { return GetToken(CILParser.UINT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT64() { return GetToken(CILParser.UINT64, 0); }
		public SimpleTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_simpleType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSimpleType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SimpleTypeContext simpleType() {
		SimpleTypeContext _localctx = new SimpleTypeContext(Context, State);
		EnterRule(_localctx, 166, RULE_simpleType);
		try {
			State = 1399;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,61,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1378;
				Match(CHAR);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1379;
				Match(STRING);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1380;
				Match(BOOL);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1381;
				Match(INT8);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1382;
				Match(INT16);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1383;
				Match(INT32_);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1384;
				Match(INT64_);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1385;
				Match(FLOAT32);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 1386;
				Match(FLOAT64_);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 1387;
				Match(UINT8);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 1388;
				Match(UINT16);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 1389;
				Match(UINT32);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 1390;
				Match(UINT64);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 1391;
				Match(T__92);
				State = 1392;
				Match(INT8);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 1393;
				Match(T__92);
				State = 1394;
				Match(INT16);
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 1395;
				Match(T__92);
				State = 1396;
				Match(INT32_);
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 1397;
				Match(T__92);
				State = 1398;
				Match(INT64_);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BoundContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELLIPSIS() { return GetToken(CILParser.ELLIPSIS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public BoundContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_bound; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBound(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BoundContext bound() {
		BoundContext _localctx = new BoundContext(Context, State);
		EnterRule(_localctx, 168, RULE_bound);
		try {
			State = 1411;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,62,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1402;
				Match(ELLIPSIS);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1403;
				int32();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1404;
				int32();
				State = 1405;
				Match(ELLIPSIS);
				State = 1406;
				int32();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1408;
				int32();
				State = 1409;
				Match(ELLIPSIS);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NativeIntContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); }
		public NativeIntContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nativeInt; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNativeInt(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NativeIntContext nativeInt() {
		NativeIntContext _localctx = new NativeIntContext(Context, State);
		EnterRule(_localctx, 170, RULE_nativeInt);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1413;
			Match(T__0);
			State = 1414;
			Match(INT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NativeUintContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(CILParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT() { return GetToken(CILParser.UINT, 0); }
		public NativeUintContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nativeUint; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNativeUint(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NativeUintContext nativeUint() {
		NativeUintContext _localctx = new NativeUintContext(Context, State);
		EnterRule(_localctx, 172, RULE_nativeUint);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1416;
			Match(T__0);
			State = 1420;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__92:
				{
				State = 1417;
				Match(T__92);
				State = 1418;
				Match(INT);
				}
				break;
			case UINT:
				{
				State = 1419;
				Match(UINT);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SecDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PERMISSION() { return GetToken(CILParser.PERMISSION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public SecActionContext secAction() {
			return GetRuleContext<SecActionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public NameValPairsContext nameValPairs() {
			return GetRuleContext<NameValPairsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomBlobDescrContext customBlobDescr() {
			return GetRuleContext<CustomBlobDescrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PERMISSIONSET() { return GetToken(CILParser.PERMISSIONSET, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SecAttrSetBlobContext secAttrSetBlob() {
			return GetRuleContext<SecAttrSetBlobContext>(0);
		}
		public SecDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_secDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSecDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SecDeclContext secDecl() {
		SecDeclContext _localctx = new SecDeclContext(Context, State);
		EnterRule(_localctx, 174, RULE_secDecl);
		int _la;
		try {
			State = 1462;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,65,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1422;
				Match(PERMISSION);
				State = 1423;
				secAction();
				State = 1424;
				typeSpec();
				State = 1425;
				Match(T__28);
				State = 1426;
				nameValPairs();
				State = 1427;
				Match(T__29);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1429;
				Match(PERMISSION);
				State = 1430;
				secAction();
				State = 1431;
				typeSpec();
				State = 1432;
				Match(T__34);
				State = 1433;
				Match(T__15);
				State = 1434;
				customBlobDescr();
				State = 1435;
				Match(T__16);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1437;
				Match(PERMISSION);
				State = 1438;
				secAction();
				State = 1439;
				typeSpec();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1441;
				Match(PERMISSIONSET);
				State = 1442;
				secAction();
				State = 1443;
				Match(T__34);
				State = 1445;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==T__82) {
					{
					State = 1444;
					Match(T__82);
					}
				}

				State = 1447;
				Match(T__28);
				State = 1448;
				bytes();
				State = 1449;
				Match(T__29);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1451;
				Match(PERMISSIONSET);
				State = 1452;
				secAction();
				State = 1453;
				compQstring();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1455;
				Match(PERMISSIONSET);
				State = 1456;
				secAction();
				State = 1457;
				Match(T__34);
				State = 1458;
				Match(T__15);
				State = 1459;
				secAttrSetBlob();
				State = 1460;
				Match(T__16);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SecAttrSetBlobContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SecAttrBlobContext[] secAttrBlob() {
			return GetRuleContexts<SecAttrBlobContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SecAttrBlobContext secAttrBlob(int i) {
			return GetRuleContext<SecAttrBlobContext>(i);
		}
		public SecAttrSetBlobContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_secAttrSetBlob; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSecAttrSetBlob(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SecAttrSetBlobContext secAttrSetBlob() {
		SecAttrSetBlobContext _localctx = new SecAttrSetBlobContext(Context, State);
		EnterRule(_localctx, 176, RULE_secAttrSetBlob);
		try {
			int _alt;
			State = 1474;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__16:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__0:
			case T__37:
			case T__40:
			case T__92:
			case T__111:
			case ELLIPSIS:
			case CHAR:
			case STRING:
			case BOOL:
			case INT8:
			case INT16:
			case INT32_:
			case INT64_:
			case FLOAT32:
			case FLOAT64_:
			case UINT8:
			case UINT16:
			case UINT32:
			case UINT64:
			case OBJECT:
			case VALUE:
			case VALUETYPE:
			case VOID:
			case METHOD:
			case INSTANCE:
			case TYPE_PARAMETER:
			case METHOD_TYPE_PARAMETER:
			case TYPEDREF:
			case THIS:
			case BASE:
			case NESTER:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1470;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,66,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1465;
						secAttrBlob();
						State = 1466;
						Match(T__26);
						}
						} 
					}
					State = 1472;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,66,Context);
				}
				State = 1473;
				secAttrBlob();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SecAttrBlobContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CustomBlobNVPairsContext customBlobNVPairs() {
			return GetRuleContext<CustomBlobNVPairsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		public SecAttrBlobContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_secAttrBlob; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSecAttrBlob(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SecAttrBlobContext secAttrBlob() {
		SecAttrBlobContext _localctx = new SecAttrBlobContext(Context, State);
		EnterRule(_localctx, 178, RULE_secAttrBlob);
		try {
			State = 1489;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,68,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1476;
				Match(T__37);
				State = 1477;
				Match(SQSTRING);
				State = 1478;
				Match(T__34);
				State = 1479;
				Match(T__15);
				State = 1480;
				customBlobNVPairs();
				State = 1481;
				Match(T__16);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1483;
				typeSpec();
				State = 1484;
				Match(T__34);
				State = 1485;
				Match(T__15);
				State = 1486;
				customBlobNVPairs();
				State = 1487;
				Match(T__16);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NameValPairsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public NameValPairContext[] nameValPair() {
			return GetRuleContexts<NameValPairContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public NameValPairContext nameValPair(int i) {
			return GetRuleContext<NameValPairContext>(i);
		}
		public NameValPairsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nameValPairs; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNameValPairs(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NameValPairsContext nameValPairs() {
		NameValPairsContext _localctx = new NameValPairsContext(Context, State);
		EnterRule(_localctx, 180, RULE_nameValPairs);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1496;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,69,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1491;
					nameValPair();
					State = 1492;
					Match(T__26);
					}
					} 
				}
				State = 1498;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,69,Context);
			}
			State = 1499;
			nameValPair();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NameValPairContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CaValueContext caValue() {
			return GetRuleContext<CaValueContext>(0);
		}
		public NameValPairContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_nameValPair; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNameValPair(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NameValPairContext nameValPair() {
		NameValPairContext _localctx = new NameValPairContext(Context, State);
		EnterRule(_localctx, 182, RULE_nameValPair);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1501;
			compQstring();
			State = 1502;
			Match(T__34);
			State = 1503;
			caValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TruefalseContext : ParserRuleContext {
		public TruefalseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_truefalse; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTruefalse(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TruefalseContext truefalse() {
		TruefalseContext _localctx = new TruefalseContext(Context, State);
		EnterRule(_localctx, 184, RULE_truefalse);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1505;
			_la = TokenStream.LA(1);
			if ( !(_la==T__93 || _la==T__94) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CaValueContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TruefalseContext truefalse() {
			return GetRuleContext<TruefalseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		public CaValueContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_caValue; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCaValue(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CaValueContext caValue() {
		CaValueContext _localctx = new CaValueContext(Context, State);
		EnterRule(_localctx, 186, RULE_caValue);
		try {
			State = 1541;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,70,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1507;
				truefalse();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1508;
				int32();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1509;
				Match(INT32_);
				State = 1510;
				Match(T__28);
				State = 1511;
				int32();
				State = 1512;
				Match(T__29);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1514;
				compQstring();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1515;
				className();
				State = 1516;
				Match(T__28);
				State = 1517;
				Match(INT8);
				State = 1518;
				Match(T__73);
				State = 1519;
				int32();
				State = 1520;
				Match(T__29);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1522;
				className();
				State = 1523;
				Match(T__28);
				State = 1524;
				Match(INT16);
				State = 1525;
				Match(T__73);
				State = 1526;
				int32();
				State = 1527;
				Match(T__29);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1529;
				className();
				State = 1530;
				Match(T__28);
				State = 1531;
				Match(INT32_);
				State = 1532;
				Match(T__73);
				State = 1533;
				int32();
				State = 1534;
				Match(T__29);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1536;
				className();
				State = 1537;
				Match(T__28);
				State = 1538;
				int32();
				State = 1539;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SecActionContext : ParserRuleContext {
		public SecActionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_secAction; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSecAction(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SecActionContext secAction() {
		SecActionContext _localctx = new SecActionContext(Context, State);
		EnterRule(_localctx, 188, RULE_secAction);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1543;
			_la = TokenStream.LA(1);
			if ( !(((((_la - 96)) & ~0x3f) == 0 && ((1L << (_la - 96)) & 32767L) != 0)) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MethodRefContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public MethodNameContext methodName() {
			return GetRuleContext<MethodNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() {
			return GetRuleContext<SigArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeArgsContext typeArgs() {
			return GetRuleContext<TypeArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public GenArityNotEmptyContext genArityNotEmpty() {
			return GetRuleContext<GenArityNotEmptyContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() {
			return GetRuleContext<MdtokenContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public MethodRefContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_methodRef; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMethodRef(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MethodRefContext methodRef() {
		MethodRefContext _localctx = new MethodRefContext(Context, State);
		EnterRule(_localctx, 190, RULE_methodRef);
		int _la;
		try {
			State = 1579;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,73,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1545;
				callConv();
				State = 1546;
				type();
				State = 1547;
				typeSpec();
				State = 1548;
				Match(DCOLON);
				State = 1549;
				methodName();
				State = 1551;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==T__84) {
					{
					State = 1550;
					typeArgs();
					}
				}

				State = 1553;
				sigArgs();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1555;
				callConv();
				State = 1556;
				type();
				State = 1557;
				typeSpec();
				State = 1558;
				Match(DCOLON);
				State = 1559;
				methodName();
				State = 1560;
				genArityNotEmpty();
				State = 1561;
				sigArgs();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1563;
				callConv();
				State = 1564;
				type();
				State = 1565;
				methodName();
				State = 1567;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==T__84) {
					{
					State = 1566;
					typeArgs();
					}
				}

				State = 1569;
				sigArgs();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1571;
				callConv();
				State = 1572;
				type();
				State = 1573;
				methodName();
				State = 1574;
				genArityNotEmpty();
				State = 1575;
				sigArgs();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1577;
				mdtoken();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1578;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CallConvContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INSTANCE() { return GetToken(CILParser.INSTANCE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPLICIT() { return GetToken(CILParser.EXPLICIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CallKindContext callKind() {
			return GetRuleContext<CallKindContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public CallConvContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_callConv; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCallConv(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CallConvContext callConv() {
		CallConvContext _localctx = new CallConvContext(Context, State);
		EnterRule(_localctx, 192, RULE_callConv);
		try {
			State = 1591;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,74,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1581;
				Match(INSTANCE);
				State = 1582;
				callConv();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1583;
				Match(EXPLICIT);
				State = 1584;
				callConv();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1585;
				callKind();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1586;
				Match(T__110);
				State = 1587;
				Match(T__28);
				State = 1588;
				int32();
				State = 1589;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CallKindContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEFAULT() { return GetToken(CILParser.DEFAULT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VARARG() { return GetToken(CILParser.VARARG, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNMANAGED() { return GetToken(CILParser.UNMANAGED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CDECL() { return GetToken(CILParser.CDECL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STDCALL() { return GetToken(CILParser.STDCALL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode THISCALL() { return GetToken(CILParser.THISCALL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FASTCALL() { return GetToken(CILParser.FASTCALL, 0); }
		public CallKindContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_callKind; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCallKind(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CallKindContext callKind() {
		CallKindContext _localctx = new CallKindContext(Context, State);
		EnterRule(_localctx, 194, RULE_callKind);
		try {
			State = 1605;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,75,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1594;
				Match(DEFAULT);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1595;
				Match(VARARG);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1596;
				Match(UNMANAGED);
				State = 1597;
				Match(CDECL);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1598;
				Match(UNMANAGED);
				State = 1599;
				Match(STDCALL);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1600;
				Match(UNMANAGED);
				State = 1601;
				Match(THISCALL);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1602;
				Match(UNMANAGED);
				State = 1603;
				Match(FASTCALL);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1604;
				Match(UNMANAGED);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MdtokenContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public MdtokenContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_mdtoken; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMdtoken(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MdtokenContext mdtoken() {
		MdtokenContext _localctx = new MdtokenContext(Context, State);
		EnterRule(_localctx, 196, RULE_mdtoken);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1607;
			Match(T__111);
			State = 1608;
			Match(T__28);
			State = 1609;
			int32();
			State = 1610;
			Match(T__29);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MemberRefContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD() { return GetToken(CILParser.METHOD, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() {
			return GetRuleContext<MethodRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldRefContext fieldRef() {
			return GetRuleContext<FieldRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() {
			return GetRuleContext<MdtokenContext>(0);
		}
		public MemberRefContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_memberRef; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMemberRef(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MemberRefContext memberRef() {
		MemberRefContext _localctx = new MemberRefContext(Context, State);
		EnterRule(_localctx, 198, RULE_memberRef);
		try {
			State = 1617;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case METHOD:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1612;
				Match(METHOD);
				State = 1613;
				methodRef();
				}
				break;
			case T__35:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1614;
				Match(T__35);
				State = 1615;
				fieldRef();
				}
				break;
			case T__111:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1616;
				mdtoken();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldRefContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public FieldRefContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldRef; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFieldRef(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FieldRefContext fieldRef() {
		FieldRefContext _localctx = new FieldRefContext(Context, State);
		EnterRule(_localctx, 200, RULE_fieldRef);
		try {
			State = 1628;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,77,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1619;
				type();
				State = 1620;
				typeSpec();
				State = 1621;
				Match(DCOLON);
				State = 1622;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1624;
				type();
				State = 1625;
				dottedName();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1627;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TypeListContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() {
			return GetRuleContexts<TypeSpecContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec(int i) {
			return GetRuleContext<TypeSpecContext>(i);
		}
		public TypeListContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typeList; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypeList(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TypeListContext typeList() {
		TypeListContext _localctx = new TypeListContext(Context, State);
		EnterRule(_localctx, 202, RULE_typeList);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1635;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,78,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1630;
					typeSpec();
					State = 1631;
					Match(T__26);
					}
					} 
				}
				State = 1637;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,78,Context);
			}
			State = 1638;
			typeSpec();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TyparsClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TyparsContext typars() {
			return GetRuleContext<TyparsContext>(0);
		}
		public TyparsClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typarsClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTyparsClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TyparsClauseContext typarsClause() {
		TyparsClauseContext _localctx = new TyparsClauseContext(Context, State);
		EnterRule(_localctx, 204, RULE_typarsClause);
		try {
			State = 1645;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__15:
			case T__28:
			case T__69:
			case T__70:
			case T__83:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__84:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1641;
				Match(T__84);
				State = 1642;
				typars();
				State = 1643;
				Match(T__85);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TyparAttribContext : ParserRuleContext {
		public IToken covariant;
		public IToken contravariant;
		public IToken @class;
		public IToken valuetype;
		public IToken byrefLike;
		public IToken ctor;
		public Int32Context flags;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PLUS() { return GetToken(CILParser.PLUS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VALUETYPE() { return GetToken(CILParser.VALUETYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public TyparAttribContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typarAttrib; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTyparAttrib(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TyparAttribContext typarAttrib() {
		TyparAttribContext _localctx = new TyparAttribContext(Context, State);
		EnterRule(_localctx, 206, RULE_typarAttrib);
		try {
			State = 1658;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case PLUS:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1647;
				_localctx.covariant = Match(PLUS);
				}
				break;
			case T__112:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1648;
				_localctx.contravariant = Match(T__112);
				}
				break;
			case T__37:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1649;
				_localctx.@class = Match(T__37);
				}
				break;
			case VALUETYPE:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1650;
				_localctx.valuetype = Match(VALUETYPE);
				}
				break;
			case T__113:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1651;
				_localctx.byrefLike = Match(T__113);
				}
				break;
			case T__114:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1652;
				_localctx.ctor = Match(T__114);
				}
				break;
			case T__68:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1653;
				Match(T__68);
				State = 1654;
				Match(T__28);
				State = 1655;
				_localctx.flags = int32();
				State = 1656;
				Match(T__29);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TyparAttribsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TyparAttribContext[] typarAttrib() {
			return GetRuleContexts<TyparAttribContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TyparAttribContext typarAttrib(int i) {
			return GetRuleContext<TyparAttribContext>(i);
		}
		public TyparAttribsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typarAttribs; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTyparAttribs(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TyparAttribsContext typarAttribs() {
		TyparAttribsContext _localctx = new TyparAttribsContext(Context, State);
		EnterRule(_localctx, 208, RULE_typarAttribs);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1663;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__37 || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 123145302310913L) != 0) || _la==VALUETYPE || _la==PLUS) {
				{
				{
				State = 1660;
				typarAttrib();
				}
				}
				State = 1665;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TyparContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TyparAttribsContext typarAttribs() {
			return GetRuleContext<TyparAttribsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TyBoundContext tyBound() {
			return GetRuleContext<TyBoundContext>(0);
		}
		public TyparContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typar; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypar(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TyparContext typar() {
		TyparContext _localctx = new TyparContext(Context, State);
		EnterRule(_localctx, 210, RULE_typar);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1666;
			typarAttribs();
			State = 1668;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==T__28) {
				{
				State = 1667;
				tyBound();
				}
			}

			State = 1670;
			dottedName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TyparsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TyparContext[] typar() {
			return GetRuleContexts<TyparContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TyparContext typar(int i) {
			return GetRuleContext<TyparContext>(i);
		}
		public TyparsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_typars; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTypars(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TyparsContext typars() {
		TyparsContext _localctx = new TyparsContext(Context, State);
		EnterRule(_localctx, 212, RULE_typars);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 1677;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,83,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 1672;
					typar();
					State = 1673;
					Match(T__26);
					}
					} 
				}
				State = 1679;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,83,Context);
			}
			State = 1680;
			typar();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TyBoundContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeListContext typeList() {
			return GetRuleContext<TypeListContext>(0);
		}
		public TyBoundContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_tyBound; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTyBound(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TyBoundContext tyBound() {
		TyBoundContext _localctx = new TyBoundContext(Context, State);
		EnterRule(_localctx, 214, RULE_tyBound);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1682;
			Match(T__28);
			State = 1683;
			typeList();
			State = 1684;
			Match(T__29);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class GenArityContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public GenArityNotEmptyContext genArityNotEmpty() {
			return GetRuleContext<GenArityNotEmptyContext>(0);
		}
		public GenArityContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_genArity; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitGenArity(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public GenArityContext genArity() {
		GenArityContext _localctx = new GenArityContext(Context, State);
		EnterRule(_localctx, 216, RULE_genArity);
		try {
			State = 1688;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__28:
			case T__83:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__84:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1687;
				genArityNotEmpty();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class GenArityNotEmptyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public GenArityNotEmptyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_genArityNotEmpty; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitGenArityNotEmpty(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public GenArityNotEmptyContext genArityNotEmpty() {
		GenArityNotEmptyContext _localctx = new GenArityNotEmptyContext(Context, State);
		EnterRule(_localctx, 218, RULE_genArityNotEmpty);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1690;
			Match(T__84);
			State = 1691;
			Match(T__40);
			State = 1692;
			int32();
			State = 1693;
			Match(T__41);
			State = 1694;
			Match(T__85);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MethodHeadContext methodHead() {
			return GetRuleContext<MethodHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodDeclsContext methodDecls() {
			return GetRuleContext<MethodDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassHeadContext classHead() {
			return GetRuleContext<ClassHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassDeclsContext classDecls() {
			return GetRuleContext<ClassDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventHeadContext eventHead() {
			return GetRuleContext<EventHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclsContext eventDecls() {
			return GetRuleContext<EventDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PropHeadContext propHead() {
			return GetRuleContext<PropHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PropDeclsContext propDecls() {
			return GetRuleContext<PropDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldDeclContext fieldDecl() {
			return GetRuleContext<FieldDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DataDeclContext dataDecl() {
			return GetRuleContext<DataDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() {
			return GetRuleContext<SecDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() {
			return GetRuleContext<ExtSourceSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext[] customAttrDecl() {
			return GetRuleContexts<CustomAttrDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl(int i) {
			return GetRuleContext<CustomAttrDeclContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExportHeadContext exportHead() {
			return GetRuleContext<ExportHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclsContext exptypeDecls() {
			return GetRuleContext<ExptypeDeclsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OVERRIDE() { return GetToken(CILParser.OVERRIDE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext[] typeSpec() {
			return GetRuleContexts<TypeSpecContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec(int i) {
			return GetRuleContext<TypeSpecContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DCOLON() { return GetTokens(CILParser.DCOLON); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON(int i) {
			return GetToken(CILParser.DCOLON, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodNameContext[] methodName() {
			return GetRuleContexts<MethodNameContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodNameContext methodName(int i) {
			return GetRuleContext<MethodNameContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext[] callConv() {
			return GetRuleContexts<CallConvContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv(int i) {
			return GetRuleContext<CallConvContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext[] type() {
			return GetRuleContexts<TypeContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type(int i) {
			return GetRuleContext<TypeContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext[] sigArgs() {
			return GetRuleContexts<SigArgsContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs(int i) {
			return GetRuleContext<SigArgsContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] METHOD() { return GetTokens(CILParser.METHOD); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD(int i) {
			return GetToken(CILParser.METHOD, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public GenArityContext[] genArity() {
			return GetRuleContexts<GenArityContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public GenArityContext genArity(int i) {
			return GetRuleContext<GenArityContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() {
			return GetRuleContext<LanguageDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PARAM() { return GetToken(CILParser.PARAM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONSTRAINT() { return GetToken(CILParser.CONSTRAINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() {
			return GetRuleContext<CustomDescrContext>(0);
		}
		public ClassDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_classDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassDeclContext classDecl() {
		ClassDeclContext _localctx = new ClassDeclContext(Context, State);
		EnterRule(_localctx, 220, RULE_classDecl);
		try {
			int _alt;
			State = 1812;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,89,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1696;
				methodHead();
				State = 1697;
				Match(T__15);
				State = 1698;
				methodDecls();
				State = 1699;
				Match(T__16);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1701;
				classHead();
				State = 1702;
				Match(T__15);
				State = 1703;
				classDecls();
				State = 1704;
				Match(T__16);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1706;
				eventHead();
				State = 1707;
				Match(T__15);
				State = 1708;
				eventDecls();
				State = 1709;
				Match(T__16);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1711;
				propHead();
				State = 1712;
				Match(T__15);
				State = 1713;
				propDecls();
				State = 1714;
				Match(T__16);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1716;
				fieldDecl();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1717;
				dataDecl();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1718;
				secDecl();
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1719;
				extSourceSpec();
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 1720;
				customAttrDecl();
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 1721;
				Match(T__115);
				State = 1722;
				int32();
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 1723;
				Match(T__116);
				State = 1724;
				int32();
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 1725;
				exportHead();
				State = 1726;
				Match(T__15);
				State = 1727;
				exptypeDecls();
				State = 1728;
				Match(T__16);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 1730;
				Match(OVERRIDE);
				State = 1731;
				typeSpec();
				State = 1732;
				Match(DCOLON);
				State = 1733;
				methodName();
				State = 1734;
				Match(T__117);
				State = 1735;
				callConv();
				State = 1736;
				type();
				State = 1737;
				typeSpec();
				State = 1738;
				Match(DCOLON);
				State = 1739;
				methodName();
				State = 1740;
				sigArgs();
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 1742;
				Match(OVERRIDE);
				State = 1743;
				Match(METHOD);
				State = 1744;
				callConv();
				State = 1745;
				type();
				State = 1746;
				typeSpec();
				State = 1747;
				Match(DCOLON);
				State = 1748;
				methodName();
				State = 1749;
				genArity();
				State = 1750;
				sigArgs();
				State = 1751;
				Match(T__117);
				State = 1752;
				Match(METHOD);
				State = 1753;
				callConv();
				State = 1754;
				type();
				State = 1755;
				typeSpec();
				State = 1756;
				Match(DCOLON);
				State = 1757;
				methodName();
				State = 1758;
				genArity();
				State = 1759;
				sigArgs();
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 1761;
				languageDecl();
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 1762;
				compControl();
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 1763;
				Match(PARAM);
				State = 1764;
				Match(TYPE);
				State = 1765;
				Match(T__40);
				State = 1766;
				int32();
				State = 1767;
				Match(T__41);
				State = 1771;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,85,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1768;
						customAttrDecl();
						}
						} 
					}
					State = 1773;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,85,Context);
				}
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 1774;
				Match(PARAM);
				State = 1775;
				Match(TYPE);
				State = 1776;
				dottedName();
				State = 1780;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,86,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1777;
						customAttrDecl();
						}
						} 
					}
					State = 1782;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,86,Context);
				}
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 1783;
				Match(PARAM);
				State = 1784;
				Match(CONSTRAINT);
				State = 1785;
				Match(T__40);
				State = 1786;
				int32();
				State = 1787;
				Match(T__41);
				State = 1788;
				Match(T__26);
				State = 1789;
				typeSpec();
				State = 1793;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,87,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1790;
						customAttrDecl();
						}
						} 
					}
					State = 1795;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,87,Context);
				}
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 1796;
				Match(PARAM);
				State = 1797;
				Match(CONSTRAINT);
				State = 1798;
				dottedName();
				State = 1799;
				Match(T__26);
				State = 1800;
				typeSpec();
				State = 1804;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,88,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 1801;
						customAttrDecl();
						}
						} 
					}
					State = 1806;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,88,Context);
				}
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 1807;
				Match(T__118);
				State = 1808;
				Match(TYPE);
				State = 1809;
				typeSpec();
				State = 1810;
				customDescr();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public RepeatOptContext repeatOpt() {
			return GetRuleContext<RepeatOptContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AtOptContext atOpt() {
			return GetRuleContext<AtOptContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InitOptContext initOpt() {
			return GetRuleContext<InitOptContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldAttrContext[] fieldAttr() {
			return GetRuleContexts<FieldAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public FieldAttrContext fieldAttr(int i) {
			return GetRuleContext<FieldAttrContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MarshalBlobContext[] marshalBlob() {
			return GetRuleContexts<MarshalBlobContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MarshalBlobContext marshalBlob(int i) {
			return GetRuleContext<MarshalBlobContext>(i);
		}
		public FieldDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFieldDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FieldDeclContext fieldDecl() {
		FieldDeclContext _localctx = new FieldDeclContext(Context, State);
		EnterRule(_localctx, 222, RULE_fieldDecl);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1814;
			Match(T__119);
			State = 1815;
			repeatOpt();
			State = 1824;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4608308318706860032L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -144115188075855813L) != 0)) {
				{
				State = 1822;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case T__49:
				case T__50:
				case T__61:
				case T__62:
				case T__63:
				case T__64:
				case T__66:
				case T__67:
				case T__68:
				case T__121:
				case T__122:
				case T__123:
				case T__124:
				case T__125:
				case T__126:
					{
					State = 1816;
					fieldAttr();
					}
					break;
				case T__120:
					{
					State = 1817;
					Match(T__120);
					State = 1818;
					Match(T__28);
					State = 1819;
					marshalBlob();
					State = 1820;
					Match(T__29);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 1826;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 1827;
			type();
			State = 1828;
			dottedName();
			State = 1829;
			atOpt();
			State = 1830;
			initOpt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public FieldAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFieldAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FieldAttrContext fieldAttr() {
		FieldAttrContext _localctx = new FieldAttrContext(Context, State);
		EnterRule(_localctx, 224, RULE_fieldAttr);
		try {
			State = 1851;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__121:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1832;
				Match(T__121);
				}
				break;
			case T__49:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1833;
				Match(T__49);
				}
				break;
			case T__50:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1834;
				Match(T__50);
				}
				break;
			case T__61:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1835;
				Match(T__61);
				}
				break;
			case T__122:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1836;
				Match(T__122);
				}
				break;
			case T__67:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1837;
				Match(T__67);
				}
				break;
			case T__66:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1838;
				Match(T__66);
				}
				break;
			case T__62:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1839;
				Match(T__62);
				}
				break;
			case T__63:
				EnterOuterAlt(_localctx, 9);
				{
				State = 1840;
				Match(T__63);
				}
				break;
			case T__64:
				EnterOuterAlt(_localctx, 10);
				{
				State = 1841;
				Match(T__64);
				}
				break;
			case T__123:
				EnterOuterAlt(_localctx, 11);
				{
				State = 1842;
				Match(T__123);
				}
				break;
			case T__124:
				EnterOuterAlt(_localctx, 12);
				{
				State = 1843;
				Match(T__124);
				}
				break;
			case T__125:
				EnterOuterAlt(_localctx, 13);
				{
				State = 1844;
				Match(T__125);
				}
				break;
			case T__126:
				EnterOuterAlt(_localctx, 14);
				{
				State = 1845;
				Match(T__126);
				}
				break;
			case T__68:
				EnterOuterAlt(_localctx, 15);
				{
				State = 1846;
				Match(T__68);
				State = 1847;
				Match(T__28);
				State = 1848;
				int32();
				State = 1849;
				Match(T__29);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AtOptContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public AtOptContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_atOpt; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAtOpt(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AtOptContext atOpt() {
		AtOptContext _localctx = new AtOptContext(Context, State);
		EnterRule(_localctx, 226, RULE_atOpt);
		try {
			State = 1858;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,93,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1854;
				Match(T__42);
				State = 1855;
				id();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1856;
				Match(T__42);
				State = 1857;
				int32();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InitOptContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public FieldInitContext fieldInit() {
			return GetRuleContext<FieldInitContext>(0);
		}
		public InitOptContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_initOpt; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInitOpt(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InitOptContext initOpt() {
		InitOptContext _localctx = new InitOptContext(Context, State);
		EnterRule(_localctx, 228, RULE_initOpt);
		try {
			State = 1863;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
			case T__1:
			case T__2:
			case T__3:
			case T__4:
			case T__5:
			case T__6:
			case T__7:
			case T__8:
			case T__9:
			case T__10:
			case T__11:
			case T__12:
			case T__13:
			case T__14:
			case T__15:
			case T__16:
			case T__17:
			case T__18:
			case T__19:
			case T__21:
			case T__22:
			case T__23:
			case T__24:
			case T__25:
			case T__27:
			case T__30:
			case T__31:
			case T__33:
			case T__39:
			case T__46:
			case T__47:
			case T__48:
			case T__71:
			case T__72:
			case T__115:
			case T__116:
			case T__118:
			case T__119:
			case T__127:
			case T__132:
			case T__138:
			case T__157:
			case T__164:
			case MODULE:
			case VALUE:
			case INSTANCE:
			case UNMANAGED:
			case PARAM:
			case SQSTRING:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
			case MRESOURCE:
			case INSTR_NONE:
			case INSTR_VAR:
			case INSTR_I:
			case INSTR_I8:
			case INSTR_R:
			case INSTR_METHOD:
			case INSTR_SIG:
			case INSTR_BRTARGET:
			case INSTR_SWITCH:
			case INSTR_TYPE:
			case INSTR_STRING:
			case INSTR_FIELD:
			case INSTR_TOK:
			case DOTTEDNAME:
			case ID:
			case PERMISSION:
			case PERMISSIONSET:
			case EMITBYTE:
			case MAXSTACK:
			case ENTRYPOINT:
			case ZEROINIT:
			case LOCALS:
			case EXPORT:
			case OVERRIDE:
			case VTENTRY:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__34:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1861;
				Match(T__34);
				State = 1862;
				fieldInit();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class RepeatOptContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public RepeatOptContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_repeatOpt; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitRepeatOpt(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public RepeatOptContext repeatOpt() {
		RepeatOptContext _localctx = new RepeatOptContext(Context, State);
		EnterRule(_localctx, 230, RULE_repeatOpt);
		try {
			State = 1870;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
			case T__37:
			case T__49:
			case T__50:
			case T__61:
			case T__62:
			case T__63:
			case T__64:
			case T__66:
			case T__67:
			case T__68:
			case T__92:
			case T__120:
			case T__121:
			case T__122:
			case T__123:
			case T__124:
			case T__125:
			case T__126:
			case ELLIPSIS:
			case CHAR:
			case STRING:
			case BOOL:
			case INT8:
			case INT16:
			case INT32_:
			case INT64_:
			case FLOAT32:
			case FLOAT64_:
			case UINT8:
			case UINT16:
			case UINT32:
			case UINT64:
			case OBJECT:
			case VALUE:
			case VALUETYPE:
			case VOID:
			case METHOD:
			case INSTANCE:
			case TYPE_PARAMETER:
			case METHOD_TYPE_PARAMETER:
			case TYPEDREF:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__40:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1866;
				Match(T__40);
				State = 1867;
				int32();
				State = 1868;
				Match(T__41);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EventHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventAttrContext[] eventAttr() {
			return GetRuleContexts<EventAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventAttrContext eventAttr(int i) {
			return GetRuleContext<EventAttrContext>(i);
		}
		public EventHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_eventHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEventHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EventHeadContext eventHead() {
		EventHeadContext _localctx = new EventHeadContext(Context, State);
		EnterRule(_localctx, 232, RULE_eventHead);
		int _la;
		try {
			State = 1890;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,98,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1872;
				Match(T__127);
				State = 1876;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__66 || _la==T__67) {
					{
					{
					State = 1873;
					eventAttr();
					}
					}
					State = 1878;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 1879;
				typeSpec();
				State = 1880;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1882;
				Match(T__127);
				State = 1886;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__66 || _la==T__67) {
					{
					{
					State = 1883;
					eventAttr();
					}
					}
					State = 1888;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 1889;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EventAttrContext : ParserRuleContext {
		public EventAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_eventAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEventAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EventAttrContext eventAttr() {
		EventAttrContext _localctx = new EventAttrContext(Context, State);
		EnterRule(_localctx, 234, RULE_eventAttr);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1892;
			_la = TokenStream.LA(1);
			if ( !(_la==T__66 || _la==T__67) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EventDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclContext[] eventDecl() {
			return GetRuleContexts<EventDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclContext eventDecl(int i) {
			return GetRuleContext<EventDeclContext>(i);
		}
		public EventDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_eventDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEventDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EventDeclsContext eventDecls() {
		EventDeclsContext _localctx = new EventDeclsContext(Context, State);
		EnterRule(_localctx, 236, RULE_eventDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1897;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 19394461696L) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & 2161727821137838083L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 263)) & ~0x3f) == 0 && ((1L << (_la - 263)) & 50332665L) != 0)) {
				{
				{
				State = 1894;
				eventDecl();
				}
				}
				State = 1899;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EventDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() {
			return GetRuleContext<MethodRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() {
			return GetRuleContext<ExtSourceSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl() {
			return GetRuleContext<CustomAttrDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() {
			return GetRuleContext<LanguageDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		public EventDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_eventDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEventDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EventDeclContext eventDecl() {
		EventDeclContext _localctx = new EventDeclContext(Context, State);
		EnterRule(_localctx, 238, RULE_eventDecl);
		try {
			State = 1912;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__128:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1900;
				Match(T__128);
				State = 1901;
				methodRef();
				}
				break;
			case T__129:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1902;
				Match(T__129);
				State = 1903;
				methodRef();
				}
				break;
			case T__130:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1904;
				Match(T__130);
				State = 1905;
				methodRef();
				}
				break;
			case T__131:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1906;
				Match(T__131);
				State = 1907;
				methodRef();
				}
				break;
			case T__71:
			case T__72:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1908;
				extSourceSpec();
				}
				break;
			case T__33:
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1909;
				customAttrDecl();
				}
				break;
			case T__25:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1910;
				languageDecl();
				}
				break;
			case T__30:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
				EnterOuterAlt(_localctx, 8);
				{
				State = 1911;
				compControl();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PropHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() {
			return GetRuleContext<SigArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InitOptContext initOpt() {
			return GetRuleContext<InitOptContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PropAttrContext[] propAttr() {
			return GetRuleContexts<PropAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public PropAttrContext propAttr(int i) {
			return GetRuleContext<PropAttrContext>(i);
		}
		public PropHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_propHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPropHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PropHeadContext propHead() {
		PropHeadContext _localctx = new PropHeadContext(Context, State);
		EnterRule(_localctx, 240, RULE_propHead);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1914;
			Match(T__132);
			State = 1918;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__66 || _la==T__67) {
				{
				{
				State = 1915;
				propAttr();
				}
				}
				State = 1920;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 1921;
			callConv();
			State = 1922;
			type();
			State = 1923;
			dottedName();
			State = 1924;
			sigArgs();
			State = 1925;
			initOpt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PropAttrContext : ParserRuleContext {
		public PropAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_propAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPropAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PropAttrContext propAttr() {
		PropAttrContext _localctx = new PropAttrContext(Context, State);
		EnterRule(_localctx, 242, RULE_propAttr);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1927;
			_la = TokenStream.LA(1);
			if ( !(_la==T__66 || _la==T__67) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PropDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public PropDeclContext[] propDecl() {
			return GetRuleContexts<PropDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public PropDeclContext propDecl(int i) {
			return GetRuleContext<PropDeclContext>(i);
		}
		public PropDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_propDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPropDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PropDeclsContext propDecls() {
		PropDeclsContext _localctx = new PropDeclsContext(Context, State);
		EnterRule(_localctx, 244, RULE_propDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1932;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 19394461696L) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & -3458764513820540925L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 263)) & ~0x3f) == 0 && ((1L << (_la - 263)) & 50332665L) != 0)) {
				{
				{
				State = 1929;
				propDecl();
				}
				}
				State = 1934;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PropDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MethodRefContext methodRef() {
			return GetRuleContext<MethodRefContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl() {
			return GetRuleContext<CustomAttrDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() {
			return GetRuleContext<ExtSourceSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() {
			return GetRuleContext<LanguageDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		public PropDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_propDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPropDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PropDeclContext propDecl() {
		PropDeclContext _localctx = new PropDeclContext(Context, State);
		EnterRule(_localctx, 246, RULE_propDecl);
		try {
			State = 1945;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__133:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1935;
				Match(T__133);
				State = 1936;
				methodRef();
				}
				break;
			case T__134:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1937;
				Match(T__134);
				State = 1938;
				methodRef();
				}
				break;
			case T__131:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1939;
				Match(T__131);
				State = 1940;
				methodRef();
				}
				break;
			case T__33:
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1941;
				customAttrDecl();
				}
				break;
			case T__71:
			case T__72:
				EnterOuterAlt(_localctx, 5);
				{
				State = 1942;
				extSourceSpec();
				}
				break;
			case T__25:
				EnterOuterAlt(_localctx, 6);
				{
				State = 1943;
				languageDecl();
				}
				break;
			case T__30:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
				EnterOuterAlt(_localctx, 7);
				{
				State = 1944;
				compControl();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MarshalClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MarshalBlobContext marshalBlob() {
			return GetRuleContext<MarshalBlobContext>(0);
		}
		public MarshalClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_marshalClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMarshalClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MarshalClauseContext marshalClause() {
		MarshalClauseContext _localctx = new MarshalClauseContext(Context, State);
		EnterRule(_localctx, 248, RULE_marshalClause);
		try {
			State = 1953;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
			case T__1:
			case T__2:
			case T__3:
			case T__4:
			case T__5:
			case T__6:
			case T__7:
			case T__8:
			case T__9:
			case T__10:
			case T__11:
			case T__12:
			case T__13:
			case T__14:
			case T__26:
			case T__29:
			case T__114:
			case T__154:
			case VALUE:
			case INSTANCE:
			case UNMANAGED:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__120:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1948;
				Match(T__120);
				State = 1949;
				Match(T__28);
				State = 1950;
				marshalBlob();
				State = 1951;
				Match(T__29);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MarshalBlobContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public NativeTypeContext nativeType() {
			return GetRuleContext<NativeTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public HexbyteContext[] hexbyte() {
			return GetRuleContexts<HexbyteContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public HexbyteContext hexbyte(int i) {
			return GetRuleContext<HexbyteContext>(i);
		}
		public MarshalBlobContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_marshalBlob; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMarshalBlob(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MarshalBlobContext marshalBlob() {
		MarshalBlobContext _localctx = new MarshalBlobContext(Context, State);
		EnterRule(_localctx, 250, RULE_marshalBlob);
		int _la;
		try {
			State = 1964;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__29:
			case T__32:
			case T__40:
			case T__60:
			case BOOL:
			case INT8:
			case INT16:
			case INT32_:
			case INT64_:
			case FLOAT32:
			case FLOAT64_:
			case UINT8:
			case UINT16:
			case UINT32:
			case UINT64:
			case INT:
			case UINT:
			case VALUE:
			case VOID:
			case CUSTOM:
			case FIXED:
			case VARIANT:
			case CURRENCY:
			case SYSCHAR:
			case ERROR:
			case DECIMAL:
			case DATE:
			case BSTR:
			case LPSTR:
			case LPWSTR:
			case LPTSTR:
			case OBJECTREF:
			case IUNKNOWN:
			case IDISPATCH:
			case STRUCT:
			case INTERFACE:
			case SAFEARRAY:
			case BYVALSTR:
			case ANSI:
			case TBSTR:
			case METHOD:
			case LPSTRUCT:
			case INSTANCE:
			case ARRAY_TYPE_NO_BOUNDS:
			case PTR:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1955;
				nativeType();
				}
				break;
			case T__15:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1956;
				Match(T__15);
				State = 1958;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				do {
					{
					{
					State = 1957;
					hexbyte();
					}
					}
					State = 1960;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				} while ( _la==INT32 || _la==ID || _la==HEXBYTE );
				State = 1962;
				Match(T__16);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ParamAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ParamAttrElementContext[] paramAttrElement() {
			return GetRuleContexts<ParamAttrElementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ParamAttrElementContext paramAttrElement(int i) {
			return GetRuleContext<ParamAttrElementContext>(i);
		}
		public ParamAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_paramAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParamAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ParamAttrContext paramAttr() {
		ParamAttrContext _localctx = new ParamAttrContext(Context, State);
		EnterRule(_localctx, 252, RULE_paramAttr);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1969;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__40) {
				{
				{
				State = 1966;
				paramAttrElement();
				}
				}
				State = 1971;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ParamAttrElementContext : ParserRuleContext {
		public IToken @in;
		public IToken @out;
		public IToken opt;
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public ParamAttrElementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_paramAttrElement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParamAttrElement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ParamAttrElementContext paramAttrElement() {
		ParamAttrElementContext _localctx = new ParamAttrElementContext(Context, State);
		EnterRule(_localctx, 254, RULE_paramAttrElement);
		try {
			State = 1985;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,108,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 1972;
				Match(T__40);
				State = 1973;
				_localctx.@in = Match(T__135);
				State = 1974;
				Match(T__41);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 1975;
				Match(T__40);
				State = 1976;
				_localctx.@out = Match(T__136);
				State = 1977;
				Match(T__41);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 1978;
				Match(T__40);
				State = 1979;
				_localctx.opt = Match(T__137);
				State = 1980;
				Match(T__41);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 1981;
				Match(T__40);
				State = 1982;
				int32();
				State = 1983;
				Match(T__41);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MethodHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ParamAttrContext paramAttr() {
			return GetRuleContext<ParamAttrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MarshalClauseContext marshalClause() {
			return GetRuleContext<MarshalClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodNameContext methodName() {
			return GetRuleContext<MethodNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TyparsClauseContext typarsClause() {
			return GetRuleContext<TyparsClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() {
			return GetRuleContext<SigArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethAttrContext[] methAttr() {
			return GetRuleContexts<MethAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethAttrContext methAttr(int i) {
			return GetRuleContext<MethAttrContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PinvImplContext[] pinvImpl() {
			return GetRuleContexts<PinvImplContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public PinvImplContext pinvImpl(int i) {
			return GetRuleContext<PinvImplContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ImplAttrContext[] implAttr() {
			return GetRuleContexts<ImplAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ImplAttrContext implAttr(int i) {
			return GetRuleContext<ImplAttrContext>(i);
		}
		public MethodHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_methodHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMethodHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MethodHeadContext methodHead() {
		MethodHeadContext _localctx = new MethodHeadContext(Context, State);
		EnterRule(_localctx, 256, RULE_methodHead);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 1987;
			Match(T__138);
			State = 1992;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 50)) & ~0x3f) == 0 && ((1L << (_la - 50)) & 978955L) != 0) || ((((_la - 122)) & ~0x3f) == 0 && ((1L << (_la - 122)) & 66846725L) != 0)) {
				{
				State = 1990;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case T__49:
				case T__50:
				case T__52:
				case T__61:
				case T__62:
				case T__63:
				case T__64:
				case T__66:
				case T__67:
				case T__68:
				case T__121:
				case T__123:
				case T__139:
				case T__140:
				case T__141:
				case T__142:
				case T__143:
				case T__144:
				case T__145:
					{
					State = 1988;
					methAttr();
					}
					break;
				case T__146:
					{
					State = 1989;
					pinvImpl();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 1994;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 1995;
			callConv();
			State = 1996;
			paramAttr();
			State = 1997;
			type();
			State = 1998;
			marshalClause();
			State = 1999;
			methodName();
			State = 2000;
			typarsClause();
			State = 2001;
			sigArgs();
			State = 2005;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0) || _la==T__68 || _la==T__155 || _la==UNMANAGED) {
				{
				{
				State = 2002;
				implAttr();
				}
				}
				State = 2007;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MethAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public MethAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_methAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMethAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MethAttrContext methAttr() {
		MethAttrContext _localctx = new MethAttrContext(Context, State);
		EnterRule(_localctx, 258, RULE_methAttr);
		try {
			State = 2031;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__121:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2008;
				Match(T__121);
				}
				break;
			case T__49:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2009;
				Match(T__49);
				}
				break;
			case T__50:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2010;
				Match(T__50);
				}
				break;
			case T__61:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2011;
				Match(T__61);
				}
				break;
			case T__139:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2012;
				Match(T__139);
				}
				break;
			case T__66:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2013;
				Match(T__66);
				}
				break;
			case T__140:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2014;
				Match(T__140);
				}
				break;
			case T__141:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2015;
				Match(T__141);
				}
				break;
			case T__52:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2016;
				Match(T__52);
				}
				break;
			case T__62:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2017;
				Match(T__62);
				}
				break;
			case T__63:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2018;
				Match(T__63);
				}
				break;
			case T__64:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2019;
				Match(T__64);
				}
				break;
			case T__123:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2020;
				Match(T__123);
				}
				break;
			case T__142:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2021;
				Match(T__142);
				}
				break;
			case T__143:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2022;
				Match(T__143);
				}
				break;
			case T__67:
				EnterOuterAlt(_localctx, 16);
				{
				State = 2023;
				Match(T__67);
				}
				break;
			case T__144:
				EnterOuterAlt(_localctx, 17);
				{
				State = 2024;
				Match(T__144);
				}
				break;
			case T__145:
				EnterOuterAlt(_localctx, 18);
				{
				State = 2025;
				Match(T__145);
				}
				break;
			case T__68:
				EnterOuterAlt(_localctx, 19);
				{
				State = 2026;
				Match(T__68);
				State = 2027;
				Match(T__28);
				State = 2028;
				int32();
				State = 2029;
				Match(T__29);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PinvImplContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext[] compQstring() {
			return GetRuleContexts<CompQstringContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring(int i) {
			return GetRuleContext<CompQstringContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PinvAttrContext[] pinvAttr() {
			return GetRuleContexts<PinvAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public PinvAttrContext pinvAttr(int i) {
			return GetRuleContext<PinvAttrContext>(i);
		}
		public PinvImplContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_pinvImpl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPinvImpl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PinvImplContext pinvImpl() {
		PinvImplContext _localctx = new PinvImplContext(Context, State);
		EnterRule(_localctx, 260, RULE_pinvImpl);
		int _la;
		try {
			State = 2051;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,116,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2033;
				Match(T__146);
				State = 2034;
				Match(T__28);
				State = 2040;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==QSTRING) {
					{
					State = 2035;
					compQstring();
					State = 2038;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==T__32) {
						{
						State = 2036;
						Match(T__32);
						State = 2037;
						compQstring();
						}
					}

					}
				}

				State = 2045;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & 8195L) != 0) || ((((_la - 148)) & ~0x3f) == 0 && ((1L << (_la - 148)) & 79L) != 0) || ((((_la - 223)) & ~0x3f) == 0 && ((1L << (_la - 223)) & 251658241L) != 0)) {
					{
					{
					State = 2042;
					pinvAttr();
					}
					}
					State = 2047;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 2048;
				Match(T__29);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2049;
				Match(T__146);
				State = 2050;
				Match(T__83);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PinvAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ANSI() { return GetToken(CILParser.ANSI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CDECL() { return GetToken(CILParser.CDECL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STDCALL() { return GetToken(CILParser.STDCALL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode THISCALL() { return GetToken(CILParser.THISCALL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FASTCALL() { return GetToken(CILParser.FASTCALL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public PinvAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_pinvAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPinvAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PinvAttrContext pinvAttr() {
		PinvAttrContext _localctx = new PinvAttrContext(Context, State);
		EnterRule(_localctx, 262, RULE_pinvAttr);
		try {
			State = 2080;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,117,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2053;
				Match(T__147);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2054;
				Match(ANSI);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2055;
				Match(T__55);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2056;
				Match(T__56);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2057;
				Match(T__148);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2058;
				Match(T__149);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2059;
				Match(CDECL);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2060;
				Match(STDCALL);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2061;
				Match(THISCALL);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2062;
				Match(FASTCALL);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2063;
				Match(T__150);
				State = 2064;
				Match(T__73);
				State = 2065;
				Match(T__151);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2066;
				Match(T__150);
				State = 2067;
				Match(T__73);
				State = 2068;
				Match(T__152);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2069;
				Match(T__153);
				State = 2070;
				Match(T__73);
				State = 2071;
				Match(T__151);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2072;
				Match(T__153);
				State = 2073;
				Match(T__73);
				State = 2074;
				Match(T__152);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2075;
				Match(T__68);
				State = 2076;
				Match(T__28);
				State = 2077;
				int32();
				State = 2078;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MethodNameContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public MethodNameContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_methodName; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMethodName(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MethodNameContext methodName() {
		MethodNameContext _localctx = new MethodNameContext(Context, State);
		EnterRule(_localctx, 264, RULE_methodName);
		try {
			State = 2085;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__114:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2082;
				Match(T__114);
				}
				break;
			case T__154:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2083;
				Match(T__154);
				}
				break;
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2084;
				dottedName();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ImplAttrContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNMANAGED() { return GetToken(CILParser.UNMANAGED, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public ImplAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_implAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitImplAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ImplAttrContext implAttr() {
		ImplAttrContext _localctx = new ImplAttrContext(Context, State);
		EnterRule(_localctx, 266, RULE_implAttr);
		try {
			State = 2108;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2087;
				Match(T__0);
				}
				break;
			case T__1:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2088;
				Match(T__1);
				}
				break;
			case T__155:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2089;
				Match(T__155);
				}
				break;
			case T__2:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2090;
				Match(T__2);
				}
				break;
			case T__3:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2091;
				Match(T__3);
				}
				break;
			case UNMANAGED:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2092;
				Match(UNMANAGED);
				}
				break;
			case T__4:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2093;
				Match(T__4);
				}
				break;
			case T__5:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2094;
				Match(T__5);
				}
				break;
			case T__6:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2095;
				Match(T__6);
				}
				break;
			case T__7:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2096;
				Match(T__7);
				}
				break;
			case T__8:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2097;
				Match(T__8);
				}
				break;
			case T__9:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2098;
				Match(T__9);
				}
				break;
			case T__10:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2099;
				Match(T__10);
				}
				break;
			case T__11:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2100;
				Match(T__11);
				}
				break;
			case T__12:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2101;
				Match(T__12);
				}
				break;
			case T__13:
				EnterOuterAlt(_localctx, 16);
				{
				State = 2102;
				Match(T__13);
				}
				break;
			case T__68:
				EnterOuterAlt(_localctx, 17);
				{
				State = 2103;
				Match(T__68);
				State = 2104;
				Match(T__28);
				State = 2105;
				int32();
				State = 2106;
				Match(T__29);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MethodDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MethodDeclContext[] methodDecl() {
			return GetRuleContexts<MethodDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MethodDeclContext methodDecl(int i) {
			return GetRuleContext<MethodDeclContext>(i);
		}
		public MethodDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_methodDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMethodDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MethodDeclsContext methodDecls() {
		MethodDeclsContext _localctx = new MethodDeclsContext(Context, State);
		EnterRule(_localctx, 268, RULE_methodDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2113;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 19394592766L) != 0) || _la==T__71 || _la==T__72 || ((((_la - 158)) & ~0x3f) == 0 && ((1L << (_la - 158)) & 1099511627905L) != 0) || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & 2303696760354115601L) != 0)) {
				{
				{
				State = 2110;
				methodDecl();
				}
				}
				State = 2115;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MethodDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public InstrContext instr() {
			return GetRuleContext<InstrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EMITBYTE() { return GetToken(CILParser.EMITBYTE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SehBlockContext sehBlock() {
			return GetRuleContext<SehBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MAXSTACK() { return GetToken(CILParser.MAXSTACK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LOCALS() { return GetToken(CILParser.LOCALS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public SigArgsContext sigArgs() {
			return GetRuleContext<SigArgsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENTRYPOINT() { return GetToken(CILParser.ENTRYPOINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ZEROINIT() { return GetToken(CILParser.ZEROINIT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DataDeclContext dataDecl() {
			return GetRuleContext<DataDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LabelDeclContext labelDecl() {
			return GetRuleContext<LabelDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SecDeclContext secDecl() {
			return GetRuleContext<SecDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExtSourceSpecContext extSourceSpec() {
			return GetRuleContext<ExtSourceSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public LanguageDeclContext languageDecl() {
			return GetRuleContext<LanguageDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrInMethodBodyContext customDescrInMethodBody() {
			return GetRuleContext<CustomDescrInMethodBodyContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPORT() { return GetToken(CILParser.EXPORT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode VTENTRY() { return GetToken(CILParser.VTENTRY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OVERRIDE() { return GetToken(CILParser.OVERRIDE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DCOLON() { return GetToken(CILParser.DCOLON, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public MethodNameContext methodName() {
			return GetRuleContext<MethodNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode METHOD() { return GetToken(CILParser.METHOD, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CallConvContext callConv() {
			return GetRuleContext<CallConvContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TypeContext type() {
			return GetRuleContext<TypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public GenArityContext genArity() {
			return GetRuleContext<GenArityContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() {
			return GetRuleContext<ScopeBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PARAM() { return GetToken(CILParser.PARAM, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext[] customAttrDecl() {
			return GetRuleContexts<CustomAttrDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl(int i) {
			return GetRuleContext<CustomAttrDeclContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONSTRAINT() { return GetToken(CILParser.CONSTRAINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public InitOptContext initOpt() {
			return GetRuleContext<InitOptContext>(0);
		}
		public MethodDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_methodDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMethodDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MethodDeclContext methodDecl() {
		MethodDeclContext _localctx = new MethodDeclContext(Context, State);
		EnterRule(_localctx, 270, RULE_methodDecl);
		try {
			int _alt;
			State = 2224;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,126,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2116;
				instr();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2117;
				Match(EMITBYTE);
				State = 2118;
				int32();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2119;
				sehBlock();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2120;
				Match(MAXSTACK);
				State = 2121;
				int32();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2122;
				Match(LOCALS);
				State = 2123;
				sigArgs();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2124;
				Match(LOCALS);
				State = 2125;
				Match(T__156);
				State = 2126;
				sigArgs();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2127;
				Match(ENTRYPOINT);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2128;
				Match(ZEROINIT);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2129;
				dataDecl();
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2130;
				labelDecl();
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2131;
				secDecl();
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2132;
				extSourceSpec();
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2133;
				languageDecl();
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2134;
				customDescrInMethodBody();
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2135;
				compControl();
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 2136;
				Match(EXPORT);
				State = 2137;
				Match(T__40);
				State = 2138;
				int32();
				State = 2139;
				Match(T__41);
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 2141;
				Match(EXPORT);
				State = 2142;
				Match(T__40);
				State = 2143;
				int32();
				State = 2144;
				Match(T__41);
				State = 2145;
				Match(T__32);
				State = 2146;
				id();
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 2148;
				Match(VTENTRY);
				State = 2149;
				int32();
				State = 2150;
				Match(T__73);
				State = 2151;
				int32();
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 2153;
				Match(OVERRIDE);
				State = 2154;
				typeSpec();
				State = 2155;
				Match(DCOLON);
				State = 2156;
				methodName();
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 2158;
				Match(OVERRIDE);
				State = 2159;
				Match(METHOD);
				State = 2160;
				callConv();
				State = 2161;
				type();
				State = 2162;
				typeSpec();
				State = 2163;
				Match(DCOLON);
				State = 2164;
				methodName();
				State = 2165;
				genArity();
				State = 2166;
				sigArgs();
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 2168;
				scopeBlock();
				}
				break;
			case 22:
				EnterOuterAlt(_localctx, 22);
				{
				State = 2169;
				Match(PARAM);
				State = 2170;
				Match(TYPE);
				State = 2171;
				Match(T__40);
				State = 2172;
				int32();
				State = 2173;
				Match(T__41);
				State = 2177;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,121,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 2174;
						customAttrDecl();
						}
						} 
					}
					State = 2179;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,121,Context);
				}
				}
				break;
			case 23:
				EnterOuterAlt(_localctx, 23);
				{
				State = 2180;
				Match(PARAM);
				State = 2181;
				Match(TYPE);
				State = 2182;
				dottedName();
				State = 2186;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,122,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 2183;
						customAttrDecl();
						}
						} 
					}
					State = 2188;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,122,Context);
				}
				}
				break;
			case 24:
				EnterOuterAlt(_localctx, 24);
				{
				State = 2189;
				Match(PARAM);
				State = 2190;
				Match(CONSTRAINT);
				State = 2191;
				Match(T__40);
				State = 2192;
				int32();
				State = 2193;
				Match(T__41);
				State = 2194;
				Match(T__26);
				State = 2195;
				typeSpec();
				State = 2199;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,123,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 2196;
						customAttrDecl();
						}
						} 
					}
					State = 2201;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,123,Context);
				}
				}
				break;
			case 25:
				EnterOuterAlt(_localctx, 25);
				{
				State = 2202;
				Match(PARAM);
				State = 2203;
				Match(CONSTRAINT);
				State = 2204;
				dottedName();
				State = 2205;
				Match(T__26);
				State = 2206;
				typeSpec();
				State = 2210;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,124,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 2207;
						customAttrDecl();
						}
						} 
					}
					State = 2212;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,124,Context);
				}
				}
				break;
			case 26:
				EnterOuterAlt(_localctx, 26);
				{
				State = 2213;
				Match(PARAM);
				State = 2214;
				Match(T__40);
				State = 2215;
				int32();
				State = 2216;
				Match(T__41);
				State = 2217;
				initOpt();
				State = 2221;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,125,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 2218;
						customAttrDecl();
						}
						} 
					}
					State = 2223;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,125,Context);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class LabelDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		public LabelDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_labelDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLabelDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public LabelDeclContext labelDecl() {
		LabelDeclContext _localctx = new LabelDeclContext(Context, State);
		EnterRule(_localctx, 272, RULE_labelDecl);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2226;
			id();
			State = 2227;
			Match(T__73);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomDescrInMethodBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() {
			return GetRuleContext<CustomDescrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrWithOwnerContext customDescrWithOwner() {
			return GetRuleContext<CustomDescrWithOwnerContext>(0);
		}
		public CustomDescrInMethodBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customDescrInMethodBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomDescrInMethodBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomDescrInMethodBodyContext customDescrInMethodBody() {
		CustomDescrInMethodBodyContext _localctx = new CustomDescrInMethodBodyContext(Context, State);
		EnterRule(_localctx, 274, RULE_customDescrInMethodBody);
		try {
			State = 2231;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,127,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2229;
				customDescr();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2230;
				customDescrWithOwner();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ScopeBlockContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MethodDeclsContext methodDecls() {
			return GetRuleContext<MethodDeclsContext>(0);
		}
		public ScopeBlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_scopeBlock; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitScopeBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ScopeBlockContext scopeBlock() {
		ScopeBlockContext _localctx = new ScopeBlockContext(Context, State);
		EnterRule(_localctx, 276, RULE_scopeBlock);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2233;
			Match(T__15);
			State = 2234;
			methodDecls();
			State = 2235;
			Match(T__16);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SehBlockContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TryBlockContext tryBlock() {
			return GetRuleContext<TryBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SehClausesContext sehClauses() {
			return GetRuleContext<SehClausesContext>(0);
		}
		public SehBlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sehBlock; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSehBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SehBlockContext sehBlock() {
		SehBlockContext _localctx = new SehBlockContext(Context, State);
		EnterRule(_localctx, 278, RULE_sehBlock);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2237;
			tryBlock();
			State = 2238;
			sehClauses();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SehClausesContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SehClauseContext[] sehClause() {
			return GetRuleContexts<SehClauseContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SehClauseContext sehClause(int i) {
			return GetRuleContext<SehClauseContext>(i);
		}
		public SehClausesContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sehClauses; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSehClauses(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SehClausesContext sehClauses() {
		SehClausesContext _localctx = new SehClausesContext(Context, State);
		EnterRule(_localctx, 280, RULE_sehClauses);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2241;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 2240;
				sehClause();
				}
				}
				State = 2243;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( ((((_la - 160)) & ~0x3f) == 0 && ((1L << (_la - 160)) & 15L) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TryBlockContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() {
			return GetRuleContext<ScopeBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext[] id() {
			return GetRuleContexts<IdContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id(int i) {
			return GetRuleContext<IdContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public TryBlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_tryBlock; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTryBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TryBlockContext tryBlock() {
		TryBlockContext _localctx = new TryBlockContext(Context, State);
		EnterRule(_localctx, 282, RULE_tryBlock);
		try {
			State = 2257;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,129,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2245;
				Match(T__157);
				State = 2246;
				scopeBlock();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2247;
				Match(T__157);
				State = 2248;
				id();
				State = 2249;
				Match(T__158);
				State = 2250;
				id();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2252;
				Match(T__157);
				State = 2253;
				int32();
				State = 2254;
				Match(T__158);
				State = 2255;
				int32();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SehClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CatchClauseContext catchClause() {
			return GetRuleContext<CatchClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public HandlerBlockContext handlerBlock() {
			return GetRuleContext<HandlerBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FilterClauseContext filterClause() {
			return GetRuleContext<FilterClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FinallyClauseContext finallyClause() {
			return GetRuleContext<FinallyClauseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public FaultClauseContext faultClause() {
			return GetRuleContext<FaultClauseContext>(0);
		}
		public SehClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sehClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSehClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SehClauseContext sehClause() {
		SehClauseContext _localctx = new SehClauseContext(Context, State);
		EnterRule(_localctx, 284, RULE_sehClause);
		try {
			State = 2271;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__160:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2259;
				catchClause();
				State = 2260;
				handlerBlock();
				}
				break;
			case T__159:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2262;
				filterClause();
				State = 2263;
				handlerBlock();
				}
				break;
			case T__161:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2265;
				finallyClause();
				State = 2266;
				handlerBlock();
				}
				break;
			case T__162:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2268;
				faultClause();
				State = 2269;
				handlerBlock();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FilterClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() {
			return GetRuleContext<ScopeBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public FilterClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_filterClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFilterClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FilterClauseContext filterClause() {
		FilterClauseContext _localctx = new FilterClauseContext(Context, State);
		EnterRule(_localctx, 286, RULE_filterClause);
		try {
			State = 2279;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,131,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2273;
				Match(T__159);
				State = 2274;
				scopeBlock();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2275;
				Match(T__159);
				State = 2276;
				id();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2277;
				Match(T__159);
				State = 2278;
				int32();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CatchClauseContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TypeSpecContext typeSpec() {
			return GetRuleContext<TypeSpecContext>(0);
		}
		public CatchClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_catchClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCatchClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CatchClauseContext catchClause() {
		CatchClauseContext _localctx = new CatchClauseContext(Context, State);
		EnterRule(_localctx, 288, RULE_catchClause);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2281;
			Match(T__160);
			State = 2282;
			typeSpec();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FinallyClauseContext : ParserRuleContext {
		public FinallyClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_finallyClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFinallyClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FinallyClauseContext finallyClause() {
		FinallyClauseContext _localctx = new FinallyClauseContext(Context, State);
		EnterRule(_localctx, 290, RULE_finallyClause);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2284;
			Match(T__161);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FaultClauseContext : ParserRuleContext {
		public FaultClauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_faultClause; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFaultClause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FaultClauseContext faultClause() {
		FaultClauseContext _localctx = new FaultClauseContext(Context, State);
		EnterRule(_localctx, 292, RULE_faultClause);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2286;
			Match(T__162);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class HandlerBlockContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ScopeBlockContext scopeBlock() {
			return GetRuleContext<ScopeBlockContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext[] id() {
			return GetRuleContexts<IdContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id(int i) {
			return GetRuleContext<IdContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public HandlerBlockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_handlerBlock; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHandlerBlock(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public HandlerBlockContext handlerBlock() {
		HandlerBlockContext _localctx = new HandlerBlockContext(Context, State);
		EnterRule(_localctx, 294, RULE_handlerBlock);
		try {
			State = 2299;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,132,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2288;
				scopeBlock();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2289;
				Match(T__163);
				State = 2290;
				id();
				State = 2291;
				Match(T__158);
				State = 2292;
				id();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2294;
				Match(T__163);
				State = 2295;
				int32();
				State = 2296;
				Match(T__158);
				State = 2297;
				int32();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DataDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DdHeadContext ddHead() {
			return GetRuleContext<DdHeadContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DdBodyContext ddBody() {
			return GetRuleContext<DdBodyContext>(0);
		}
		public DataDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dataDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDataDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DataDeclContext dataDecl() {
		DataDeclContext _localctx = new DataDeclContext(Context, State);
		EnterRule(_localctx, 296, RULE_dataDecl);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2301;
			ddHead();
			State = 2302;
			ddBody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DdHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TlsContext tls() {
			return GetRuleContext<TlsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		public DdHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ddHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDdHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DdHeadContext ddHead() {
		DdHeadContext _localctx = new DdHeadContext(Context, State);
		EnterRule(_localctx, 298, RULE_ddHead);
		try {
			State = 2311;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,133,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2304;
				Match(T__164);
				State = 2305;
				tls();
				State = 2306;
				id();
				State = 2307;
				Match(T__34);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2309;
				Match(T__164);
				State = 2310;
				tls();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TlsContext : ParserRuleContext {
		public TlsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_tls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TlsContext tls() {
		TlsContext _localctx = new TlsContext(Context, State);
		EnterRule(_localctx, 300, RULE_tls);
		try {
			State = 2316;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,134,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2314;
				Match(T__165);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2315;
				Match(T__1);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DdBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DdItemListContext ddItemList() {
			return GetRuleContext<DdItemListContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DdItemContext[] ddItem() {
			return GetRuleContexts<DdItemContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DdItemContext ddItem(int i) {
			return GetRuleContext<DdItemContext>(i);
		}
		public DdBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ddBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDdBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DdBodyContext ddBody() {
		DdBodyContext _localctx = new DdBodyContext(Context, State);
		EnterRule(_localctx, 302, RULE_ddBody);
		int _la;
		try {
			State = 2327;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__15:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2318;
				Match(T__15);
				State = 2319;
				ddItemList();
				State = 2320;
				Match(T__16);
				}
				break;
			case T__82:
			case CHAR:
			case INT8:
			case INT16:
			case INT32_:
			case INT64_:
			case FLOAT32:
			case FLOAT64_:
			case REF:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2323;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				do {
					{
					{
					State = 2322;
					ddItem();
					}
					}
					State = 2325;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				} while ( _la==T__82 || ((((_la - 180)) & ~0x3f) == 0 && ((1L << (_la - 180)) & 505L) != 0) || _la==REF );
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DdItemListContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DdItemContext[] ddItem() {
			return GetRuleContexts<DdItemContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DdItemContext ddItem(int i) {
			return GetRuleContext<DdItemContext>(i);
		}
		public DdItemListContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ddItemList; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDdItemList(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DdItemListContext ddItemList() {
		DdItemListContext _localctx = new DdItemListContext(Context, State);
		EnterRule(_localctx, 304, RULE_ddItemList);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 2334;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,137,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 2329;
					ddItem();
					State = 2330;
					Match(T__26);
					}
					} 
				}
				State = 2336;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,137,Context);
			}
			State = 2337;
			ddItem();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DdItemCountContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		public DdItemCountContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ddItemCount; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDdItemCount(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DdItemCountContext ddItemCount() {
		DdItemCountContext _localctx = new DdItemCountContext(Context, State);
		EnterRule(_localctx, 306, RULE_ddItemCount);
		try {
			State = 2344;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__0:
			case T__1:
			case T__2:
			case T__3:
			case T__4:
			case T__5:
			case T__6:
			case T__7:
			case T__8:
			case T__9:
			case T__10:
			case T__11:
			case T__12:
			case T__13:
			case T__14:
			case T__15:
			case T__16:
			case T__17:
			case T__18:
			case T__19:
			case T__21:
			case T__22:
			case T__23:
			case T__24:
			case T__25:
			case T__26:
			case T__27:
			case T__30:
			case T__31:
			case T__33:
			case T__39:
			case T__46:
			case T__47:
			case T__48:
			case T__71:
			case T__72:
			case T__82:
			case T__115:
			case T__116:
			case T__118:
			case T__119:
			case T__127:
			case T__132:
			case T__138:
			case T__157:
			case T__164:
			case CHAR:
			case INT8:
			case INT16:
			case INT32_:
			case INT64_:
			case FLOAT32:
			case FLOAT64_:
			case MODULE:
			case VALUE:
			case INSTANCE:
			case UNMANAGED:
			case PARAM:
			case REF:
			case SQSTRING:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
			case MRESOURCE:
			case INSTR_NONE:
			case INSTR_VAR:
			case INSTR_I:
			case INSTR_I8:
			case INSTR_R:
			case INSTR_METHOD:
			case INSTR_SIG:
			case INSTR_BRTARGET:
			case INSTR_SWITCH:
			case INSTR_TYPE:
			case INSTR_STRING:
			case INSTR_FIELD:
			case INSTR_TOK:
			case DOTTEDNAME:
			case ID:
			case PERMISSION:
			case PERMISSIONSET:
			case EMITBYTE:
			case MAXSTACK:
			case ENTRYPOINT:
			case ZEROINIT:
			case LOCALS:
			case EXPORT:
			case OVERRIDE:
			case VTENTRY:
				EnterOuterAlt(_localctx, 1);
				{
				}
				break;
			case T__40:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2340;
				Match(T__40);
				State = 2341;
				int32();
				State = 2342;
				Match(T__41);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DdItemContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(CILParser.CHAR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PTR() { return GetToken(CILParser.PTR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REF() { return GetToken(CILParser.REF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public IdContext id() {
			return GetRuleContext<IdContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() {
			return GetRuleContext<Float64Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DdItemCountContext ddItemCount() {
			return GetRuleContext<DdItemCountContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() {
			return GetRuleContext<Int64Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		public DdItemContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_ddItem; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDdItem(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DdItemContext ddItem() {
		DdItemContext _localctx = new DdItemContext(Context, State);
		EnterRule(_localctx, 308, RULE_ddItem);
		try {
			State = 2412;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,139,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2346;
				Match(CHAR);
				State = 2347;
				Match(PTR);
				State = 2348;
				Match(T__28);
				State = 2349;
				compQstring();
				State = 2350;
				Match(T__29);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2352;
				Match(REF);
				State = 2353;
				Match(T__28);
				State = 2354;
				id();
				State = 2355;
				Match(T__29);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2357;
				Match(REF);
				State = 2358;
				id();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2359;
				Match(T__82);
				State = 2360;
				Match(T__28);
				State = 2361;
				bytes();
				State = 2362;
				Match(T__29);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2364;
				Match(FLOAT32);
				State = 2365;
				Match(T__28);
				State = 2366;
				float64();
				State = 2367;
				Match(T__29);
				State = 2368;
				ddItemCount();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2370;
				Match(FLOAT64_);
				State = 2371;
				Match(T__28);
				State = 2372;
				float64();
				State = 2373;
				Match(T__29);
				State = 2374;
				ddItemCount();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2376;
				Match(INT64_);
				State = 2377;
				Match(T__28);
				State = 2378;
				int64();
				State = 2379;
				Match(T__29);
				State = 2380;
				ddItemCount();
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2382;
				Match(INT32_);
				State = 2383;
				Match(T__28);
				State = 2384;
				int32();
				State = 2385;
				Match(T__29);
				State = 2386;
				ddItemCount();
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2388;
				Match(INT16);
				State = 2389;
				Match(T__28);
				State = 2390;
				int32();
				State = 2391;
				Match(T__29);
				State = 2392;
				ddItemCount();
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2394;
				Match(INT8);
				State = 2395;
				Match(T__28);
				State = 2396;
				int32();
				State = 2397;
				Match(T__29);
				State = 2398;
				ddItemCount();
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2400;
				Match(FLOAT32);
				State = 2401;
				ddItemCount();
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2402;
				Match(FLOAT64_);
				State = 2403;
				ddItemCount();
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2404;
				Match(INT64_);
				State = 2405;
				ddItemCount();
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2406;
				Match(INT32_);
				State = 2407;
				ddItemCount();
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2408;
				Match(INT16);
				State = 2409;
				ddItemCount();
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 2410;
				Match(INT8);
				State = 2411;
				ddItemCount();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldSerInitContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context float64() {
			return GetRuleContext<Float64Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64() {
			return GetRuleContext<Int64Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT64() { return GetToken(CILParser.UINT64, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT32() { return GetToken(CILParser.UINT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT16() { return GetToken(CILParser.UINT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT8() { return GetToken(CILParser.UINT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(CILParser.CHAR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(CILParser.BOOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TruefalseContext truefalse() {
			return GetRuleContext<TruefalseContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		public FieldSerInitContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldSerInit; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFieldSerInit(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FieldSerInitContext fieldSerInit() {
		FieldSerInitContext _localctx = new FieldSerInitContext(Context, State);
		EnterRule(_localctx, 310, RULE_fieldSerInit);
		try {
			State = 2489;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,140,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2414;
				Match(FLOAT32);
				State = 2415;
				Match(T__28);
				State = 2416;
				float64();
				State = 2417;
				Match(T__29);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2419;
				Match(FLOAT64_);
				State = 2420;
				Match(T__28);
				State = 2421;
				float64();
				State = 2422;
				Match(T__29);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2424;
				Match(FLOAT32);
				State = 2425;
				Match(T__28);
				State = 2426;
				int32();
				State = 2427;
				Match(T__29);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2429;
				Match(FLOAT64_);
				State = 2430;
				Match(T__28);
				State = 2431;
				int64();
				State = 2432;
				Match(T__29);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2434;
				Match(INT64_);
				State = 2435;
				Match(T__28);
				State = 2436;
				int64();
				State = 2437;
				Match(T__29);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2439;
				Match(INT32_);
				State = 2440;
				Match(T__28);
				State = 2441;
				int32();
				State = 2442;
				Match(T__29);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2444;
				Match(INT16);
				State = 2445;
				Match(T__28);
				State = 2446;
				int32();
				State = 2447;
				Match(T__29);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2449;
				Match(INT8);
				State = 2450;
				Match(T__28);
				State = 2451;
				int32();
				State = 2452;
				Match(T__29);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2454;
				Match(UINT64);
				State = 2455;
				Match(T__28);
				State = 2456;
				int64();
				State = 2457;
				Match(T__29);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2459;
				Match(UINT32);
				State = 2460;
				Match(T__28);
				State = 2461;
				int32();
				State = 2462;
				Match(T__29);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2464;
				Match(UINT16);
				State = 2465;
				Match(T__28);
				State = 2466;
				int32();
				State = 2467;
				Match(T__29);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2469;
				Match(UINT8);
				State = 2470;
				Match(T__28);
				State = 2471;
				int32();
				State = 2472;
				Match(T__29);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2474;
				Match(CHAR);
				State = 2475;
				Match(T__28);
				State = 2476;
				int32();
				State = 2477;
				Match(T__29);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2479;
				Match(BOOL);
				State = 2480;
				Match(T__28);
				State = 2481;
				truefalse();
				State = 2482;
				Match(T__29);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2484;
				Match(T__82);
				State = 2485;
				Match(T__28);
				State = 2486;
				bytes();
				State = 2487;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BytesContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public HexbyteContext[] hexbyte() {
			return GetRuleContexts<HexbyteContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public HexbyteContext hexbyte(int i) {
			return GetRuleContext<HexbyteContext>(i);
		}
		public BytesContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_bytes; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBytes(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BytesContext bytes() {
		BytesContext _localctx = new BytesContext(Context, State);
		EnterRule(_localctx, 312, RULE_bytes);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2494;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==INT32 || _la==ID || _la==HEXBYTE) {
				{
				{
				State = 2491;
				hexbyte();
				}
				}
				State = 2496;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class HexbyteContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32() { return GetToken(CILParser.INT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ID() { return GetToken(CILParser.ID, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HEXBYTE() { return GetToken(CILParser.HEXBYTE, 0); }
		public HexbyteContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_hexbyte; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHexbyte(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public HexbyteContext hexbyte() {
		HexbyteContext _localctx = new HexbyteContext(Context, State);
		EnterRule(_localctx, 314, RULE_hexbyte);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2497;
			_la = TokenStream.LA(1);
			if ( !(_la==INT32 || _la==ID || _la==HEXBYTE) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class FieldInitContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public FieldSerInitContext fieldSerInit() {
			return GetRuleContext<FieldSerInitContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF() { return GetToken(CILParser.NULLREF, 0); }
		public FieldInitContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_fieldInit; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFieldInit(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FieldInitContext fieldInit() {
		FieldInitContext _localctx = new FieldInitContext(Context, State);
		EnterRule(_localctx, 316, RULE_fieldInit);
		try {
			State = 2502;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__82:
			case CHAR:
			case BOOL:
			case INT8:
			case INT16:
			case INT32_:
			case INT64_:
			case FLOAT32:
			case FLOAT64_:
			case UINT8:
			case UINT16:
			case UINT32:
			case UINT64:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2499;
				fieldSerInit();
				}
				break;
			case QSTRING:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2500;
				compQstring();
				}
				break;
			case NULLREF:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2501;
				Match(NULLREF);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SerInitContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public FieldSerInitContext fieldSerInit() {
			return GetRuleContext<FieldSerInitContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(CILParser.STRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF() { return GetToken(CILParser.NULLREF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TYPE() { return GetToken(CILParser.TYPE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OBJECT() { return GetToken(CILParser.OBJECT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit() {
			return GetRuleContext<SerInitContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT32() { return GetToken(CILParser.FLOAT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public F32seqContext f32seq() {
			return GetRuleContext<F32seqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT64_() { return GetToken(CILParser.FLOAT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public F64seqContext f64seq() {
			return GetRuleContext<F64seqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT64_() { return GetToken(CILParser.INT64_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public I64seqContext i64seq() {
			return GetRuleContext<I64seqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT32_() { return GetToken(CILParser.INT32_, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public I32seqContext i32seq() {
			return GetRuleContext<I32seqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT16() { return GetToken(CILParser.INT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public I16seqContext i16seq() {
			return GetRuleContext<I16seqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT8() { return GetToken(CILParser.INT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public I8seqContext i8seq() {
			return GetRuleContext<I8seqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT64() { return GetToken(CILParser.UINT64, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT32() { return GetToken(CILParser.UINT32, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT16() { return GetToken(CILParser.UINT16, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UINT8() { return GetToken(CILParser.UINT8, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CHAR() { return GetToken(CILParser.CHAR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(CILParser.BOOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BoolSeqContext boolSeq() {
			return GetRuleContext<BoolSeqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SqstringSeqContext sqstringSeq() {
			return GetRuleContext<SqstringSeqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassSeqContext classSeq() {
			return GetRuleContext<ClassSeqContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ObjSeqContext objSeq() {
			return GetRuleContext<ObjSeqContext>(0);
		}
		public SerInitContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_serInit; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSerInit(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SerInitContext serInit() {
		SerInitContext _localctx = new SerInitContext(Context, State);
		EnterRule(_localctx, 318, RULE_serInit);
		try {
			State = 2652;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,143,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2504;
				fieldSerInit();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2505;
				Match(STRING);
				State = 2506;
				Match(T__28);
				State = 2507;
				Match(NULLREF);
				State = 2508;
				Match(T__29);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2509;
				Match(STRING);
				State = 2510;
				Match(T__28);
				State = 2511;
				Match(SQSTRING);
				State = 2512;
				Match(T__29);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2513;
				Match(TYPE);
				State = 2514;
				Match(T__28);
				State = 2515;
				Match(T__37);
				State = 2516;
				Match(SQSTRING);
				State = 2517;
				Match(T__29);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2518;
				Match(TYPE);
				State = 2519;
				Match(T__28);
				State = 2520;
				className();
				State = 2521;
				Match(T__29);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2523;
				Match(TYPE);
				State = 2524;
				Match(T__28);
				State = 2525;
				Match(NULLREF);
				State = 2526;
				Match(T__29);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2527;
				Match(OBJECT);
				State = 2528;
				Match(T__28);
				State = 2529;
				serInit();
				State = 2530;
				Match(T__29);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2532;
				Match(FLOAT32);
				State = 2533;
				Match(T__40);
				State = 2534;
				int32();
				State = 2535;
				Match(T__41);
				State = 2536;
				Match(T__28);
				State = 2537;
				f32seq();
				State = 2538;
				Match(T__29);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2540;
				Match(FLOAT64_);
				State = 2541;
				Match(T__40);
				State = 2542;
				int32();
				State = 2543;
				Match(T__41);
				State = 2544;
				Match(T__28);
				State = 2545;
				f64seq();
				State = 2546;
				Match(T__29);
				}
				break;
			case 10:
				EnterOuterAlt(_localctx, 10);
				{
				State = 2548;
				Match(INT64_);
				State = 2549;
				Match(T__40);
				State = 2550;
				int32();
				State = 2551;
				Match(T__41);
				State = 2552;
				Match(T__28);
				State = 2553;
				i64seq();
				State = 2554;
				Match(T__29);
				}
				break;
			case 11:
				EnterOuterAlt(_localctx, 11);
				{
				State = 2556;
				Match(INT32_);
				State = 2557;
				Match(T__40);
				State = 2558;
				int32();
				State = 2559;
				Match(T__41);
				State = 2560;
				Match(T__28);
				State = 2561;
				i32seq();
				State = 2562;
				Match(T__29);
				}
				break;
			case 12:
				EnterOuterAlt(_localctx, 12);
				{
				State = 2564;
				Match(INT16);
				State = 2565;
				Match(T__40);
				State = 2566;
				int32();
				State = 2567;
				Match(T__41);
				State = 2568;
				Match(T__28);
				State = 2569;
				i16seq();
				State = 2570;
				Match(T__29);
				}
				break;
			case 13:
				EnterOuterAlt(_localctx, 13);
				{
				State = 2572;
				Match(INT8);
				State = 2573;
				Match(T__40);
				State = 2574;
				int32();
				State = 2575;
				Match(T__41);
				State = 2576;
				Match(T__28);
				State = 2577;
				i8seq();
				State = 2578;
				Match(T__29);
				}
				break;
			case 14:
				EnterOuterAlt(_localctx, 14);
				{
				State = 2580;
				Match(UINT64);
				State = 2581;
				Match(T__40);
				State = 2582;
				int32();
				State = 2583;
				Match(T__41);
				State = 2584;
				Match(T__28);
				State = 2585;
				i64seq();
				State = 2586;
				Match(T__29);
				}
				break;
			case 15:
				EnterOuterAlt(_localctx, 15);
				{
				State = 2588;
				Match(UINT32);
				State = 2589;
				Match(T__40);
				State = 2590;
				int32();
				State = 2591;
				Match(T__41);
				State = 2592;
				Match(T__28);
				State = 2593;
				i32seq();
				State = 2594;
				Match(T__29);
				}
				break;
			case 16:
				EnterOuterAlt(_localctx, 16);
				{
				State = 2596;
				Match(UINT16);
				State = 2597;
				Match(T__40);
				State = 2598;
				int32();
				State = 2599;
				Match(T__41);
				State = 2600;
				Match(T__28);
				State = 2601;
				i16seq();
				State = 2602;
				Match(T__29);
				}
				break;
			case 17:
				EnterOuterAlt(_localctx, 17);
				{
				State = 2604;
				Match(UINT8);
				State = 2605;
				Match(T__40);
				State = 2606;
				int32();
				State = 2607;
				Match(T__41);
				State = 2608;
				Match(T__28);
				State = 2609;
				i8seq();
				State = 2610;
				Match(T__29);
				}
				break;
			case 18:
				EnterOuterAlt(_localctx, 18);
				{
				State = 2612;
				Match(CHAR);
				State = 2613;
				Match(T__40);
				State = 2614;
				int32();
				State = 2615;
				Match(T__41);
				State = 2616;
				Match(T__28);
				State = 2617;
				i16seq();
				State = 2618;
				Match(T__29);
				}
				break;
			case 19:
				EnterOuterAlt(_localctx, 19);
				{
				State = 2620;
				Match(BOOL);
				State = 2621;
				Match(T__40);
				State = 2622;
				int32();
				State = 2623;
				Match(T__41);
				State = 2624;
				Match(T__28);
				State = 2625;
				boolSeq();
				State = 2626;
				Match(T__29);
				}
				break;
			case 20:
				EnterOuterAlt(_localctx, 20);
				{
				State = 2628;
				Match(STRING);
				State = 2629;
				Match(T__40);
				State = 2630;
				int32();
				State = 2631;
				Match(T__41);
				State = 2632;
				Match(T__28);
				State = 2633;
				sqstringSeq();
				State = 2634;
				Match(T__29);
				}
				break;
			case 21:
				EnterOuterAlt(_localctx, 21);
				{
				State = 2636;
				Match(TYPE);
				State = 2637;
				Match(T__40);
				State = 2638;
				int32();
				State = 2639;
				Match(T__41);
				State = 2640;
				Match(T__28);
				State = 2641;
				classSeq();
				State = 2642;
				Match(T__29);
				}
				break;
			case 22:
				EnterOuterAlt(_localctx, 22);
				{
				State = 2644;
				Match(OBJECT);
				State = 2645;
				Match(T__40);
				State = 2646;
				int32();
				State = 2647;
				Match(T__41);
				State = 2648;
				Match(T__28);
				State = 2649;
				objSeq();
				State = 2650;
				Match(T__29);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class F32seqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context[] float64() {
			return GetRuleContexts<Float64Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context float64(int i) {
			return GetRuleContext<Float64Context>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public F32seqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_f32seq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitF32seq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public F32seqContext f32seq() {
		F32seqContext _localctx = new F32seqContext(Context, State);
		EnterRule(_localctx, 320, RULE_f32seq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2658;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 172)) & ~0x3f) == 0 && ((1L << (_la - 172)) & 98309L) != 0)) {
				{
				State = 2656;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,144,Context) ) {
				case 1:
					{
					State = 2654;
					float64();
					}
					break;
				case 2:
					{
					State = 2655;
					int32();
					}
					break;
				}
				}
				State = 2660;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class F64seqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context[] float64() {
			return GetRuleContexts<Float64Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Float64Context float64(int i) {
			return GetRuleContext<Float64Context>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context[] int64() {
			return GetRuleContexts<Int64Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64(int i) {
			return GetRuleContext<Int64Context>(i);
		}
		public F64seqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_f64seq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitF64seq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public F64seqContext f64seq() {
		F64seqContext _localctx = new F64seqContext(Context, State);
		EnterRule(_localctx, 322, RULE_f64seq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2665;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 172)) & ~0x3f) == 0 && ((1L << (_la - 172)) & 98311L) != 0)) {
				{
				State = 2663;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,146,Context) ) {
				case 1:
					{
					State = 2661;
					float64();
					}
					break;
				case 2:
					{
					State = 2662;
					int64();
					}
					break;
				}
				}
				State = 2667;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class I64seqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context[] int64() {
			return GetRuleContexts<Int64Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int64Context int64(int i) {
			return GetRuleContext<Int64Context>(i);
		}
		public I64seqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_i64seq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitI64seq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public I64seqContext i64seq() {
		I64seqContext _localctx = new I64seqContext(Context, State);
		EnterRule(_localctx, 324, RULE_i64seq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2671;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==INT32 || _la==INT64) {
				{
				{
				State = 2668;
				int64();
				}
				}
				State = 2673;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class I32seqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public I32seqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_i32seq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitI32seq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public I32seqContext i32seq() {
		I32seqContext _localctx = new I32seqContext(Context, State);
		EnterRule(_localctx, 326, RULE_i32seq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2677;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==INT32) {
				{
				{
				State = 2674;
				int32();
				}
				}
				State = 2679;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class I16seqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public I16seqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_i16seq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitI16seq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public I16seqContext i16seq() {
		I16seqContext _localctx = new I16seqContext(Context, State);
		EnterRule(_localctx, 328, RULE_i16seq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2683;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==INT32) {
				{
				{
				State = 2680;
				int32();
				}
				}
				State = 2685;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class I8seqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context[] int32() {
			return GetRuleContexts<Int32Context>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32(int i) {
			return GetRuleContext<Int32Context>(i);
		}
		public I8seqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_i8seq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitI8seq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public I8seqContext i8seq() {
		I8seqContext _localctx = new I8seqContext(Context, State);
		EnterRule(_localctx, 330, RULE_i8seq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2689;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==INT32) {
				{
				{
				State = 2686;
				int32();
				}
				}
				State = 2691;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BoolSeqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TruefalseContext[] truefalse() {
			return GetRuleContexts<TruefalseContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TruefalseContext truefalse(int i) {
			return GetRuleContext<TruefalseContext>(i);
		}
		public BoolSeqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_boolSeq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBoolSeq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BoolSeqContext boolSeq() {
		BoolSeqContext _localctx = new BoolSeqContext(Context, State);
		EnterRule(_localctx, 332, RULE_boolSeq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2695;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__93 || _la==T__94) {
				{
				{
				State = 2692;
				truefalse();
				}
				}
				State = 2697;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SqstringSeqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] NULLREF() { return GetTokens(CILParser.NULLREF); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF(int i) {
			return GetToken(CILParser.NULLREF, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] SQSTRING() { return GetTokens(CILParser.SQSTRING); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING(int i) {
			return GetToken(CILParser.SQSTRING, i);
		}
		public SqstringSeqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sqstringSeq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSqstringSeq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SqstringSeqContext sqstringSeq() {
		SqstringSeqContext _localctx = new SqstringSeqContext(Context, State);
		EnterRule(_localctx, 334, RULE_sqstringSeq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2701;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==NULLREF || _la==SQSTRING) {
				{
				{
				State = 2698;
				_la = TokenStream.LA(1);
				if ( !(_la==NULLREF || _la==SQSTRING) ) {
				ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				}
				}
				State = 2703;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassSeqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ClassSeqElementContext[] classSeqElement() {
			return GetRuleContexts<ClassSeqElementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ClassSeqElementContext classSeqElement(int i) {
			return GetRuleContext<ClassSeqElementContext>(i);
		}
		public ClassSeqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_classSeq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassSeq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassSeqContext classSeq() {
		ClassSeqContext _localctx = new ClassSeqContext(Context, State);
		EnterRule(_localctx, 336, RULE_classSeq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2707;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__37 || _la==T__40 || _la==T__111 || _la==NULLREF || _la==VALUE || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & 105553118478337L) != 0)) {
				{
				{
				State = 2704;
				classSeqElement();
				}
				}
				State = 2709;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ClassSeqElementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLREF() { return GetToken(CILParser.NULLREF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SQSTRING() { return GetToken(CILParser.SQSTRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ClassNameContext className() {
			return GetRuleContext<ClassNameContext>(0);
		}
		public ClassSeqElementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_classSeqElement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitClassSeqElement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ClassSeqElementContext classSeqElement() {
		ClassSeqElementContext _localctx = new ClassSeqElementContext(Context, State);
		EnterRule(_localctx, 338, RULE_classSeqElement);
		try {
			State = 2714;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case NULLREF:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2710;
				Match(NULLREF);
				}
				break;
			case T__37:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2711;
				Match(T__37);
				State = 2712;
				Match(SQSTRING);
				}
				break;
			case T__40:
			case T__111:
			case VALUE:
			case INSTANCE:
			case THIS:
			case BASE:
			case NESTER:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2713;
				className();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ObjSeqContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext[] serInit() {
			return GetRuleContexts<SerInitContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SerInitContext serInit(int i) {
			return GetRuleContext<SerInitContext>(i);
		}
		public ObjSeqContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_objSeq; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitObjSeq(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ObjSeqContext objSeq() {
		ObjSeqContext _localctx = new ObjSeqContext(Context, State);
		EnterRule(_localctx, 340, RULE_objSeq);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2719;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__82 || ((((_la - 180)) & ~0x3f) == 0 && ((1L << (_la - 180)) & 106495L) != 0)) {
				{
				{
				State = 2716;
				serInit();
				}
				}
				State = 2721;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class CustomAttrDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrContext customDescr() {
			return GetRuleContext<CustomDescrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomDescrWithOwnerContext customDescrWithOwner() {
			return GetRuleContext<CustomDescrWithOwnerContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		public CustomAttrDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_customAttrDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitCustomAttrDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public CustomAttrDeclContext customAttrDecl() {
		CustomAttrDeclContext _localctx = new CustomAttrDeclContext(Context, State);
		EnterRule(_localctx, 342, RULE_customAttrDecl);
		try {
			State = 2725;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,157,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2722;
				customDescr();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2723;
				customDescrWithOwner();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2724;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AsmOrRefDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public IntOrWildcardContext[] intOrWildcard() {
			return GetRuleContexts<IntOrWildcardContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public IntOrWildcardContext intOrWildcard(int i) {
			return GetRuleContext<IntOrWildcardContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompQstringContext compQstring() {
			return GetRuleContext<CompQstringContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl() {
			return GetRuleContext<CustomAttrDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		public AsmOrRefDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_asmOrRefDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAsmOrRefDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AsmOrRefDeclContext asmOrRefDecl() {
		AsmOrRefDeclContext _localctx = new AsmOrRefDeclContext(Context, State);
		EnterRule(_localctx, 344, RULE_asmOrRefDecl);
		try {
			State = 2752;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,158,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2727;
				Match(T__166);
				State = 2728;
				Match(T__34);
				State = 2729;
				Match(T__28);
				State = 2730;
				bytes();
				State = 2731;
				Match(T__29);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2733;
				Match(T__167);
				State = 2734;
				intOrWildcard();
				State = 2735;
				Match(T__73);
				State = 2736;
				intOrWildcard();
				State = 2737;
				Match(T__73);
				State = 2738;
				intOrWildcard();
				State = 2739;
				Match(T__73);
				State = 2740;
				intOrWildcard();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2742;
				Match(T__168);
				State = 2743;
				compQstring();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2744;
				Match(T__168);
				State = 2745;
				Match(T__34);
				State = 2746;
				Match(T__28);
				State = 2747;
				bytes();
				State = 2748;
				Match(T__29);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2750;
				customAttrDecl();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2751;
				compControl();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssemblyRefHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AsmAttrContext asmAttr() {
			return GetRuleContext<AsmAttrContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() {
			return GetRuleContexts<DottedNameContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName(int i) {
			return GetRuleContext<DottedNameContext>(i);
		}
		public AssemblyRefHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assemblyRefHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssemblyRefHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssemblyRefHeadContext assemblyRefHead() {
		AssemblyRefHeadContext _localctx = new AssemblyRefHeadContext(Context, State);
		EnterRule(_localctx, 346, RULE_assemblyRefHead);
		try {
			State = 2766;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,159,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2754;
				Match(T__23);
				State = 2755;
				Match(T__38);
				State = 2756;
				asmAttr();
				State = 2757;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2759;
				Match(T__23);
				State = 2760;
				Match(T__38);
				State = 2761;
				asmAttr();
				State = 2762;
				dottedName();
				State = 2763;
				Match(T__32);
				State = 2764;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssemblyRefDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclContext[] assemblyRefDecl() {
			return GetRuleContexts<AssemblyRefDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public AssemblyRefDeclContext assemblyRefDecl(int i) {
			return GetRuleContext<AssemblyRefDeclContext>(i);
		}
		public AssemblyRefDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assemblyRefDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssemblyRefDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssemblyRefDeclsContext assemblyRefDecls() {
		AssemblyRefDeclsContext _localctx = new AssemblyRefDeclsContext(Context, State);
		EnterRule(_localctx, 348, RULE_assemblyRefDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2771;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 18014417836834816L) != 0) || ((((_la - 167)) & ~0x3f) == 0 && ((1L << (_la - 167)) & 2147487759L) != 0) || ((((_la - 242)) & ~0x3f) == 0 && ((1L << (_la - 242)) & 105555249070081L) != 0)) {
				{
				{
				State = 2768;
				assemblyRefDecl();
				}
				}
				State = 2773;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class AssemblyRefDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode HASH() { return GetToken(CILParser.HASH, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public BytesContext bytes() {
			return GetRuleContext<BytesContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public AsmOrRefDeclContext asmOrRefDecl() {
			return GetRuleContext<AsmOrRefDeclContext>(0);
		}
		public AssemblyRefDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_assemblyRefDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAssemblyRefDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public AssemblyRefDeclContext assemblyRefDecl() {
		AssemblyRefDeclContext _localctx = new AssemblyRefDeclContext(Context, State);
		EnterRule(_localctx, 350, RULE_assemblyRefDecl);
		try {
			State = 2788;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case HASH:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2774;
				Match(HASH);
				State = 2775;
				Match(T__34);
				State = 2776;
				Match(T__28);
				State = 2777;
				bytes();
				State = 2778;
				Match(T__29);
				}
				break;
			case T__30:
			case T__33:
			case T__166:
			case T__167:
			case T__168:
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2780;
				asmOrRefDecl();
				}
				break;
			case T__169:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2781;
				Match(T__169);
				State = 2782;
				Match(T__34);
				State = 2783;
				Match(T__28);
				State = 2784;
				bytes();
				State = 2785;
				Match(T__29);
				}
				break;
			case T__53:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2787;
				Match(T__53);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExptypeHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext[] exptAttr() {
			return GetRuleContexts<ExptAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext exptAttr(int i) {
			return GetRuleContext<ExptAttrContext>(i);
		}
		public ExptypeHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_exptypeHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExptypeHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExptypeHeadContext exptypeHead() {
		ExptypeHeadContext _localctx = new ExptypeHeadContext(Context, State);
		EnterRule(_localctx, 352, RULE_exptypeHead);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2790;
			Match(T__48);
			State = 2791;
			Match(T__38);
			State = 2795;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 2309220708934221824L) != 0) || _la==T__170) {
				{
				{
				State = 2792;
				exptAttr();
				}
				}
				State = 2797;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 2798;
			dottedName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExportHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode EXPORT() { return GetToken(CILParser.EXPORT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext[] exptAttr() {
			return GetRuleContexts<ExptAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptAttrContext exptAttr(int i) {
			return GetRuleContext<ExptAttrContext>(i);
		}
		public ExportHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_exportHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExportHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExportHeadContext exportHead() {
		ExportHeadContext _localctx = new ExportHeadContext(Context, State);
		EnterRule(_localctx, 354, RULE_exportHead);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2800;
			Match(EXPORT);
			State = 2804;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 2309220708934221824L) != 0) || _la==T__170) {
				{
				{
				State = 2801;
				exptAttr();
				}
				}
				State = 2806;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 2807;
			dottedName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExptAttrContext : ParserRuleContext {
		public ExptAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_exptAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExptAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExptAttrContext exptAttr() {
		ExptAttrContext _localctx = new ExptAttrContext(Context, State);
		EnterRule(_localctx, 356, RULE_exptAttr);
		try {
			State = 2824;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,164,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2809;
				Match(T__50);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2810;
				Match(T__49);
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2811;
				Match(T__170);
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2812;
				Match(T__60);
				State = 2813;
				Match(T__49);
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2814;
				Match(T__60);
				State = 2815;
				Match(T__50);
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2816;
				Match(T__60);
				State = 2817;
				Match(T__61);
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2818;
				Match(T__60);
				State = 2819;
				Match(T__62);
				}
				break;
			case 8:
				EnterOuterAlt(_localctx, 8);
				{
				State = 2820;
				Match(T__60);
				State = 2821;
				Match(T__63);
				}
				break;
			case 9:
				EnterOuterAlt(_localctx, 9);
				{
				State = 2822;
				Match(T__60);
				State = 2823;
				Match(T__64);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExptypeDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclContext[] exptypeDecl() {
			return GetRuleContexts<ExptypeDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExptypeDeclContext exptypeDecl(int i) {
			return GetRuleContext<ExptypeDeclContext>(i);
		}
		public ExptypeDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_exptypeDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExptypeDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExptypeDeclsContext exptypeDecls() {
		ExptypeDeclsContext _localctx = new ExptypeDeclsContext(Context, State);
		EnterRule(_localctx, 358, RULE_exptypeDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2829;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 562969298599936L) != 0) || _la==T__111 || _la==VALUE || _la==INSTANCE || ((((_la - 263)) & ~0x3f) == 0 && ((1L << (_la - 263)) & 50332665L) != 0)) {
				{
				{
				State = 2826;
				exptypeDecl();
				}
				}
				State = 2831;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExptypeDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SlashedNameContext slashedName() {
			return GetRuleContext<SlashedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MdtokenContext mdtoken() {
			return GetRuleContext<MdtokenContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl() {
			return GetRuleContext<CustomAttrDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		public ExptypeDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_exptypeDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExptypeDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExptypeDeclContext exptypeDecl() {
		ExptypeDeclContext _localctx = new ExptypeDeclContext(Context, State);
		EnterRule(_localctx, 360, RULE_exptypeDecl);
		try {
			State = 2845;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,166,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2832;
				Match(T__19);
				State = 2833;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2834;
				Match(T__48);
				State = 2835;
				Match(T__38);
				State = 2836;
				slashedName();
				}
				break;
			case 3:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2837;
				Match(T__23);
				State = 2838;
				Match(T__38);
				State = 2839;
				dottedName();
				}
				break;
			case 4:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2840;
				mdtoken();
				}
				break;
			case 5:
				EnterOuterAlt(_localctx, 5);
				{
				State = 2841;
				Match(T__48);
				State = 2842;
				int32();
				}
				break;
			case 6:
				EnterOuterAlt(_localctx, 6);
				{
				State = 2843;
				customAttrDecl();
				}
				break;
			case 7:
				EnterOuterAlt(_localctx, 7);
				{
				State = 2844;
				compControl();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ManifestResHeadContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MRESOURCE() { return GetToken(CILParser.MRESOURCE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext[] dottedName() {
			return GetRuleContexts<DottedNameContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName(int i) {
			return GetRuleContext<DottedNameContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManresAttrContext[] manresAttr() {
			return GetRuleContexts<ManresAttrContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManresAttrContext manresAttr(int i) {
			return GetRuleContext<ManresAttrContext>(i);
		}
		public ManifestResHeadContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_manifestResHead; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitManifestResHead(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ManifestResHeadContext manifestResHead() {
		ManifestResHeadContext _localctx = new ManifestResHeadContext(Context, State);
		EnterRule(_localctx, 362, RULE_manifestResHead);
		int _la;
		try {
			State = 2866;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,169,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2847;
				Match(MRESOURCE);
				State = 2851;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__49 || _la==T__50) {
					{
					{
					State = 2848;
					manresAttr();
					}
					}
					State = 2853;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 2854;
				dottedName();
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2855;
				Match(MRESOURCE);
				State = 2859;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__49 || _la==T__50) {
					{
					{
					State = 2856;
					manresAttr();
					}
					}
					State = 2861;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 2862;
				dottedName();
				State = 2863;
				Match(T__32);
				State = 2864;
				dottedName();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ManresAttrContext : ParserRuleContext {
		public ManresAttrContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_manresAttr; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitManresAttr(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ManresAttrContext manresAttr() {
		ManresAttrContext _localctx = new ManresAttrContext(Context, State);
		EnterRule(_localctx, 364, RULE_manresAttr);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2868;
			_la = TokenStream.LA(1);
			if ( !(_la==T__49 || _la==T__50) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ManifestResDeclsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclContext[] manifestResDecl() {
			return GetRuleContexts<ManifestResDeclContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ManifestResDeclContext manifestResDecl(int i) {
			return GetRuleContext<ManifestResDeclContext>(i);
		}
		public ManifestResDeclsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_manifestResDecls; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitManifestResDecls(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ManifestResDeclsContext manifestResDecls() {
		ManifestResDeclsContext _localctx = new ManifestResDeclsContext(Context, State);
		EnterRule(_localctx, 366, RULE_manifestResDecls);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 2873;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 19345178624L) != 0) || _la==VALUE || _la==INSTANCE || ((((_la - 263)) & ~0x3f) == 0 && ((1L << (_la - 263)) & 50332665L) != 0)) {
				{
				{
				State = 2870;
				manifestResDecl();
				}
				}
				State = 2875;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ManifestResDeclContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DottedNameContext dottedName() {
			return GetRuleContext<DottedNameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Int32Context int32() {
			return GetRuleContext<Int32Context>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CustomAttrDeclContext customAttrDecl() {
			return GetRuleContext<CustomAttrDeclContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public CompControlContext compControl() {
			return GetRuleContext<CompControlContext>(0);
		}
		public ManifestResDeclContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_manifestResDecl; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			ICILVisitor<TResult> typedVisitor = visitor as ICILVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitManifestResDecl(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ManifestResDeclContext manifestResDecl() {
		ManifestResDeclContext _localctx = new ManifestResDeclContext(Context, State);
		EnterRule(_localctx, 368, RULE_manifestResDecl);
		try {
			State = 2886;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case T__19:
				EnterOuterAlt(_localctx, 1);
				{
				State = 2876;
				Match(T__19);
				State = 2877;
				dottedName();
				State = 2878;
				Match(T__42);
				State = 2879;
				int32();
				}
				break;
			case T__23:
				EnterOuterAlt(_localctx, 2);
				{
				State = 2881;
				Match(T__23);
				State = 2882;
				Match(T__38);
				State = 2883;
				dottedName();
				}
				break;
			case T__33:
			case VALUE:
			case INSTANCE:
			case SQSTRING:
			case DOTTEDNAME:
			case ID:
				EnterOuterAlt(_localctx, 3);
				{
				State = 2884;
				customAttrDecl();
				}
				break;
			case T__30:
			case PP_DEFINE:
			case PP_UNDEF:
			case PP_IFDEF:
			case PP_IFNDEF:
			case PP_ELSE:
			case PP_ENDIF:
			case PP_INCLUDE:
				EnterOuterAlt(_localctx, 4);
				{
				State = 2885;
				compControl();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 34: return vtfixupAttr_sempred((VtfixupAttrContext)_localctx, predIndex);
		}
		return true;
	}
	private bool vtfixupAttr_sempred(VtfixupAttrContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 5);
		case 1: return Precpred(Context, 4);
		case 2: return Precpred(Context, 3);
		case 3: return Precpred(Context, 2);
		case 4: return Precpred(Context, 1);
		}
		return true;
	}

	private static int[] _serializedATN = {
		4,1,304,2889,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,
		7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7,14,
		2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,7,21,
		2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,7,28,
		2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,7,35,
		2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,
		2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,
		2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,
		2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,
		2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,
		2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,
		2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,
		2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,91,
		2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,7,98,
		2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,7,104,
		2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,7,110,
		2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,7,116,
		2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122,7,122,
		2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128,7,128,
		2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134,7,134,
		2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,
		2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,
		2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,
		2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
		2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,7,164,
		2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170,7,170,
		2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,2,176,7,176,
		2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,2,181,7,181,2,182,7,182,
		2,183,7,183,2,184,7,184,1,0,1,0,1,1,1,1,1,1,1,1,5,1,377,8,1,10,1,12,1,
		380,9,1,1,1,3,1,383,8,1,1,2,1,2,1,3,1,3,5,3,389,8,3,10,3,12,3,392,9,3,
		1,3,1,3,1,4,5,4,397,8,4,10,4,12,4,400,9,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,
		1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,
		5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,
		1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,452,8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,
		8,1,8,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,
		1,11,1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
		1,13,1,13,1,13,3,13,493,8,13,1,14,1,14,1,15,1,15,1,15,5,15,500,8,15,10,
		15,12,15,503,9,15,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,
		18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,526,8,18,1,19,
		1,19,3,19,530,8,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,
		20,1,20,1,20,1,20,1,20,1,20,3,20,548,8,20,1,21,1,21,1,21,1,21,1,21,1,21,
		1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,
		1,21,1,21,1,21,1,21,1,21,3,21,575,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,
		22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,
		22,3,22,598,8,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
		1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,
		1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,634,8,23,1,24,1,24,1,
		25,1,25,3,25,640,8,25,1,26,1,26,1,26,1,27,1,27,5,27,647,8,27,10,27,12,
		27,650,9,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,5,28,659,8,28,10,28,12,
		28,662,9,28,1,29,1,29,1,30,1,30,3,30,668,8,30,1,31,1,31,1,31,1,31,1,31,
		1,31,1,31,1,31,1,31,3,31,679,8,31,1,32,1,32,1,32,1,32,1,32,1,32,3,32,687,
		8,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,
		1,34,1,34,1,34,1,34,1,34,1,34,5,34,708,8,34,10,34,12,34,711,9,34,1,35,
		1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,37,1,37,5,37,724,8,37,10,37,
		12,37,727,9,37,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,38,
		1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,
		1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,
		1,38,1,38,1,38,3,38,771,8,38,1,39,1,39,1,39,3,39,776,8,39,1,40,1,40,1,
		40,3,40,781,8,40,1,41,5,41,784,8,41,10,41,12,41,787,9,41,1,42,1,42,1,42,
		5,42,792,8,42,10,42,12,42,795,9,42,1,42,1,42,1,43,1,43,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,
		1,44,1,44,3,44,904,8,44,1,45,1,45,5,45,908,8,45,10,45,12,45,911,9,45,1,
		45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,5,45,924,8,45,10,
		45,12,45,927,9,45,1,45,1,45,1,45,3,45,932,8,45,1,46,1,46,1,47,1,47,3,47,
		938,8,47,1,48,1,48,1,49,5,49,943,8,49,10,49,12,49,946,9,49,1,50,1,50,1,
		51,1,51,1,52,1,52,1,53,1,53,1,54,1,54,1,55,1,55,1,56,1,56,1,57,1,57,1,
		58,1,58,1,59,1,59,1,60,1,60,1,61,1,61,1,62,1,62,1,63,1,63,1,63,1,63,1,
		63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,
		63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,
		63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,
		63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,
		63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,
		63,1,63,1,63,1,63,1,63,3,63,1053,8,63,1,64,1,64,1,64,3,64,1058,8,64,1,
		64,1,64,5,64,1062,8,64,10,64,12,64,1065,9,64,1,64,1,64,3,64,1069,8,64,
		3,64,1071,8,64,1,65,1,65,1,65,1,65,5,65,1077,8,65,10,65,12,65,1080,9,65,
		1,65,1,65,1,65,1,66,1,66,1,66,1,66,5,66,1089,8,66,10,66,12,66,1092,9,66,
		1,66,1,66,1,66,1,67,1,67,1,67,1,67,5,67,1101,8,67,10,67,12,67,1104,9,67,
		1,67,1,67,1,67,1,67,3,67,1110,8,67,1,68,1,68,1,68,1,68,1,68,3,68,1117,
		8,68,3,68,1119,8,68,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,
		1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,
		1,69,3,69,1146,8,69,1,70,1,70,1,70,5,70,1151,8,70,10,70,12,70,1154,9,70,
		1,70,1,70,1,71,5,71,1159,8,71,10,71,12,71,1162,9,71,1,72,1,72,1,72,1,72,
		1,72,3,72,1169,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,73,
		1,73,3,73,1182,8,73,1,74,1,74,1,74,5,74,1187,8,74,10,74,12,74,1190,9,74,
		3,74,1192,8,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,75,
		1,75,1,75,1,75,1,75,1,75,1,75,3,75,1211,8,75,1,76,1,76,1,76,1,76,1,76,
		1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
		1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
		1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
		1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
		1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
		1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,3,76,1297,8,76,1,77,1,77,
		1,77,1,77,1,77,1,77,1,77,3,77,1306,8,77,1,78,1,78,1,78,5,78,1311,8,78,
		10,78,12,78,1314,9,78,3,78,1316,8,78,1,79,1,79,1,80,1,80,5,80,1322,8,80,
		10,80,12,80,1325,9,80,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,
		1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,81,3,81,1345,8,81,1,82,1,82,1,82,
		1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
		1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,
		1377,8,82,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,
		1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1400,8,83,1,84,1,84,
		1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1412,8,84,1,85,1,85,1,85,
		1,86,1,86,1,86,1,86,3,86,1421,8,86,1,87,1,87,1,87,1,87,1,87,1,87,1,87,
		1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,
		1,87,1,87,3,87,1446,8,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,
		1,87,1,87,1,87,1,87,1,87,1,87,3,87,1463,8,87,1,88,1,88,1,88,1,88,5,88,
		1469,8,88,10,88,12,88,1472,9,88,1,88,3,88,1475,8,88,1,89,1,89,1,89,1,89,
		1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,1490,8,89,1,90,1,90,
		1,90,5,90,1495,8,90,10,90,12,90,1498,9,90,1,90,1,90,1,91,1,91,1,91,1,91,
		1,92,1,92,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,
		1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,
		1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,3,93,1542,8,93,1,94,1,94,1,95,
		1,95,1,95,1,95,1,95,1,95,3,95,1552,8,95,1,95,1,95,1,95,1,95,1,95,1,95,
		1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,3,95,1568,8,95,1,95,1,95,1,95,
		1,95,1,95,1,95,1,95,1,95,1,95,1,95,3,95,1580,8,95,1,96,1,96,1,96,1,96,
		1,96,1,96,1,96,1,96,1,96,1,96,3,96,1592,8,96,1,97,1,97,1,97,1,97,1,97,
		1,97,1,97,1,97,1,97,1,97,1,97,1,97,3,97,1606,8,97,1,98,1,98,1,98,1,98,
		1,98,1,99,1,99,1,99,1,99,1,99,3,99,1618,8,99,1,100,1,100,1,100,1,100,1,
		100,1,100,1,100,1,100,1,100,3,100,1629,8,100,1,101,1,101,1,101,5,101,1634,
		8,101,10,101,12,101,1637,9,101,1,101,1,101,1,102,1,102,1,102,1,102,1,102,
		3,102,1646,8,102,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,
		1,103,1,103,3,103,1659,8,103,1,104,5,104,1662,8,104,10,104,12,104,1665,
		9,104,1,105,1,105,3,105,1669,8,105,1,105,1,105,1,106,1,106,1,106,5,106,
		1676,8,106,10,106,12,106,1679,9,106,1,106,1,106,1,107,1,107,1,107,1,107,
		1,108,1,108,3,108,1689,8,108,1,109,1,109,1,109,1,109,1,109,1,109,1,110,
		1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,
		1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,
		1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,
		1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,
		1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,
		1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,
		5,110,1770,8,110,10,110,12,110,1773,9,110,1,110,1,110,1,110,1,110,5,110,
		1779,8,110,10,110,12,110,1782,9,110,1,110,1,110,1,110,1,110,1,110,1,110,
		1,110,1,110,5,110,1792,8,110,10,110,12,110,1795,9,110,1,110,1,110,1,110,
		1,110,1,110,1,110,5,110,1803,8,110,10,110,12,110,1806,9,110,1,110,1,110,
		1,110,1,110,1,110,3,110,1813,8,110,1,111,1,111,1,111,1,111,1,111,1,111,
		1,111,1,111,5,111,1823,8,111,10,111,12,111,1826,9,111,1,111,1,111,1,111,
		1,111,1,111,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,
		1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,1852,8,112,
		1,113,1,113,1,113,1,113,1,113,3,113,1859,8,113,1,114,1,114,1,114,3,114,
		1864,8,114,1,115,1,115,1,115,1,115,1,115,3,115,1871,8,115,1,116,1,116,
		5,116,1875,8,116,10,116,12,116,1878,9,116,1,116,1,116,1,116,1,116,1,116,
		5,116,1885,8,116,10,116,12,116,1888,9,116,1,116,3,116,1891,8,116,1,117,
		1,117,1,118,5,118,1896,8,118,10,118,12,118,1899,9,118,1,119,1,119,1,119,
		1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,3,119,1913,8,119,
		1,120,1,120,5,120,1917,8,120,10,120,12,120,1920,9,120,1,120,1,120,1,120,
		1,120,1,120,1,120,1,121,1,121,1,122,5,122,1931,8,122,10,122,12,122,1934,
		9,122,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,123,3,123,
		1946,8,123,1,124,1,124,1,124,1,124,1,124,1,124,3,124,1954,8,124,1,125,
		1,125,1,125,4,125,1959,8,125,11,125,12,125,1960,1,125,1,125,3,125,1965,
		8,125,1,126,5,126,1968,8,126,10,126,12,126,1971,9,126,1,127,1,127,1,127,
		1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,3,127,1986,
		8,127,1,128,1,128,1,128,5,128,1991,8,128,10,128,12,128,1994,9,128,1,128,
		1,128,1,128,1,128,1,128,1,128,1,128,1,128,5,128,2004,8,128,10,128,12,128,
		2007,9,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,
		1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,
		1,129,3,129,2032,8,129,1,130,1,130,1,130,1,130,1,130,3,130,2039,8,130,
		3,130,2041,8,130,1,130,5,130,2044,8,130,10,130,12,130,2047,9,130,1,130,
		1,130,1,130,3,130,2052,8,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,
		1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,
		1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,3,131,2081,8,131,1,132,
		1,132,1,132,3,132,2086,8,132,1,133,1,133,1,133,1,133,1,133,1,133,1,133,
		1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,1,133,
		1,133,1,133,3,133,2109,8,133,1,134,5,134,2112,8,134,10,134,12,134,2115,
		9,134,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
		1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
		1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
		1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
		1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
		5,135,2176,8,135,10,135,12,135,2179,9,135,1,135,1,135,1,135,1,135,5,135,
		2185,8,135,10,135,12,135,2188,9,135,1,135,1,135,1,135,1,135,1,135,1,135,
		1,135,1,135,5,135,2198,8,135,10,135,12,135,2201,9,135,1,135,1,135,1,135,
		1,135,1,135,1,135,5,135,2209,8,135,10,135,12,135,2212,9,135,1,135,1,135,
		1,135,1,135,1,135,1,135,5,135,2220,8,135,10,135,12,135,2223,9,135,3,135,
		2225,8,135,1,136,1,136,1,136,1,137,1,137,3,137,2232,8,137,1,138,1,138,
		1,138,1,138,1,139,1,139,1,139,1,140,4,140,2242,8,140,11,140,12,140,2243,
		1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,
		3,141,2258,8,141,1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142,1,142,
		1,142,1,142,1,142,3,142,2272,8,142,1,143,1,143,1,143,1,143,1,143,1,143,
		3,143,2280,8,143,1,144,1,144,1,144,1,145,1,145,1,146,1,146,1,147,1,147,
		1,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147,1,147,3,147,2300,8,147,
		1,148,1,148,1,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,3,149,2312,
		8,149,1,150,1,150,1,150,3,150,2317,8,150,1,151,1,151,1,151,1,151,1,151,
		4,151,2324,8,151,11,151,12,151,2325,3,151,2328,8,151,1,152,1,152,1,152,
		5,152,2333,8,152,10,152,12,152,2336,9,152,1,152,1,152,1,153,1,153,1,153,
		1,153,1,153,3,153,2345,8,153,1,154,1,154,1,154,1,154,1,154,1,154,1,154,
		1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,
		1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,
		1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,
		1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,
		1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,154,3,154,
		2413,8,154,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
		1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
		1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
		1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
		1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
		1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,
		1,155,1,155,1,155,1,155,1,155,3,155,2490,8,155,1,156,5,156,2493,8,156,
		10,156,12,156,2496,9,156,1,157,1,157,1,158,1,158,1,158,3,158,2503,8,158,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,1,159,
		1,159,1,159,1,159,1,159,3,159,2653,8,159,1,160,1,160,5,160,2657,8,160,
		10,160,12,160,2660,9,160,1,161,1,161,5,161,2664,8,161,10,161,12,161,2667,
		9,161,1,162,5,162,2670,8,162,10,162,12,162,2673,9,162,1,163,5,163,2676,
		8,163,10,163,12,163,2679,9,163,1,164,5,164,2682,8,164,10,164,12,164,2685,
		9,164,1,165,5,165,2688,8,165,10,165,12,165,2691,9,165,1,166,5,166,2694,
		8,166,10,166,12,166,2697,9,166,1,167,5,167,2700,8,167,10,167,12,167,2703,
		9,167,1,168,5,168,2706,8,168,10,168,12,168,2709,9,168,1,169,1,169,1,169,
		1,169,3,169,2715,8,169,1,170,5,170,2718,8,170,10,170,12,170,2721,9,170,
		1,171,1,171,1,171,3,171,2726,8,171,1,172,1,172,1,172,1,172,1,172,1,172,
		1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,
		1,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172,2753,8,172,1,173,1,173,
		1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,3,173,2767,
		8,173,1,174,5,174,2770,8,174,10,174,12,174,2773,9,174,1,175,1,175,1,175,
		1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,1,175,3,175,
		2789,8,175,1,176,1,176,1,176,5,176,2794,8,176,10,176,12,176,2797,9,176,
		1,176,1,176,1,177,1,177,5,177,2803,8,177,10,177,12,177,2806,9,177,1,177,
		1,177,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,
		1,178,1,178,1,178,1,178,3,178,2825,8,178,1,179,5,179,2828,8,179,10,179,
		12,179,2831,9,179,1,180,1,180,1,180,1,180,1,180,1,180,1,180,1,180,1,180,
		1,180,1,180,1,180,1,180,3,180,2846,8,180,1,181,1,181,5,181,2850,8,181,
		10,181,12,181,2853,9,181,1,181,1,181,1,181,5,181,2858,8,181,10,181,12,
		181,2861,9,181,1,181,1,181,1,181,1,181,3,181,2867,8,181,1,182,1,182,1,
		183,5,183,2872,8,183,10,183,12,183,2875,9,183,1,184,1,184,1,184,1,184,
		1,184,1,184,1,184,1,184,1,184,1,184,3,184,2887,8,184,1,184,0,1,68,185,
		0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,
		50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,
		98,100,102,104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,
		134,136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166,168,
		170,172,174,176,178,180,182,184,186,188,190,192,194,196,198,200,202,204,
		206,208,210,212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,
		242,244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,274,276,
		278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,308,310,312,
		314,316,318,320,322,324,326,328,330,332,334,336,338,340,342,344,346,348,
		350,352,354,356,358,360,362,364,366,368,0,15,6,0,1,15,198,198,242,242,
		246,246,263,263,288,288,4,0,198,198,242,242,263,263,288,288,1,0,262,263,
		1,0,172,173,1,0,36,37,1,0,72,73,3,0,2,2,60,60,76,82,2,0,228,228,259,260,
		9,0,177,177,182,194,200,200,206,207,209,214,217,218,221,221,229,241,261,
		261,1,0,94,95,1,0,96,110,1,0,67,68,2,0,172,172,288,289,2,0,178,178,263,
		263,1,0,50,51,3299,0,370,1,0,0,0,2,382,1,0,0,0,4,384,1,0,0,0,6,390,1,0,
		0,0,8,398,1,0,0,0,10,451,1,0,0,0,12,453,1,0,0,0,14,456,1,0,0,0,16,459,
		1,0,0,0,18,463,1,0,0,0,20,466,1,0,0,0,22,469,1,0,0,0,24,476,1,0,0,0,26,
		492,1,0,0,0,28,494,1,0,0,0,30,496,1,0,0,0,32,506,1,0,0,0,34,508,1,0,0,
		0,36,525,1,0,0,0,38,529,1,0,0,0,40,547,1,0,0,0,42,574,1,0,0,0,44,597,1,
		0,0,0,46,633,1,0,0,0,48,635,1,0,0,0,50,639,1,0,0,0,52,641,1,0,0,0,54,648,
		1,0,0,0,56,660,1,0,0,0,58,663,1,0,0,0,60,665,1,0,0,0,62,678,1,0,0,0,64,
		686,1,0,0,0,66,688,1,0,0,0,68,696,1,0,0,0,70,712,1,0,0,0,72,718,1,0,0,
		0,74,721,1,0,0,0,76,770,1,0,0,0,78,775,1,0,0,0,80,780,1,0,0,0,82,785,1,
		0,0,0,84,793,1,0,0,0,86,798,1,0,0,0,88,903,1,0,0,0,90,931,1,0,0,0,92,933,
		1,0,0,0,94,937,1,0,0,0,96,939,1,0,0,0,98,944,1,0,0,0,100,947,1,0,0,0,102,
		949,1,0,0,0,104,951,1,0,0,0,106,953,1,0,0,0,108,955,1,0,0,0,110,957,1,
		0,0,0,112,959,1,0,0,0,114,961,1,0,0,0,116,963,1,0,0,0,118,965,1,0,0,0,
		120,967,1,0,0,0,122,969,1,0,0,0,124,971,1,0,0,0,126,1052,1,0,0,0,128,1070,
		1,0,0,0,130,1072,1,0,0,0,132,1084,1,0,0,0,134,1109,1,0,0,0,136,1118,1,
		0,0,0,138,1145,1,0,0,0,140,1152,1,0,0,0,142,1160,1,0,0,0,144,1168,1,0,
		0,0,146,1181,1,0,0,0,148,1191,1,0,0,0,150,1210,1,0,0,0,152,1296,1,0,0,
		0,154,1305,1,0,0,0,156,1315,1,0,0,0,158,1317,1,0,0,0,160,1319,1,0,0,0,
		162,1344,1,0,0,0,164,1376,1,0,0,0,166,1399,1,0,0,0,168,1411,1,0,0,0,170,
		1413,1,0,0,0,172,1416,1,0,0,0,174,1462,1,0,0,0,176,1474,1,0,0,0,178,1489,
		1,0,0,0,180,1496,1,0,0,0,182,1501,1,0,0,0,184,1505,1,0,0,0,186,1541,1,
		0,0,0,188,1543,1,0,0,0,190,1579,1,0,0,0,192,1591,1,0,0,0,194,1605,1,0,
		0,0,196,1607,1,0,0,0,198,1617,1,0,0,0,200,1628,1,0,0,0,202,1635,1,0,0,
		0,204,1645,1,0,0,0,206,1658,1,0,0,0,208,1663,1,0,0,0,210,1666,1,0,0,0,
		212,1677,1,0,0,0,214,1682,1,0,0,0,216,1688,1,0,0,0,218,1690,1,0,0,0,220,
		1812,1,0,0,0,222,1814,1,0,0,0,224,1851,1,0,0,0,226,1858,1,0,0,0,228,1863,
		1,0,0,0,230,1870,1,0,0,0,232,1890,1,0,0,0,234,1892,1,0,0,0,236,1897,1,
		0,0,0,238,1912,1,0,0,0,240,1914,1,0,0,0,242,1927,1,0,0,0,244,1932,1,0,
		0,0,246,1945,1,0,0,0,248,1953,1,0,0,0,250,1964,1,0,0,0,252,1969,1,0,0,
		0,254,1985,1,0,0,0,256,1987,1,0,0,0,258,2031,1,0,0,0,260,2051,1,0,0,0,
		262,2080,1,0,0,0,264,2085,1,0,0,0,266,2108,1,0,0,0,268,2113,1,0,0,0,270,
		2224,1,0,0,0,272,2226,1,0,0,0,274,2231,1,0,0,0,276,2233,1,0,0,0,278,2237,
		1,0,0,0,280,2241,1,0,0,0,282,2257,1,0,0,0,284,2271,1,0,0,0,286,2279,1,
		0,0,0,288,2281,1,0,0,0,290,2284,1,0,0,0,292,2286,1,0,0,0,294,2299,1,0,
		0,0,296,2301,1,0,0,0,298,2311,1,0,0,0,300,2316,1,0,0,0,302,2327,1,0,0,
		0,304,2334,1,0,0,0,306,2344,1,0,0,0,308,2412,1,0,0,0,310,2489,1,0,0,0,
		312,2494,1,0,0,0,314,2497,1,0,0,0,316,2502,1,0,0,0,318,2652,1,0,0,0,320,
		2658,1,0,0,0,322,2665,1,0,0,0,324,2671,1,0,0,0,326,2677,1,0,0,0,328,2683,
		1,0,0,0,330,2689,1,0,0,0,332,2695,1,0,0,0,334,2701,1,0,0,0,336,2707,1,
		0,0,0,338,2714,1,0,0,0,340,2719,1,0,0,0,342,2725,1,0,0,0,344,2752,1,0,
		0,0,346,2766,1,0,0,0,348,2771,1,0,0,0,350,2788,1,0,0,0,352,2790,1,0,0,
		0,354,2800,1,0,0,0,356,2824,1,0,0,0,358,2829,1,0,0,0,360,2845,1,0,0,0,
		362,2866,1,0,0,0,364,2868,1,0,0,0,366,2873,1,0,0,0,368,2886,1,0,0,0,370,
		371,7,0,0,0,371,1,1,0,0,0,372,383,5,287,0,0,373,374,3,4,2,0,374,375,5,
		264,0,0,375,377,1,0,0,0,376,373,1,0,0,0,377,380,1,0,0,0,378,376,1,0,0,
		0,378,379,1,0,0,0,379,381,1,0,0,0,380,378,1,0,0,0,381,383,3,4,2,0,382,
		372,1,0,0,0,382,378,1,0,0,0,383,3,1,0,0,0,384,385,7,1,0,0,385,5,1,0,0,
		0,386,387,5,262,0,0,387,389,5,265,0,0,388,386,1,0,0,0,389,392,1,0,0,0,
		390,388,1,0,0,0,390,391,1,0,0,0,391,393,1,0,0,0,392,390,1,0,0,0,393,394,
		5,262,0,0,394,7,1,0,0,0,395,397,3,10,5,0,396,395,1,0,0,0,397,400,1,0,0,
		0,398,396,1,0,0,0,398,399,1,0,0,0,399,9,1,0,0,0,400,398,1,0,0,0,401,402,
		3,74,37,0,402,403,5,16,0,0,403,404,3,82,41,0,404,405,5,17,0,0,405,452,
		1,0,0,0,406,407,3,72,36,0,407,408,5,16,0,0,408,409,3,8,4,0,409,410,5,17,
		0,0,410,452,1,0,0,0,411,412,3,256,128,0,412,413,5,16,0,0,413,414,3,268,
		134,0,414,415,5,17,0,0,415,452,1,0,0,0,416,452,3,222,111,0,417,452,3,296,
		148,0,418,452,3,70,35,0,419,452,3,66,33,0,420,452,3,88,44,0,421,452,3,
		90,45,0,422,452,3,22,11,0,423,424,3,346,173,0,424,425,5,16,0,0,425,426,
		3,348,174,0,426,427,5,17,0,0,427,452,1,0,0,0,428,429,3,352,176,0,429,430,
		5,16,0,0,430,431,3,358,179,0,431,432,5,17,0,0,432,452,1,0,0,0,433,434,
		3,362,181,0,434,435,5,16,0,0,435,436,3,366,183,0,436,437,5,17,0,0,437,
		452,1,0,0,0,438,452,3,64,32,0,439,452,3,174,87,0,440,452,3,342,171,0,441,
		452,3,12,6,0,442,452,3,14,7,0,443,452,3,16,8,0,444,452,3,18,9,0,445,452,
		3,20,10,0,446,452,3,26,13,0,447,452,3,42,21,0,448,452,3,40,20,0,449,452,
		3,30,15,0,450,452,3,24,12,0,451,401,1,0,0,0,451,406,1,0,0,0,451,411,1,
		0,0,0,451,416,1,0,0,0,451,417,1,0,0,0,451,418,1,0,0,0,451,419,1,0,0,0,
		451,420,1,0,0,0,451,421,1,0,0,0,451,422,1,0,0,0,451,423,1,0,0,0,451,428,
		1,0,0,0,451,433,1,0,0,0,451,438,1,0,0,0,451,439,1,0,0,0,451,440,1,0,0,
		0,451,441,1,0,0,0,451,442,1,0,0,0,451,443,1,0,0,0,451,444,1,0,0,0,451,
		445,1,0,0,0,451,446,1,0,0,0,451,447,1,0,0,0,451,448,1,0,0,0,451,449,1,
		0,0,0,451,450,1,0,0,0,452,11,1,0,0,0,453,454,5,18,0,0,454,455,3,32,16,
		0,455,13,1,0,0,0,456,457,5,19,0,0,457,458,3,32,16,0,458,15,1,0,0,0,459,
		460,5,20,0,0,460,461,5,21,0,0,461,462,3,32,16,0,462,17,1,0,0,0,463,464,
		5,22,0,0,464,465,3,34,17,0,465,19,1,0,0,0,466,467,5,23,0,0,467,468,3,34,
		17,0,468,21,1,0,0,0,469,470,5,24,0,0,470,471,3,98,49,0,471,472,3,2,1,0,
		472,473,5,16,0,0,473,474,3,142,71,0,474,475,5,17,0,0,475,23,1,0,0,0,476,
		477,5,25,0,0,477,25,1,0,0,0,478,479,5,26,0,0,479,493,3,28,14,0,480,481,
		5,26,0,0,481,482,3,28,14,0,482,483,5,27,0,0,483,484,3,28,14,0,484,493,
		1,0,0,0,485,486,5,26,0,0,486,487,3,28,14,0,487,488,5,27,0,0,488,489,3,
		28,14,0,489,490,5,27,0,0,490,491,3,28,14,0,491,493,1,0,0,0,492,478,1,0,
		0,0,492,480,1,0,0,0,492,485,1,0,0,0,493,27,1,0,0,0,494,495,7,2,0,0,495,
		29,1,0,0,0,496,497,5,28,0,0,497,501,5,16,0,0,498,500,3,138,69,0,499,498,
		1,0,0,0,500,503,1,0,0,0,501,499,1,0,0,0,501,502,1,0,0,0,502,504,1,0,0,
		0,503,501,1,0,0,0,504,505,5,17,0,0,505,31,1,0,0,0,506,507,5,172,0,0,507,
		33,1,0,0,0,508,509,7,3,0,0,509,35,1,0,0,0,510,526,5,174,0,0,511,512,3,
		32,16,0,512,513,5,264,0,0,513,526,1,0,0,0,514,526,3,32,16,0,515,516,5,
		187,0,0,516,517,5,29,0,0,517,518,3,32,16,0,518,519,5,30,0,0,519,526,1,
		0,0,0,520,521,5,188,0,0,521,522,5,29,0,0,522,523,3,34,17,0,523,524,5,30,
		0,0,524,526,1,0,0,0,525,510,1,0,0,0,525,511,1,0,0,0,525,514,1,0,0,0,525,
		515,1,0,0,0,525,520,1,0,0,0,526,37,1,0,0,0,527,530,3,32,16,0,528,530,5,
		261,0,0,529,527,1,0,0,0,529,528,1,0,0,0,530,39,1,0,0,0,531,532,5,266,0,
		0,532,548,5,288,0,0,533,534,5,266,0,0,534,535,5,288,0,0,535,548,5,262,
		0,0,536,537,5,267,0,0,537,548,5,288,0,0,538,539,5,268,0,0,539,548,5,288,
		0,0,540,541,5,269,0,0,541,548,5,288,0,0,542,548,5,270,0,0,543,548,5,271,
		0,0,544,545,5,272,0,0,545,548,5,262,0,0,546,548,5,31,0,0,547,531,1,0,0,
		0,547,533,1,0,0,0,547,536,1,0,0,0,547,538,1,0,0,0,547,540,1,0,0,0,547,
		542,1,0,0,0,547,543,1,0,0,0,547,544,1,0,0,0,547,546,1,0,0,0,548,41,1,0,
		0,0,549,550,5,32,0,0,550,551,3,160,80,0,551,552,5,33,0,0,552,553,3,2,1,
		0,553,575,1,0,0,0,554,555,5,32,0,0,555,556,3,138,69,0,556,557,5,33,0,0,
		557,558,3,2,1,0,558,575,1,0,0,0,559,560,5,32,0,0,560,561,3,198,99,0,561,
		562,5,33,0,0,562,563,3,2,1,0,563,575,1,0,0,0,564,565,5,32,0,0,565,566,
		3,44,22,0,566,567,5,33,0,0,567,568,3,2,1,0,568,575,1,0,0,0,569,570,5,32,
		0,0,570,571,3,46,23,0,571,572,5,33,0,0,572,573,3,2,1,0,573,575,1,0,0,0,
		574,549,1,0,0,0,574,554,1,0,0,0,574,559,1,0,0,0,574,564,1,0,0,0,574,569,
		1,0,0,0,575,43,1,0,0,0,576,577,5,34,0,0,577,598,3,48,24,0,578,579,5,34,
		0,0,579,580,3,48,24,0,580,581,5,35,0,0,581,582,3,6,3,0,582,598,1,0,0,0,
		583,584,5,34,0,0,584,585,3,48,24,0,585,586,5,35,0,0,586,587,5,16,0,0,587,
		588,3,52,26,0,588,589,5,17,0,0,589,598,1,0,0,0,590,591,5,34,0,0,591,592,
		3,48,24,0,592,593,5,35,0,0,593,594,5,29,0,0,594,595,3,312,156,0,595,596,
		5,30,0,0,596,598,1,0,0,0,597,576,1,0,0,0,597,578,1,0,0,0,597,583,1,0,0,
		0,597,590,1,0,0,0,598,45,1,0,0,0,599,600,5,34,0,0,600,601,5,29,0,0,601,
		602,3,50,25,0,602,603,5,30,0,0,603,604,3,48,24,0,604,634,1,0,0,0,605,606,
		5,34,0,0,606,607,5,29,0,0,607,608,3,50,25,0,608,609,5,30,0,0,609,610,3,
		48,24,0,610,611,5,35,0,0,611,612,3,6,3,0,612,634,1,0,0,0,613,614,5,34,
		0,0,614,615,5,29,0,0,615,616,3,50,25,0,616,617,5,30,0,0,617,618,3,48,24,
		0,618,619,5,35,0,0,619,620,5,16,0,0,620,621,3,52,26,0,621,622,5,17,0,0,
		622,634,1,0,0,0,623,624,5,34,0,0,624,625,5,29,0,0,625,626,3,50,25,0,626,
		627,5,30,0,0,627,628,3,48,24,0,628,629,5,35,0,0,629,630,5,29,0,0,630,631,
		3,312,156,0,631,632,5,30,0,0,632,634,1,0,0,0,633,599,1,0,0,0,633,605,1,
		0,0,0,633,613,1,0,0,0,633,623,1,0,0,0,634,47,1,0,0,0,635,636,3,190,95,
		0,636,49,1,0,0,0,637,640,3,146,73,0,638,640,3,198,99,0,639,637,1,0,0,0,
		639,638,1,0,0,0,640,51,1,0,0,0,641,642,3,54,27,0,642,643,3,56,28,0,643,
		53,1,0,0,0,644,647,3,318,159,0,645,647,3,40,20,0,646,644,1,0,0,0,646,645,
		1,0,0,0,647,650,1,0,0,0,648,646,1,0,0,0,648,649,1,0,0,0,649,55,1,0,0,0,
		650,648,1,0,0,0,651,652,3,58,29,0,652,653,3,60,30,0,653,654,3,2,1,0,654,
		655,5,35,0,0,655,656,3,318,159,0,656,659,1,0,0,0,657,659,3,40,20,0,658,
		651,1,0,0,0,658,657,1,0,0,0,659,662,1,0,0,0,660,658,1,0,0,0,660,661,1,
		0,0,0,661,57,1,0,0,0,662,660,1,0,0,0,663,664,7,4,0,0,664,59,1,0,0,0,665,
		667,3,62,31,0,666,668,5,260,0,0,667,666,1,0,0,0,667,668,1,0,0,0,668,61,
		1,0,0,0,669,679,3,166,83,0,670,679,3,2,1,0,671,679,5,195,0,0,672,679,5,
		196,0,0,673,674,5,201,0,0,674,675,5,38,0,0,675,679,5,263,0,0,676,677,5,
		201,0,0,677,679,3,138,69,0,678,669,1,0,0,0,678,670,1,0,0,0,678,671,1,0,
		0,0,678,672,1,0,0,0,678,673,1,0,0,0,678,676,1,0,0,0,679,63,1,0,0,0,680,
		681,5,197,0,0,681,682,5,39,0,0,682,687,3,2,1,0,683,684,5,197,0,0,684,687,
		3,2,1,0,685,687,5,197,0,0,686,680,1,0,0,0,686,683,1,0,0,0,686,685,1,0,
		0,0,687,65,1,0,0,0,688,689,5,40,0,0,689,690,5,41,0,0,690,691,3,32,16,0,
		691,692,5,42,0,0,692,693,3,68,34,0,693,694,5,43,0,0,694,695,3,0,0,0,695,
		67,1,0,0,0,696,709,6,34,-1,0,697,698,10,5,0,0,698,708,5,185,0,0,699,700,
		10,4,0,0,700,708,5,186,0,0,701,702,10,3,0,0,702,708,5,44,0,0,703,704,10,
		2,0,0,704,708,5,45,0,0,705,706,10,1,0,0,706,708,5,46,0,0,707,697,1,0,0,
		0,707,699,1,0,0,0,707,701,1,0,0,0,707,703,1,0,0,0,707,705,1,0,0,0,708,
		711,1,0,0,0,709,707,1,0,0,0,709,710,1,0,0,0,710,69,1,0,0,0,711,709,1,0,
		0,0,712,713,5,47,0,0,713,714,5,35,0,0,714,715,5,29,0,0,715,716,3,312,156,
		0,716,717,5,30,0,0,717,71,1,0,0,0,718,719,5,48,0,0,719,720,3,2,1,0,720,
		73,1,0,0,0,721,725,5,49,0,0,722,724,3,76,38,0,723,722,1,0,0,0,724,727,
		1,0,0,0,725,723,1,0,0,0,725,726,1,0,0,0,726,728,1,0,0,0,727,725,1,0,0,
		0,728,729,3,2,1,0,729,730,3,204,102,0,730,731,3,78,39,0,731,732,3,80,40,
		0,732,75,1,0,0,0,733,771,5,50,0,0,734,771,5,51,0,0,735,771,5,198,0,0,736,
		771,5,201,0,0,737,771,5,220,0,0,738,771,5,52,0,0,739,771,5,53,0,0,740,
		771,5,54,0,0,741,771,5,55,0,0,742,771,5,243,0,0,743,771,5,15,0,0,744,771,
		5,223,0,0,745,771,5,56,0,0,746,771,5,57,0,0,747,771,5,58,0,0,748,771,5,
		59,0,0,749,771,5,60,0,0,750,751,5,61,0,0,751,771,5,50,0,0,752,753,5,61,
		0,0,753,771,5,51,0,0,754,755,5,61,0,0,755,771,5,62,0,0,756,757,5,61,0,
		0,757,771,5,63,0,0,758,759,5,61,0,0,759,771,5,64,0,0,760,761,5,61,0,0,
		761,771,5,65,0,0,762,771,5,66,0,0,763,771,5,67,0,0,764,771,5,68,0,0,765,
		766,5,69,0,0,766,767,5,29,0,0,767,768,3,32,16,0,768,769,5,30,0,0,769,771,
		1,0,0,0,770,733,1,0,0,0,770,734,1,0,0,0,770,735,1,0,0,0,770,736,1,0,0,
		0,770,737,1,0,0,0,770,738,1,0,0,0,770,739,1,0,0,0,770,740,1,0,0,0,770,
		741,1,0,0,0,770,742,1,0,0,0,770,743,1,0,0,0,770,744,1,0,0,0,770,745,1,
		0,0,0,770,746,1,0,0,0,770,747,1,0,0,0,770,748,1,0,0,0,770,749,1,0,0,0,
		770,750,1,0,0,0,770,752,1,0,0,0,770,754,1,0,0,0,770,756,1,0,0,0,770,758,
		1,0,0,0,770,760,1,0,0,0,770,762,1,0,0,0,770,763,1,0,0,0,770,764,1,0,0,
		0,770,765,1,0,0,0,771,77,1,0,0,0,772,776,1,0,0,0,773,774,5,70,0,0,774,
		776,3,146,73,0,775,772,1,0,0,0,775,773,1,0,0,0,776,79,1,0,0,0,777,781,
		1,0,0,0,778,779,5,71,0,0,779,781,3,84,42,0,780,777,1,0,0,0,780,778,1,0,
		0,0,781,81,1,0,0,0,782,784,3,220,110,0,783,782,1,0,0,0,784,787,1,0,0,0,
		785,783,1,0,0,0,785,786,1,0,0,0,786,83,1,0,0,0,787,785,1,0,0,0,788,789,
		3,146,73,0,789,790,5,27,0,0,790,792,1,0,0,0,791,788,1,0,0,0,792,795,1,
		0,0,0,793,791,1,0,0,0,793,794,1,0,0,0,794,796,1,0,0,0,795,793,1,0,0,0,
		796,797,3,146,73,0,797,85,1,0,0,0,798,799,7,5,0,0,799,87,1,0,0,0,800,801,
		3,86,43,0,801,802,3,32,16,0,802,803,5,263,0,0,803,904,1,0,0,0,804,805,
		3,86,43,0,805,806,3,32,16,0,806,904,1,0,0,0,807,808,3,86,43,0,808,809,
		3,32,16,0,809,810,5,74,0,0,810,811,3,32,16,0,811,812,5,263,0,0,812,904,
		1,0,0,0,813,814,3,86,43,0,814,815,3,32,16,0,815,816,5,74,0,0,816,817,3,
		32,16,0,817,904,1,0,0,0,818,819,3,86,43,0,819,820,3,32,16,0,820,821,5,
		74,0,0,821,822,3,32,16,0,822,823,5,27,0,0,823,824,3,32,16,0,824,825,5,
		263,0,0,825,904,1,0,0,0,826,827,3,86,43,0,827,828,3,32,16,0,828,829,5,
		74,0,0,829,830,3,32,16,0,830,831,5,27,0,0,831,832,3,32,16,0,832,904,1,
		0,0,0,833,834,3,86,43,0,834,835,3,32,16,0,835,836,5,27,0,0,836,837,3,32,
		16,0,837,838,5,74,0,0,838,839,3,32,16,0,839,840,5,263,0,0,840,904,1,0,
		0,0,841,842,3,86,43,0,842,843,3,32,16,0,843,844,5,27,0,0,844,845,3,32,
		16,0,845,846,5,74,0,0,846,847,3,32,16,0,847,904,1,0,0,0,848,849,3,86,43,
		0,849,850,3,32,16,0,850,851,5,27,0,0,851,852,3,32,16,0,852,853,5,74,0,
		0,853,854,3,32,16,0,854,855,5,27,0,0,855,856,3,32,16,0,856,857,5,263,0,
		0,857,904,1,0,0,0,858,859,3,86,43,0,859,860,3,32,16,0,860,861,5,27,0,0,
		861,862,3,32,16,0,862,863,5,74,0,0,863,864,3,32,16,0,864,865,5,27,0,0,
		865,866,3,32,16,0,866,904,1,0,0,0,867,868,3,86,43,0,868,869,3,32,16,0,
		869,870,5,262,0,0,870,904,1,0,0,0,871,872,3,86,43,0,872,873,3,32,16,0,
		873,874,5,74,0,0,874,875,3,32,16,0,875,876,5,262,0,0,876,904,1,0,0,0,877,
		878,3,86,43,0,878,879,3,32,16,0,879,880,5,74,0,0,880,881,3,32,16,0,881,
		882,5,27,0,0,882,883,3,32,16,0,883,884,5,262,0,0,884,904,1,0,0,0,885,886,
		3,86,43,0,886,887,3,32,16,0,887,888,5,27,0,0,888,889,3,32,16,0,889,890,
		5,74,0,0,890,891,3,32,16,0,891,892,5,262,0,0,892,904,1,0,0,0,893,894,3,
		86,43,0,894,895,3,32,16,0,895,896,5,27,0,0,896,897,3,32,16,0,897,898,5,
		74,0,0,898,899,3,32,16,0,899,900,5,27,0,0,900,901,3,32,16,0,901,902,5,
		262,0,0,902,904,1,0,0,0,903,800,1,0,0,0,903,804,1,0,0,0,903,807,1,0,0,
		0,903,813,1,0,0,0,903,818,1,0,0,0,903,826,1,0,0,0,903,833,1,0,0,0,903,
		841,1,0,0,0,903,848,1,0,0,0,903,858,1,0,0,0,903,867,1,0,0,0,903,871,1,
		0,0,0,903,877,1,0,0,0,903,885,1,0,0,0,903,893,1,0,0,0,904,89,1,0,0,0,905,
		909,5,20,0,0,906,908,3,92,46,0,907,906,1,0,0,0,908,911,1,0,0,0,909,907,
		1,0,0,0,909,910,1,0,0,0,910,912,1,0,0,0,911,909,1,0,0,0,912,913,3,2,1,
		0,913,914,3,94,47,0,914,915,5,179,0,0,915,916,5,35,0,0,916,917,5,29,0,
		0,917,918,3,312,156,0,918,919,5,30,0,0,919,920,3,94,47,0,920,932,1,0,0,
		0,921,925,5,20,0,0,922,924,3,92,46,0,923,922,1,0,0,0,924,927,1,0,0,0,925,
		923,1,0,0,0,925,926,1,0,0,0,926,928,1,0,0,0,927,925,1,0,0,0,928,929,3,
		2,1,0,929,930,3,94,47,0,930,932,1,0,0,0,931,905,1,0,0,0,931,921,1,0,0,
		0,932,91,1,0,0,0,933,934,5,75,0,0,934,93,1,0,0,0,935,938,1,0,0,0,936,938,
		5,297,0,0,937,935,1,0,0,0,937,936,1,0,0,0,938,95,1,0,0,0,939,940,7,6,0,
		0,940,97,1,0,0,0,941,943,3,96,48,0,942,941,1,0,0,0,943,946,1,0,0,0,944,
		942,1,0,0,0,944,945,1,0,0,0,945,99,1,0,0,0,946,944,1,0,0,0,947,948,5,274,
		0,0,948,101,1,0,0,0,949,950,5,275,0,0,950,103,1,0,0,0,951,952,5,276,0,
		0,952,105,1,0,0,0,953,954,5,277,0,0,954,107,1,0,0,0,955,956,5,278,0,0,
		956,109,1,0,0,0,957,958,5,281,0,0,958,111,1,0,0,0,959,960,5,279,0,0,960,
		113,1,0,0,0,961,962,5,285,0,0,962,115,1,0,0,0,963,964,5,283,0,0,964,117,
		1,0,0,0,965,966,5,284,0,0,966,119,1,0,0,0,967,968,5,280,0,0,968,121,1,
		0,0,0,969,970,5,286,0,0,970,123,1,0,0,0,971,972,5,282,0,0,972,125,1,0,
		0,0,973,1053,3,100,50,0,974,975,3,102,51,0,975,976,3,32,16,0,976,1053,
		1,0,0,0,977,978,3,102,51,0,978,979,3,0,0,0,979,1053,1,0,0,0,980,981,3,
		104,52,0,981,982,3,32,16,0,982,1053,1,0,0,0,983,984,3,106,53,0,984,985,
		3,34,17,0,985,1053,1,0,0,0,986,987,3,108,54,0,987,988,3,36,18,0,988,1053,
		1,0,0,0,989,990,3,108,54,0,990,991,3,34,17,0,991,1053,1,0,0,0,992,993,
		3,108,54,0,993,994,5,29,0,0,994,995,3,312,156,0,995,996,5,30,0,0,996,1053,
		1,0,0,0,997,998,3,108,54,0,998,999,5,83,0,0,999,1000,5,29,0,0,1000,1001,
		3,312,156,0,1001,1002,5,30,0,0,1002,1053,1,0,0,0,1003,1004,3,110,55,0,
		1004,1005,3,32,16,0,1005,1053,1,0,0,0,1006,1007,3,110,55,0,1007,1008,3,
		0,0,0,1008,1053,1,0,0,0,1009,1010,3,112,56,0,1010,1011,3,190,95,0,1011,
		1053,1,0,0,0,1012,1013,3,114,57,0,1013,1014,3,200,100,0,1014,1053,1,0,
		0,0,1015,1016,3,114,57,0,1016,1017,3,196,98,0,1017,1053,1,0,0,0,1018,1019,
		3,116,58,0,1019,1020,3,146,73,0,1020,1053,1,0,0,0,1021,1022,3,118,59,0,
		1022,1023,3,6,3,0,1023,1053,1,0,0,0,1024,1025,3,118,59,0,1025,1026,5,223,
		0,0,1026,1027,5,29,0,0,1027,1028,3,6,3,0,1028,1029,5,30,0,0,1029,1053,
		1,0,0,0,1030,1031,3,118,59,0,1031,1032,5,83,0,0,1032,1033,5,29,0,0,1033,
		1034,3,312,156,0,1034,1035,5,30,0,0,1035,1053,1,0,0,0,1036,1037,3,120,
		60,0,1037,1038,3,192,96,0,1038,1039,3,160,80,0,1039,1040,3,134,67,0,1040,
		1053,1,0,0,0,1041,1042,3,122,61,0,1042,1043,3,50,25,0,1043,1053,1,0,0,
		0,1044,1045,3,124,62,0,1045,1046,5,29,0,0,1046,1047,3,128,64,0,1047,1048,
		5,30,0,0,1048,1053,1,0,0,0,1049,1050,3,124,62,0,1050,1051,5,84,0,0,1051,
		1053,1,0,0,0,1052,973,1,0,0,0,1052,974,1,0,0,0,1052,977,1,0,0,0,1052,980,
		1,0,0,0,1052,983,1,0,0,0,1052,986,1,0,0,0,1052,989,1,0,0,0,1052,992,1,
		0,0,0,1052,997,1,0,0,0,1052,1003,1,0,0,0,1052,1006,1,0,0,0,1052,1009,1,
		0,0,0,1052,1012,1,0,0,0,1052,1015,1,0,0,0,1052,1018,1,0,0,0,1052,1021,
		1,0,0,0,1052,1024,1,0,0,0,1052,1030,1,0,0,0,1052,1036,1,0,0,0,1052,1041,
		1,0,0,0,1052,1044,1,0,0,0,1052,1049,1,0,0,0,1053,127,1,0,0,0,1054,1071,
		1,0,0,0,1055,1058,3,0,0,0,1056,1058,3,32,16,0,1057,1055,1,0,0,0,1057,1056,
		1,0,0,0,1058,1059,1,0,0,0,1059,1060,5,27,0,0,1060,1062,1,0,0,0,1061,1057,
		1,0,0,0,1062,1065,1,0,0,0,1063,1061,1,0,0,0,1063,1064,1,0,0,0,1064,1068,
		1,0,0,0,1065,1063,1,0,0,0,1066,1069,3,0,0,0,1067,1069,3,32,16,0,1068,1066,
		1,0,0,0,1068,1067,1,0,0,0,1069,1071,1,0,0,0,1070,1054,1,0,0,0,1070,1063,
		1,0,0,0,1071,129,1,0,0,0,1072,1078,5,85,0,0,1073,1074,3,160,80,0,1074,
		1075,5,27,0,0,1075,1077,1,0,0,0,1076,1073,1,0,0,0,1077,1080,1,0,0,0,1078,
		1076,1,0,0,0,1078,1079,1,0,0,0,1079,1081,1,0,0,0,1080,1078,1,0,0,0,1081,
		1082,3,160,80,0,1082,1083,5,86,0,0,1083,131,1,0,0,0,1084,1090,5,41,0,0,
		1085,1086,3,168,84,0,1086,1087,5,27,0,0,1087,1089,1,0,0,0,1088,1085,1,
		0,0,0,1089,1092,1,0,0,0,1090,1088,1,0,0,0,1090,1091,1,0,0,0,1091,1093,
		1,0,0,0,1092,1090,1,0,0,0,1093,1094,3,168,84,0,1094,1095,5,42,0,0,1095,
		133,1,0,0,0,1096,1102,5,29,0,0,1097,1098,3,136,68,0,1098,1099,5,27,0,0,
		1099,1101,1,0,0,0,1100,1097,1,0,0,0,1101,1104,1,0,0,0,1102,1100,1,0,0,
		0,1102,1103,1,0,0,0,1103,1105,1,0,0,0,1104,1102,1,0,0,0,1105,1106,3,136,
		68,0,1106,1107,5,30,0,0,1107,1110,1,0,0,0,1108,1110,5,84,0,0,1109,1096,
		1,0,0,0,1109,1108,1,0,0,0,1110,135,1,0,0,0,1111,1119,5,176,0,0,1112,1113,
		3,252,126,0,1113,1114,3,160,80,0,1114,1116,3,248,124,0,1115,1117,3,0,0,
		0,1116,1115,1,0,0,0,1116,1117,1,0,0,0,1117,1119,1,0,0,0,1118,1111,1,0,
		0,0,1118,1112,1,0,0,0,1119,137,1,0,0,0,1120,1121,5,41,0,0,1121,1122,3,
		2,1,0,1122,1123,5,42,0,0,1123,1124,3,140,70,0,1124,1146,1,0,0,0,1125,1126,
		5,41,0,0,1126,1127,3,196,98,0,1127,1128,5,42,0,0,1128,1129,3,140,70,0,
		1129,1146,1,0,0,0,1130,1131,5,41,0,0,1131,1132,5,261,0,0,1132,1133,5,42,
		0,0,1133,1146,3,140,70,0,1134,1135,5,41,0,0,1135,1136,5,197,0,0,1136,1137,
		3,2,1,0,1137,1138,5,42,0,0,1138,1139,3,140,70,0,1139,1146,1,0,0,0,1140,
		1146,3,140,70,0,1141,1146,3,196,98,0,1142,1146,5,256,0,0,1143,1146,5,257,
		0,0,1144,1146,5,258,0,0,1145,1120,1,0,0,0,1145,1125,1,0,0,0,1145,1130,
		1,0,0,0,1145,1134,1,0,0,0,1145,1140,1,0,0,0,1145,1141,1,0,0,0,1145,1142,
		1,0,0,0,1145,1143,1,0,0,0,1145,1144,1,0,0,0,1146,139,1,0,0,0,1147,1148,
		3,2,1,0,1148,1149,5,87,0,0,1149,1151,1,0,0,0,1150,1147,1,0,0,0,1151,1154,
		1,0,0,0,1152,1150,1,0,0,0,1152,1153,1,0,0,0,1153,1155,1,0,0,0,1154,1152,
		1,0,0,0,1155,1156,3,2,1,0,1156,141,1,0,0,0,1157,1159,3,144,72,0,1158,1157,
		1,0,0,0,1159,1162,1,0,0,0,1160,1158,1,0,0,0,1160,1161,1,0,0,0,1161,143,
		1,0,0,0,1162,1160,1,0,0,0,1163,1164,5,179,0,0,1164,1165,5,88,0,0,1165,
		1169,3,32,16,0,1166,1169,3,174,87,0,1167,1169,3,344,172,0,1168,1163,1,
		0,0,0,1168,1166,1,0,0,0,1168,1167,1,0,0,0,1169,145,1,0,0,0,1170,1182,3,
		138,69,0,1171,1172,5,41,0,0,1172,1173,3,2,1,0,1173,1174,5,42,0,0,1174,
		1182,1,0,0,0,1175,1176,5,41,0,0,1176,1177,5,197,0,0,1177,1178,3,2,1,0,
		1178,1179,5,42,0,0,1179,1182,1,0,0,0,1180,1182,3,160,80,0,1181,1170,1,
		0,0,0,1181,1171,1,0,0,0,1181,1175,1,0,0,0,1181,1180,1,0,0,0,1182,147,1,
		0,0,0,1183,1192,1,0,0,0,1184,1188,3,152,76,0,1185,1187,3,150,75,0,1186,
		1185,1,0,0,0,1187,1190,1,0,0,0,1188,1186,1,0,0,0,1188,1189,1,0,0,0,1189,
		1192,1,0,0,0,1190,1188,1,0,0,0,1191,1183,1,0,0,0,1191,1184,1,0,0,0,1192,
		149,1,0,0,0,1193,1211,5,261,0,0,1194,1211,5,260,0,0,1195,1196,5,41,0,0,
		1196,1197,3,32,16,0,1197,1198,5,42,0,0,1198,1211,1,0,0,0,1199,1200,5,41,
		0,0,1200,1201,3,32,16,0,1201,1202,5,265,0,0,1202,1203,3,32,16,0,1203,1204,
		5,42,0,0,1204,1211,1,0,0,0,1205,1206,5,41,0,0,1206,1207,5,265,0,0,1207,
		1208,3,32,16,0,1208,1209,5,42,0,0,1209,1211,1,0,0,0,1210,1193,1,0,0,0,
		1210,1194,1,0,0,0,1210,1195,1,0,0,0,1210,1199,1,0,0,0,1210,1205,1,0,0,
		0,1211,151,1,0,0,0,1212,1297,1,0,0,0,1213,1214,5,202,0,0,1214,1215,5,29,
		0,0,1215,1216,3,6,3,0,1216,1217,5,27,0,0,1217,1218,3,6,3,0,1218,1219,5,
		27,0,0,1219,1220,3,6,3,0,1220,1221,5,27,0,0,1221,1222,3,6,3,0,1222,1223,
		5,30,0,0,1223,1297,1,0,0,0,1224,1225,5,202,0,0,1225,1226,5,29,0,0,1226,
		1227,3,6,3,0,1227,1228,5,27,0,0,1228,1229,3,6,3,0,1229,1230,5,30,0,0,1230,
		1297,1,0,0,0,1231,1232,5,203,0,0,1232,1233,5,204,0,0,1233,1234,5,41,0,
		0,1234,1235,3,32,16,0,1235,1236,5,42,0,0,1236,1297,1,0,0,0,1237,1238,5,
		203,0,0,1238,1239,5,205,0,0,1239,1240,5,41,0,0,1240,1241,3,32,16,0,1241,
		1242,5,42,0,0,1242,1243,3,148,74,0,1243,1297,1,0,0,0,1244,1297,5,206,0,
		0,1245,1297,5,207,0,0,1246,1297,5,208,0,0,1247,1297,5,200,0,0,1248,1297,
		5,182,0,0,1249,1297,5,183,0,0,1250,1297,5,184,0,0,1251,1297,5,185,0,0,
		1252,1297,5,186,0,0,1253,1297,5,187,0,0,1254,1297,5,188,0,0,1255,1297,
		5,209,0,0,1256,1297,5,189,0,0,1257,1297,5,190,0,0,1258,1297,5,191,0,0,
		1259,1297,5,192,0,0,1260,1297,5,210,0,0,1261,1297,5,211,0,0,1262,1297,
		5,212,0,0,1263,1297,5,213,0,0,1264,1297,5,214,0,0,1265,1297,5,215,0,0,
		1266,1297,5,216,0,0,1267,1268,5,217,0,0,1268,1297,3,154,77,0,1269,1270,
		5,218,0,0,1270,1297,3,154,77,0,1271,1297,5,219,0,0,1272,1273,5,220,0,0,
		1273,1297,3,154,77,0,1274,1275,5,221,0,0,1275,1297,3,156,78,0,1276,1277,
		5,221,0,0,1277,1278,3,156,78,0,1278,1279,5,27,0,0,1279,1280,3,6,3,0,1280,
		1297,1,0,0,0,1281,1297,5,193,0,0,1282,1297,5,194,0,0,1283,1284,5,61,0,
		0,1284,1297,5,219,0,0,1285,1297,5,222,0,0,1286,1287,5,223,0,0,1287,1297,
		5,212,0,0,1288,1297,5,224,0,0,1289,1290,5,206,0,0,1290,1297,5,182,0,0,
		1291,1297,5,225,0,0,1292,1297,5,227,0,0,1293,1294,5,33,0,0,1294,1297,5,
		226,0,0,1295,1297,3,2,1,0,1296,1212,1,0,0,0,1296,1213,1,0,0,0,1296,1224,
		1,0,0,0,1296,1231,1,0,0,0,1296,1237,1,0,0,0,1296,1244,1,0,0,0,1296,1245,
		1,0,0,0,1296,1246,1,0,0,0,1296,1247,1,0,0,0,1296,1248,1,0,0,0,1296,1249,
		1,0,0,0,1296,1250,1,0,0,0,1296,1251,1,0,0,0,1296,1252,1,0,0,0,1296,1253,
		1,0,0,0,1296,1254,1,0,0,0,1296,1255,1,0,0,0,1296,1256,1,0,0,0,1296,1257,
		1,0,0,0,1296,1258,1,0,0,0,1296,1259,1,0,0,0,1296,1260,1,0,0,0,1296,1261,
		1,0,0,0,1296,1262,1,0,0,0,1296,1263,1,0,0,0,1296,1264,1,0,0,0,1296,1265,
		1,0,0,0,1296,1266,1,0,0,0,1296,1267,1,0,0,0,1296,1269,1,0,0,0,1296,1271,
		1,0,0,0,1296,1272,1,0,0,0,1296,1274,1,0,0,0,1296,1276,1,0,0,0,1296,1281,
		1,0,0,0,1296,1282,1,0,0,0,1296,1283,1,0,0,0,1296,1285,1,0,0,0,1296,1286,
		1,0,0,0,1296,1288,1,0,0,0,1296,1289,1,0,0,0,1296,1291,1,0,0,0,1296,1292,
		1,0,0,0,1296,1293,1,0,0,0,1296,1295,1,0,0,0,1297,153,1,0,0,0,1298,1306,
		1,0,0,0,1299,1300,5,29,0,0,1300,1301,5,89,0,0,1301,1302,5,35,0,0,1302,
		1303,3,32,16,0,1303,1304,5,30,0,0,1304,1306,1,0,0,0,1305,1298,1,0,0,0,
		1305,1299,1,0,0,0,1306,155,1,0,0,0,1307,1316,1,0,0,0,1308,1312,3,158,79,
		0,1309,1311,7,7,0,0,1310,1309,1,0,0,0,1311,1314,1,0,0,0,1312,1310,1,0,
		0,0,1312,1313,1,0,0,0,1313,1316,1,0,0,0,1314,1312,1,0,0,0,1315,1307,1,
		0,0,0,1315,1308,1,0,0,0,1316,157,1,0,0,0,1317,1318,7,8,0,0,1318,159,1,
		0,0,0,1319,1323,3,164,82,0,1320,1322,3,162,81,0,1321,1320,1,0,0,0,1322,
		1325,1,0,0,0,1323,1321,1,0,0,0,1323,1324,1,0,0,0,1324,161,1,0,0,0,1325,
		1323,1,0,0,0,1326,1345,5,260,0,0,1327,1328,5,41,0,0,1328,1345,5,42,0,0,
		1329,1345,3,132,66,0,1330,1345,5,259,0,0,1331,1345,5,261,0,0,1332,1345,
		5,90,0,0,1333,1334,5,91,0,0,1334,1335,5,29,0,0,1335,1336,3,146,73,0,1336,
		1337,5,30,0,0,1337,1345,1,0,0,0,1338,1339,5,92,0,0,1339,1340,5,29,0,0,
		1340,1341,3,146,73,0,1341,1342,5,30,0,0,1342,1345,1,0,0,0,1343,1345,3,
		130,65,0,1344,1326,1,0,0,0,1344,1327,1,0,0,0,1344,1329,1,0,0,0,1344,1330,
		1,0,0,0,1344,1331,1,0,0,0,1344,1332,1,0,0,0,1344,1333,1,0,0,0,1344,1338,
		1,0,0,0,1344,1343,1,0,0,0,1345,163,1,0,0,0,1346,1347,5,38,0,0,1347,1377,
		3,138,69,0,1348,1377,5,196,0,0,1349,1350,5,198,0,0,1350,1351,5,38,0,0,
		1351,1377,3,138,69,0,1352,1353,5,199,0,0,1353,1377,3,138,69,0,1354,1355,
		5,225,0,0,1355,1356,3,192,96,0,1356,1357,3,160,80,0,1357,1358,5,261,0,
		0,1358,1359,3,134,67,0,1359,1377,1,0,0,0,1360,1361,5,252,0,0,1361,1377,
		3,32,16,0,1362,1363,5,251,0,0,1363,1377,3,32,16,0,1364,1365,5,252,0,0,
		1365,1377,3,2,1,0,1366,1367,5,251,0,0,1367,1377,3,2,1,0,1368,1377,5,253,
		0,0,1369,1377,5,200,0,0,1370,1377,3,170,85,0,1371,1377,3,172,86,0,1372,
		1377,3,166,83,0,1373,1377,3,2,1,0,1374,1375,5,176,0,0,1375,1377,3,160,
		80,0,1376,1346,1,0,0,0,1376,1348,1,0,0,0,1376,1349,1,0,0,0,1376,1352,1,
		0,0,0,1376,1354,1,0,0,0,1376,1360,1,0,0,0,1376,1362,1,0,0,0,1376,1364,
		1,0,0,0,1376,1366,1,0,0,0,1376,1368,1,0,0,0,1376,1369,1,0,0,0,1376,1370,
		1,0,0,0,1376,1371,1,0,0,0,1376,1372,1,0,0,0,1376,1373,1,0,0,0,1376,1374,
		1,0,0,0,1377,165,1,0,0,0,1378,1400,5,180,0,0,1379,1400,5,181,0,0,1380,
		1400,5,182,0,0,1381,1400,5,183,0,0,1382,1400,5,184,0,0,1383,1400,5,185,
		0,0,1384,1400,5,186,0,0,1385,1400,5,187,0,0,1386,1400,5,188,0,0,1387,1400,
		5,189,0,0,1388,1400,5,190,0,0,1389,1400,5,191,0,0,1390,1400,5,192,0,0,
		1391,1392,5,93,0,0,1392,1400,5,183,0,0,1393,1394,5,93,0,0,1394,1400,5,
		184,0,0,1395,1396,5,93,0,0,1396,1400,5,185,0,0,1397,1398,5,93,0,0,1398,
		1400,5,186,0,0,1399,1378,1,0,0,0,1399,1379,1,0,0,0,1399,1380,1,0,0,0,1399,
		1381,1,0,0,0,1399,1382,1,0,0,0,1399,1383,1,0,0,0,1399,1384,1,0,0,0,1399,
		1385,1,0,0,0,1399,1386,1,0,0,0,1399,1387,1,0,0,0,1399,1388,1,0,0,0,1399,
		1389,1,0,0,0,1399,1390,1,0,0,0,1399,1391,1,0,0,0,1399,1393,1,0,0,0,1399,
		1395,1,0,0,0,1399,1397,1,0,0,0,1400,167,1,0,0,0,1401,1412,1,0,0,0,1402,
		1412,5,176,0,0,1403,1412,3,32,16,0,1404,1405,3,32,16,0,1405,1406,5,176,
		0,0,1406,1407,3,32,16,0,1407,1412,1,0,0,0,1408,1409,3,32,16,0,1409,1410,
		5,176,0,0,1410,1412,1,0,0,0,1411,1401,1,0,0,0,1411,1402,1,0,0,0,1411,1403,
		1,0,0,0,1411,1404,1,0,0,0,1411,1408,1,0,0,0,1412,169,1,0,0,0,1413,1414,
		5,1,0,0,1414,1415,5,193,0,0,1415,171,1,0,0,0,1416,1420,5,1,0,0,1417,1418,
		5,93,0,0,1418,1421,5,193,0,0,1419,1421,5,194,0,0,1420,1417,1,0,0,0,1420,
		1419,1,0,0,0,1421,173,1,0,0,0,1422,1423,5,293,0,0,1423,1424,3,188,94,0,
		1424,1425,3,146,73,0,1425,1426,5,29,0,0,1426,1427,3,180,90,0,1427,1428,
		5,30,0,0,1428,1463,1,0,0,0,1429,1430,5,293,0,0,1430,1431,3,188,94,0,1431,
		1432,3,146,73,0,1432,1433,5,35,0,0,1433,1434,5,16,0,0,1434,1435,3,52,26,
		0,1435,1436,5,17,0,0,1436,1463,1,0,0,0,1437,1438,5,293,0,0,1438,1439,3,
		188,94,0,1439,1440,3,146,73,0,1440,1463,1,0,0,0,1441,1442,5,294,0,0,1442,
		1443,3,188,94,0,1443,1445,5,35,0,0,1444,1446,5,83,0,0,1445,1444,1,0,0,
		0,1445,1446,1,0,0,0,1446,1447,1,0,0,0,1447,1448,5,29,0,0,1448,1449,3,312,
		156,0,1449,1450,5,30,0,0,1450,1463,1,0,0,0,1451,1452,5,294,0,0,1452,1453,
		3,188,94,0,1453,1454,3,6,3,0,1454,1463,1,0,0,0,1455,1456,5,294,0,0,1456,
		1457,3,188,94,0,1457,1458,5,35,0,0,1458,1459,5,16,0,0,1459,1460,3,176,
		88,0,1460,1461,5,17,0,0,1461,1463,1,0,0,0,1462,1422,1,0,0,0,1462,1429,
		1,0,0,0,1462,1437,1,0,0,0,1462,1441,1,0,0,0,1462,1451,1,0,0,0,1462,1455,
		1,0,0,0,1463,175,1,0,0,0,1464,1475,1,0,0,0,1465,1466,3,178,89,0,1466,1467,
		5,27,0,0,1467,1469,1,0,0,0,1468,1465,1,0,0,0,1469,1472,1,0,0,0,1470,1468,
		1,0,0,0,1470,1471,1,0,0,0,1471,1473,1,0,0,0,1472,1470,1,0,0,0,1473,1475,
		3,178,89,0,1474,1464,1,0,0,0,1474,1470,1,0,0,0,1475,177,1,0,0,0,1476,1477,
		5,38,0,0,1477,1478,5,263,0,0,1478,1479,5,35,0,0,1479,1480,5,16,0,0,1480,
		1481,3,56,28,0,1481,1482,5,17,0,0,1482,1490,1,0,0,0,1483,1484,3,146,73,
		0,1484,1485,5,35,0,0,1485,1486,5,16,0,0,1486,1487,3,56,28,0,1487,1488,
		5,17,0,0,1488,1490,1,0,0,0,1489,1476,1,0,0,0,1489,1483,1,0,0,0,1490,179,
		1,0,0,0,1491,1492,3,182,91,0,1492,1493,5,27,0,0,1493,1495,1,0,0,0,1494,
		1491,1,0,0,0,1495,1498,1,0,0,0,1496,1494,1,0,0,0,1496,1497,1,0,0,0,1497,
		1499,1,0,0,0,1498,1496,1,0,0,0,1499,1500,3,182,91,0,1500,181,1,0,0,0,1501,
		1502,3,6,3,0,1502,1503,5,35,0,0,1503,1504,3,186,93,0,1504,183,1,0,0,0,
		1505,1506,7,9,0,0,1506,185,1,0,0,0,1507,1542,3,184,92,0,1508,1542,3,32,
		16,0,1509,1510,5,185,0,0,1510,1511,5,29,0,0,1511,1512,3,32,16,0,1512,1513,
		5,30,0,0,1513,1542,1,0,0,0,1514,1542,3,6,3,0,1515,1516,3,138,69,0,1516,
		1517,5,29,0,0,1517,1518,5,183,0,0,1518,1519,5,74,0,0,1519,1520,3,32,16,
		0,1520,1521,5,30,0,0,1521,1542,1,0,0,0,1522,1523,3,138,69,0,1523,1524,
		5,29,0,0,1524,1525,5,184,0,0,1525,1526,5,74,0,0,1526,1527,3,32,16,0,1527,
		1528,5,30,0,0,1528,1542,1,0,0,0,1529,1530,3,138,69,0,1530,1531,5,29,0,
		0,1531,1532,5,185,0,0,1532,1533,5,74,0,0,1533,1534,3,32,16,0,1534,1535,
		5,30,0,0,1535,1542,1,0,0,0,1536,1537,3,138,69,0,1537,1538,5,29,0,0,1538,
		1539,3,32,16,0,1539,1540,5,30,0,0,1540,1542,1,0,0,0,1541,1507,1,0,0,0,
		1541,1508,1,0,0,0,1541,1509,1,0,0,0,1541,1514,1,0,0,0,1541,1515,1,0,0,
		0,1541,1522,1,0,0,0,1541,1529,1,0,0,0,1541,1536,1,0,0,0,1542,187,1,0,0,
		0,1543,1544,7,10,0,0,1544,189,1,0,0,0,1545,1546,3,192,96,0,1546,1547,3,
		160,80,0,1547,1548,3,146,73,0,1548,1549,5,175,0,0,1549,1551,3,264,132,
		0,1550,1552,3,130,65,0,1551,1550,1,0,0,0,1551,1552,1,0,0,0,1552,1553,1,
		0,0,0,1553,1554,3,134,67,0,1554,1580,1,0,0,0,1555,1556,3,192,96,0,1556,
		1557,3,160,80,0,1557,1558,3,146,73,0,1558,1559,5,175,0,0,1559,1560,3,264,
		132,0,1560,1561,3,218,109,0,1561,1562,3,134,67,0,1562,1580,1,0,0,0,1563,
		1564,3,192,96,0,1564,1565,3,160,80,0,1565,1567,3,264,132,0,1566,1568,3,
		130,65,0,1567,1566,1,0,0,0,1567,1568,1,0,0,0,1568,1569,1,0,0,0,1569,1570,
		3,134,67,0,1570,1580,1,0,0,0,1571,1572,3,192,96,0,1572,1573,3,160,80,0,
		1573,1574,3,264,132,0,1574,1575,3,218,109,0,1575,1576,3,134,67,0,1576,
		1580,1,0,0,0,1577,1580,3,196,98,0,1578,1580,3,2,1,0,1579,1545,1,0,0,0,
		1579,1555,1,0,0,0,1579,1563,1,0,0,0,1579,1571,1,0,0,0,1579,1577,1,0,0,
		0,1579,1578,1,0,0,0,1580,191,1,0,0,0,1581,1582,5,242,0,0,1582,1592,3,192,
		96,0,1583,1584,5,243,0,0,1584,1592,3,192,96,0,1585,1592,3,194,97,0,1586,
		1587,5,111,0,0,1587,1588,5,29,0,0,1588,1589,3,32,16,0,1589,1590,5,30,0,
		0,1590,1592,1,0,0,0,1591,1581,1,0,0,0,1591,1583,1,0,0,0,1591,1585,1,0,
		0,0,1591,1586,1,0,0,0,1592,193,1,0,0,0,1593,1606,1,0,0,0,1594,1606,5,244,
		0,0,1595,1606,5,245,0,0,1596,1597,5,246,0,0,1597,1606,5,247,0,0,1598,1599,
		5,246,0,0,1599,1606,5,248,0,0,1600,1601,5,246,0,0,1601,1606,5,249,0,0,
		1602,1603,5,246,0,0,1603,1606,5,250,0,0,1604,1606,5,246,0,0,1605,1593,
		1,0,0,0,1605,1594,1,0,0,0,1605,1595,1,0,0,0,1605,1596,1,0,0,0,1605,1598,
		1,0,0,0,1605,1600,1,0,0,0,1605,1602,1,0,0,0,1605,1604,1,0,0,0,1606,195,
		1,0,0,0,1607,1608,5,112,0,0,1608,1609,5,29,0,0,1609,1610,3,32,16,0,1610,
		1611,5,30,0,0,1611,197,1,0,0,0,1612,1613,5,225,0,0,1613,1618,3,190,95,
		0,1614,1615,5,36,0,0,1615,1618,3,200,100,0,1616,1618,3,196,98,0,1617,1612,
		1,0,0,0,1617,1614,1,0,0,0,1617,1616,1,0,0,0,1618,199,1,0,0,0,1619,1620,
		3,160,80,0,1620,1621,3,146,73,0,1621,1622,5,175,0,0,1622,1623,3,2,1,0,
		1623,1629,1,0,0,0,1624,1625,3,160,80,0,1625,1626,3,2,1,0,1626,1629,1,0,
		0,0,1627,1629,3,2,1,0,1628,1619,1,0,0,0,1628,1624,1,0,0,0,1628,1627,1,
		0,0,0,1629,201,1,0,0,0,1630,1631,3,146,73,0,1631,1632,5,27,0,0,1632,1634,
		1,0,0,0,1633,1630,1,0,0,0,1634,1637,1,0,0,0,1635,1633,1,0,0,0,1635,1636,
		1,0,0,0,1636,1638,1,0,0,0,1637,1635,1,0,0,0,1638,1639,3,146,73,0,1639,
		203,1,0,0,0,1640,1646,1,0,0,0,1641,1642,5,85,0,0,1642,1643,3,212,106,0,
		1643,1644,5,86,0,0,1644,1646,1,0,0,0,1645,1640,1,0,0,0,1645,1641,1,0,0,
		0,1646,205,1,0,0,0,1647,1659,5,265,0,0,1648,1659,5,113,0,0,1649,1659,5,
		38,0,0,1650,1659,5,199,0,0,1651,1659,5,114,0,0,1652,1659,5,115,0,0,1653,
		1654,5,69,0,0,1654,1655,5,29,0,0,1655,1656,3,32,16,0,1656,1657,5,30,0,
		0,1657,1659,1,0,0,0,1658,1647,1,0,0,0,1658,1648,1,0,0,0,1658,1649,1,0,
		0,0,1658,1650,1,0,0,0,1658,1651,1,0,0,0,1658,1652,1,0,0,0,1658,1653,1,
		0,0,0,1659,207,1,0,0,0,1660,1662,3,206,103,0,1661,1660,1,0,0,0,1662,1665,
		1,0,0,0,1663,1661,1,0,0,0,1663,1664,1,0,0,0,1664,209,1,0,0,0,1665,1663,
		1,0,0,0,1666,1668,3,208,104,0,1667,1669,3,214,107,0,1668,1667,1,0,0,0,
		1668,1669,1,0,0,0,1669,1670,1,0,0,0,1670,1671,3,2,1,0,1671,211,1,0,0,0,
		1672,1673,3,210,105,0,1673,1674,5,27,0,0,1674,1676,1,0,0,0,1675,1672,1,
		0,0,0,1676,1679,1,0,0,0,1677,1675,1,0,0,0,1677,1678,1,0,0,0,1678,1680,
		1,0,0,0,1679,1677,1,0,0,0,1680,1681,3,210,105,0,1681,213,1,0,0,0,1682,
		1683,5,29,0,0,1683,1684,3,202,101,0,1684,1685,5,30,0,0,1685,215,1,0,0,
		0,1686,1689,1,0,0,0,1687,1689,3,218,109,0,1688,1686,1,0,0,0,1688,1687,
		1,0,0,0,1689,217,1,0,0,0,1690,1691,5,85,0,0,1691,1692,5,41,0,0,1692,1693,
		3,32,16,0,1693,1694,5,42,0,0,1694,1695,5,86,0,0,1695,219,1,0,0,0,1696,
		1697,3,256,128,0,1697,1698,5,16,0,0,1698,1699,3,268,134,0,1699,1700,5,
		17,0,0,1700,1813,1,0,0,0,1701,1702,3,74,37,0,1702,1703,5,16,0,0,1703,1704,
		3,82,41,0,1704,1705,5,17,0,0,1705,1813,1,0,0,0,1706,1707,3,232,116,0,1707,
		1708,5,16,0,0,1708,1709,3,236,118,0,1709,1710,5,17,0,0,1710,1813,1,0,0,
		0,1711,1712,3,240,120,0,1712,1713,5,16,0,0,1713,1714,3,244,122,0,1714,
		1715,5,17,0,0,1715,1813,1,0,0,0,1716,1813,3,222,111,0,1717,1813,3,296,
		148,0,1718,1813,3,174,87,0,1719,1813,3,88,44,0,1720,1813,3,342,171,0,1721,
		1722,5,116,0,0,1722,1813,3,32,16,0,1723,1724,5,117,0,0,1724,1813,3,32,
		16,0,1725,1726,3,354,177,0,1726,1727,5,16,0,0,1727,1728,3,358,179,0,1728,
		1729,5,17,0,0,1729,1813,1,0,0,0,1730,1731,5,301,0,0,1731,1732,3,146,73,
		0,1732,1733,5,175,0,0,1733,1734,3,264,132,0,1734,1735,5,118,0,0,1735,1736,
		3,192,96,0,1736,1737,3,160,80,0,1737,1738,3,146,73,0,1738,1739,5,175,0,
		0,1739,1740,3,264,132,0,1740,1741,3,134,67,0,1741,1813,1,0,0,0,1742,1743,
		5,301,0,0,1743,1744,5,225,0,0,1744,1745,3,192,96,0,1745,1746,3,160,80,
		0,1746,1747,3,146,73,0,1747,1748,5,175,0,0,1748,1749,3,264,132,0,1749,
		1750,3,216,108,0,1750,1751,3,134,67,0,1751,1752,5,118,0,0,1752,1753,5,
		225,0,0,1753,1754,3,192,96,0,1754,1755,3,160,80,0,1755,1756,3,146,73,0,
		1756,1757,5,175,0,0,1757,1758,3,264,132,0,1758,1759,3,216,108,0,1759,1760,
		3,134,67,0,1760,1813,1,0,0,0,1761,1813,3,26,13,0,1762,1813,3,40,20,0,1763,
		1764,5,254,0,0,1764,1765,5,195,0,0,1765,1766,5,41,0,0,1766,1767,3,32,16,
		0,1767,1771,5,42,0,0,1768,1770,3,342,171,0,1769,1768,1,0,0,0,1770,1773,
		1,0,0,0,1771,1769,1,0,0,0,1771,1772,1,0,0,0,1772,1813,1,0,0,0,1773,1771,
		1,0,0,0,1774,1775,5,254,0,0,1775,1776,5,195,0,0,1776,1780,3,2,1,0,1777,
		1779,3,342,171,0,1778,1777,1,0,0,0,1779,1782,1,0,0,0,1780,1778,1,0,0,0,
		1780,1781,1,0,0,0,1781,1813,1,0,0,0,1782,1780,1,0,0,0,1783,1784,5,254,
		0,0,1784,1785,5,255,0,0,1785,1786,5,41,0,0,1786,1787,3,32,16,0,1787,1788,
		5,42,0,0,1788,1789,5,27,0,0,1789,1793,3,146,73,0,1790,1792,3,342,171,0,
		1791,1790,1,0,0,0,1792,1795,1,0,0,0,1793,1791,1,0,0,0,1793,1794,1,0,0,
		0,1794,1813,1,0,0,0,1795,1793,1,0,0,0,1796,1797,5,254,0,0,1797,1798,5,
		255,0,0,1798,1799,3,2,1,0,1799,1800,5,27,0,0,1800,1804,3,146,73,0,1801,
		1803,3,342,171,0,1802,1801,1,0,0,0,1803,1806,1,0,0,0,1804,1802,1,0,0,0,
		1804,1805,1,0,0,0,1805,1813,1,0,0,0,1806,1804,1,0,0,0,1807,1808,5,119,
		0,0,1808,1809,5,195,0,0,1809,1810,3,146,73,0,1810,1811,3,44,22,0,1811,
		1813,1,0,0,0,1812,1696,1,0,0,0,1812,1701,1,0,0,0,1812,1706,1,0,0,0,1812,
		1711,1,0,0,0,1812,1716,1,0,0,0,1812,1717,1,0,0,0,1812,1718,1,0,0,0,1812,
		1719,1,0,0,0,1812,1720,1,0,0,0,1812,1721,1,0,0,0,1812,1723,1,0,0,0,1812,
		1725,1,0,0,0,1812,1730,1,0,0,0,1812,1742,1,0,0,0,1812,1761,1,0,0,0,1812,
		1762,1,0,0,0,1812,1763,1,0,0,0,1812,1774,1,0,0,0,1812,1783,1,0,0,0,1812,
		1796,1,0,0,0,1812,1807,1,0,0,0,1813,221,1,0,0,0,1814,1815,5,120,0,0,1815,
		1824,3,230,115,0,1816,1823,3,224,112,0,1817,1818,5,121,0,0,1818,1819,5,
		29,0,0,1819,1820,3,250,125,0,1820,1821,5,30,0,0,1821,1823,1,0,0,0,1822,
		1816,1,0,0,0,1822,1817,1,0,0,0,1823,1826,1,0,0,0,1824,1822,1,0,0,0,1824,
		1825,1,0,0,0,1825,1827,1,0,0,0,1826,1824,1,0,0,0,1827,1828,3,160,80,0,
		1828,1829,3,2,1,0,1829,1830,3,226,113,0,1830,1831,3,228,114,0,1831,223,
		1,0,0,0,1832,1852,5,122,0,0,1833,1852,5,50,0,0,1834,1852,5,51,0,0,1835,
		1852,5,62,0,0,1836,1852,5,123,0,0,1837,1852,5,68,0,0,1838,1852,5,67,0,
		0,1839,1852,5,63,0,0,1840,1852,5,64,0,0,1841,1852,5,65,0,0,1842,1852,5,
		124,0,0,1843,1852,5,125,0,0,1844,1852,5,126,0,0,1845,1852,5,127,0,0,1846,
		1847,5,69,0,0,1847,1848,5,29,0,0,1848,1849,3,32,16,0,1849,1850,5,30,0,
		0,1850,1852,1,0,0,0,1851,1832,1,0,0,0,1851,1833,1,0,0,0,1851,1834,1,0,
		0,0,1851,1835,1,0,0,0,1851,1836,1,0,0,0,1851,1837,1,0,0,0,1851,1838,1,
		0,0,0,1851,1839,1,0,0,0,1851,1840,1,0,0,0,1851,1841,1,0,0,0,1851,1842,
		1,0,0,0,1851,1843,1,0,0,0,1851,1844,1,0,0,0,1851,1845,1,0,0,0,1851,1846,
		1,0,0,0,1852,225,1,0,0,0,1853,1859,1,0,0,0,1854,1855,5,43,0,0,1855,1859,
		3,0,0,0,1856,1857,5,43,0,0,1857,1859,3,32,16,0,1858,1853,1,0,0,0,1858,
		1854,1,0,0,0,1858,1856,1,0,0,0,1859,227,1,0,0,0,1860,1864,1,0,0,0,1861,
		1862,5,35,0,0,1862,1864,3,316,158,0,1863,1860,1,0,0,0,1863,1861,1,0,0,
		0,1864,229,1,0,0,0,1865,1871,1,0,0,0,1866,1867,5,41,0,0,1867,1868,3,32,
		16,0,1868,1869,5,42,0,0,1869,1871,1,0,0,0,1870,1865,1,0,0,0,1870,1866,
		1,0,0,0,1871,231,1,0,0,0,1872,1876,5,128,0,0,1873,1875,3,234,117,0,1874,
		1873,1,0,0,0,1875,1878,1,0,0,0,1876,1874,1,0,0,0,1876,1877,1,0,0,0,1877,
		1879,1,0,0,0,1878,1876,1,0,0,0,1879,1880,3,146,73,0,1880,1881,3,2,1,0,
		1881,1891,1,0,0,0,1882,1886,5,128,0,0,1883,1885,3,234,117,0,1884,1883,
		1,0,0,0,1885,1888,1,0,0,0,1886,1884,1,0,0,0,1886,1887,1,0,0,0,1887,1889,
		1,0,0,0,1888,1886,1,0,0,0,1889,1891,3,2,1,0,1890,1872,1,0,0,0,1890,1882,
		1,0,0,0,1891,233,1,0,0,0,1892,1893,7,11,0,0,1893,235,1,0,0,0,1894,1896,
		3,238,119,0,1895,1894,1,0,0,0,1896,1899,1,0,0,0,1897,1895,1,0,0,0,1897,
		1898,1,0,0,0,1898,237,1,0,0,0,1899,1897,1,0,0,0,1900,1901,5,129,0,0,1901,
		1913,3,190,95,0,1902,1903,5,130,0,0,1903,1913,3,190,95,0,1904,1905,5,131,
		0,0,1905,1913,3,190,95,0,1906,1907,5,132,0,0,1907,1913,3,190,95,0,1908,
		1913,3,88,44,0,1909,1913,3,342,171,0,1910,1913,3,26,13,0,1911,1913,3,40,
		20,0,1912,1900,1,0,0,0,1912,1902,1,0,0,0,1912,1904,1,0,0,0,1912,1906,1,
		0,0,0,1912,1908,1,0,0,0,1912,1909,1,0,0,0,1912,1910,1,0,0,0,1912,1911,
		1,0,0,0,1913,239,1,0,0,0,1914,1918,5,133,0,0,1915,1917,3,242,121,0,1916,
		1915,1,0,0,0,1917,1920,1,0,0,0,1918,1916,1,0,0,0,1918,1919,1,0,0,0,1919,
		1921,1,0,0,0,1920,1918,1,0,0,0,1921,1922,3,192,96,0,1922,1923,3,160,80,
		0,1923,1924,3,2,1,0,1924,1925,3,134,67,0,1925,1926,3,228,114,0,1926,241,
		1,0,0,0,1927,1928,7,11,0,0,1928,243,1,0,0,0,1929,1931,3,246,123,0,1930,
		1929,1,0,0,0,1931,1934,1,0,0,0,1932,1930,1,0,0,0,1932,1933,1,0,0,0,1933,
		245,1,0,0,0,1934,1932,1,0,0,0,1935,1936,5,134,0,0,1936,1946,3,190,95,0,
		1937,1938,5,135,0,0,1938,1946,3,190,95,0,1939,1940,5,132,0,0,1940,1946,
		3,190,95,0,1941,1946,3,342,171,0,1942,1946,3,88,44,0,1943,1946,3,26,13,
		0,1944,1946,3,40,20,0,1945,1935,1,0,0,0,1945,1937,1,0,0,0,1945,1939,1,
		0,0,0,1945,1941,1,0,0,0,1945,1942,1,0,0,0,1945,1943,1,0,0,0,1945,1944,
		1,0,0,0,1946,247,1,0,0,0,1947,1954,1,0,0,0,1948,1949,5,121,0,0,1949,1950,
		5,29,0,0,1950,1951,3,250,125,0,1951,1952,5,30,0,0,1952,1954,1,0,0,0,1953,
		1947,1,0,0,0,1953,1948,1,0,0,0,1954,249,1,0,0,0,1955,1965,3,148,74,0,1956,
		1958,5,16,0,0,1957,1959,3,314,157,0,1958,1957,1,0,0,0,1959,1960,1,0,0,
		0,1960,1958,1,0,0,0,1960,1961,1,0,0,0,1961,1962,1,0,0,0,1962,1963,5,17,
		0,0,1963,1965,1,0,0,0,1964,1955,1,0,0,0,1964,1956,1,0,0,0,1965,251,1,0,
		0,0,1966,1968,3,254,127,0,1967,1966,1,0,0,0,1968,1971,1,0,0,0,1969,1967,
		1,0,0,0,1969,1970,1,0,0,0,1970,253,1,0,0,0,1971,1969,1,0,0,0,1972,1973,
		5,41,0,0,1973,1974,5,136,0,0,1974,1986,5,42,0,0,1975,1976,5,41,0,0,1976,
		1977,5,137,0,0,1977,1986,5,42,0,0,1978,1979,5,41,0,0,1979,1980,5,138,0,
		0,1980,1986,5,42,0,0,1981,1982,5,41,0,0,1982,1983,3,32,16,0,1983,1984,
		5,42,0,0,1984,1986,1,0,0,0,1985,1972,1,0,0,0,1985,1975,1,0,0,0,1985,1978,
		1,0,0,0,1985,1981,1,0,0,0,1986,255,1,0,0,0,1987,1992,5,139,0,0,1988,1991,
		3,258,129,0,1989,1991,3,260,130,0,1990,1988,1,0,0,0,1990,1989,1,0,0,0,
		1991,1994,1,0,0,0,1992,1990,1,0,0,0,1992,1993,1,0,0,0,1993,1995,1,0,0,
		0,1994,1992,1,0,0,0,1995,1996,3,192,96,0,1996,1997,3,252,126,0,1997,1998,
		3,160,80,0,1998,1999,3,248,124,0,1999,2000,3,264,132,0,2000,2001,3,204,
		102,0,2001,2005,3,134,67,0,2002,2004,3,266,133,0,2003,2002,1,0,0,0,2004,
		2007,1,0,0,0,2005,2003,1,0,0,0,2005,2006,1,0,0,0,2006,257,1,0,0,0,2007,
		2005,1,0,0,0,2008,2032,5,122,0,0,2009,2032,5,50,0,0,2010,2032,5,51,0,0,
		2011,2032,5,62,0,0,2012,2032,5,140,0,0,2013,2032,5,67,0,0,2014,2032,5,
		141,0,0,2015,2032,5,142,0,0,2016,2032,5,53,0,0,2017,2032,5,63,0,0,2018,
		2032,5,64,0,0,2019,2032,5,65,0,0,2020,2032,5,124,0,0,2021,2032,5,143,0,
		0,2022,2032,5,144,0,0,2023,2032,5,68,0,0,2024,2032,5,145,0,0,2025,2032,
		5,146,0,0,2026,2027,5,69,0,0,2027,2028,5,29,0,0,2028,2029,3,32,16,0,2029,
		2030,5,30,0,0,2030,2032,1,0,0,0,2031,2008,1,0,0,0,2031,2009,1,0,0,0,2031,
		2010,1,0,0,0,2031,2011,1,0,0,0,2031,2012,1,0,0,0,2031,2013,1,0,0,0,2031,
		2014,1,0,0,0,2031,2015,1,0,0,0,2031,2016,1,0,0,0,2031,2017,1,0,0,0,2031,
		2018,1,0,0,0,2031,2019,1,0,0,0,2031,2020,1,0,0,0,2031,2021,1,0,0,0,2031,
		2022,1,0,0,0,2031,2023,1,0,0,0,2031,2024,1,0,0,0,2031,2025,1,0,0,0,2031,
		2026,1,0,0,0,2032,259,1,0,0,0,2033,2034,5,147,0,0,2034,2040,5,29,0,0,2035,
		2038,3,6,3,0,2036,2037,5,33,0,0,2037,2039,3,6,3,0,2038,2036,1,0,0,0,2038,
		2039,1,0,0,0,2039,2041,1,0,0,0,2040,2035,1,0,0,0,2040,2041,1,0,0,0,2041,
		2045,1,0,0,0,2042,2044,3,262,131,0,2043,2042,1,0,0,0,2044,2047,1,0,0,0,
		2045,2043,1,0,0,0,2045,2046,1,0,0,0,2046,2048,1,0,0,0,2047,2045,1,0,0,
		0,2048,2052,5,30,0,0,2049,2050,5,147,0,0,2050,2052,5,84,0,0,2051,2033,
		1,0,0,0,2051,2049,1,0,0,0,2052,261,1,0,0,0,2053,2081,5,148,0,0,2054,2081,
		5,223,0,0,2055,2081,5,56,0,0,2056,2081,5,57,0,0,2057,2081,5,149,0,0,2058,
		2081,5,150,0,0,2059,2081,5,247,0,0,2060,2081,5,248,0,0,2061,2081,5,249,
		0,0,2062,2081,5,250,0,0,2063,2064,5,151,0,0,2064,2065,5,74,0,0,2065,2081,
		5,152,0,0,2066,2067,5,151,0,0,2067,2068,5,74,0,0,2068,2081,5,153,0,0,2069,
		2070,5,154,0,0,2070,2071,5,74,0,0,2071,2081,5,152,0,0,2072,2073,5,154,
		0,0,2073,2074,5,74,0,0,2074,2081,5,153,0,0,2075,2076,5,69,0,0,2076,2077,
		5,29,0,0,2077,2078,3,32,16,0,2078,2079,5,30,0,0,2079,2081,1,0,0,0,2080,
		2053,1,0,0,0,2080,2054,1,0,0,0,2080,2055,1,0,0,0,2080,2056,1,0,0,0,2080,
		2057,1,0,0,0,2080,2058,1,0,0,0,2080,2059,1,0,0,0,2080,2060,1,0,0,0,2080,
		2061,1,0,0,0,2080,2062,1,0,0,0,2080,2063,1,0,0,0,2080,2066,1,0,0,0,2080,
		2069,1,0,0,0,2080,2072,1,0,0,0,2080,2075,1,0,0,0,2081,263,1,0,0,0,2082,
		2086,5,115,0,0,2083,2086,5,155,0,0,2084,2086,3,2,1,0,2085,2082,1,0,0,0,
		2085,2083,1,0,0,0,2085,2084,1,0,0,0,2086,265,1,0,0,0,2087,2109,5,1,0,0,
		2088,2109,5,2,0,0,2089,2109,5,156,0,0,2090,2109,5,3,0,0,2091,2109,5,4,
		0,0,2092,2109,5,246,0,0,2093,2109,5,5,0,0,2094,2109,5,6,0,0,2095,2109,
		5,7,0,0,2096,2109,5,8,0,0,2097,2109,5,9,0,0,2098,2109,5,10,0,0,2099,2109,
		5,11,0,0,2100,2109,5,12,0,0,2101,2109,5,13,0,0,2102,2109,5,14,0,0,2103,
		2104,5,69,0,0,2104,2105,5,29,0,0,2105,2106,3,32,16,0,2106,2107,5,30,0,
		0,2107,2109,1,0,0,0,2108,2087,1,0,0,0,2108,2088,1,0,0,0,2108,2089,1,0,
		0,0,2108,2090,1,0,0,0,2108,2091,1,0,0,0,2108,2092,1,0,0,0,2108,2093,1,
		0,0,0,2108,2094,1,0,0,0,2108,2095,1,0,0,0,2108,2096,1,0,0,0,2108,2097,
		1,0,0,0,2108,2098,1,0,0,0,2108,2099,1,0,0,0,2108,2100,1,0,0,0,2108,2101,
		1,0,0,0,2108,2102,1,0,0,0,2108,2103,1,0,0,0,2109,267,1,0,0,0,2110,2112,
		3,270,135,0,2111,2110,1,0,0,0,2112,2115,1,0,0,0,2113,2111,1,0,0,0,2113,
		2114,1,0,0,0,2114,269,1,0,0,0,2115,2113,1,0,0,0,2116,2225,3,126,63,0,2117,
		2118,5,295,0,0,2118,2225,3,32,16,0,2119,2225,3,278,139,0,2120,2121,5,296,
		0,0,2121,2225,3,32,16,0,2122,2123,5,299,0,0,2123,2225,3,134,67,0,2124,
		2125,5,299,0,0,2125,2126,5,157,0,0,2126,2225,3,134,67,0,2127,2225,5,297,
		0,0,2128,2225,5,298,0,0,2129,2225,3,296,148,0,2130,2225,3,272,136,0,2131,
		2225,3,174,87,0,2132,2225,3,88,44,0,2133,2225,3,26,13,0,2134,2225,3,274,
		137,0,2135,2225,3,40,20,0,2136,2137,5,300,0,0,2137,2138,5,41,0,0,2138,
		2139,3,32,16,0,2139,2140,5,42,0,0,2140,2225,1,0,0,0,2141,2142,5,300,0,
		0,2142,2143,5,41,0,0,2143,2144,3,32,16,0,2144,2145,5,42,0,0,2145,2146,
		5,33,0,0,2146,2147,3,0,0,0,2147,2225,1,0,0,0,2148,2149,5,302,0,0,2149,
		2150,3,32,16,0,2150,2151,5,74,0,0,2151,2152,3,32,16,0,2152,2225,1,0,0,
		0,2153,2154,5,301,0,0,2154,2155,3,146,73,0,2155,2156,5,175,0,0,2156,2157,
		3,264,132,0,2157,2225,1,0,0,0,2158,2159,5,301,0,0,2159,2160,5,225,0,0,
		2160,2161,3,192,96,0,2161,2162,3,160,80,0,2162,2163,3,146,73,0,2163,2164,
		5,175,0,0,2164,2165,3,264,132,0,2165,2166,3,216,108,0,2166,2167,3,134,
		67,0,2167,2225,1,0,0,0,2168,2225,3,276,138,0,2169,2170,5,254,0,0,2170,
		2171,5,195,0,0,2171,2172,5,41,0,0,2172,2173,3,32,16,0,2173,2177,5,42,0,
		0,2174,2176,3,342,171,0,2175,2174,1,0,0,0,2176,2179,1,0,0,0,2177,2175,
		1,0,0,0,2177,2178,1,0,0,0,2178,2225,1,0,0,0,2179,2177,1,0,0,0,2180,2181,
		5,254,0,0,2181,2182,5,195,0,0,2182,2186,3,2,1,0,2183,2185,3,342,171,0,
		2184,2183,1,0,0,0,2185,2188,1,0,0,0,2186,2184,1,0,0,0,2186,2187,1,0,0,
		0,2187,2225,1,0,0,0,2188,2186,1,0,0,0,2189,2190,5,254,0,0,2190,2191,5,
		255,0,0,2191,2192,5,41,0,0,2192,2193,3,32,16,0,2193,2194,5,42,0,0,2194,
		2195,5,27,0,0,2195,2199,3,146,73,0,2196,2198,3,342,171,0,2197,2196,1,0,
		0,0,2198,2201,1,0,0,0,2199,2197,1,0,0,0,2199,2200,1,0,0,0,2200,2225,1,
		0,0,0,2201,2199,1,0,0,0,2202,2203,5,254,0,0,2203,2204,5,255,0,0,2204,2205,
		3,2,1,0,2205,2206,5,27,0,0,2206,2210,3,146,73,0,2207,2209,3,342,171,0,
		2208,2207,1,0,0,0,2209,2212,1,0,0,0,2210,2208,1,0,0,0,2210,2211,1,0,0,
		0,2211,2225,1,0,0,0,2212,2210,1,0,0,0,2213,2214,5,254,0,0,2214,2215,5,
		41,0,0,2215,2216,3,32,16,0,2216,2217,5,42,0,0,2217,2221,3,228,114,0,2218,
		2220,3,342,171,0,2219,2218,1,0,0,0,2220,2223,1,0,0,0,2221,2219,1,0,0,0,
		2221,2222,1,0,0,0,2222,2225,1,0,0,0,2223,2221,1,0,0,0,2224,2116,1,0,0,
		0,2224,2117,1,0,0,0,2224,2119,1,0,0,0,2224,2120,1,0,0,0,2224,2122,1,0,
		0,0,2224,2124,1,0,0,0,2224,2127,1,0,0,0,2224,2128,1,0,0,0,2224,2129,1,
		0,0,0,2224,2130,1,0,0,0,2224,2131,1,0,0,0,2224,2132,1,0,0,0,2224,2133,
		1,0,0,0,2224,2134,1,0,0,0,2224,2135,1,0,0,0,2224,2136,1,0,0,0,2224,2141,
		1,0,0,0,2224,2148,1,0,0,0,2224,2153,1,0,0,0,2224,2158,1,0,0,0,2224,2168,
		1,0,0,0,2224,2169,1,0,0,0,2224,2180,1,0,0,0,2224,2189,1,0,0,0,2224,2202,
		1,0,0,0,2224,2213,1,0,0,0,2225,271,1,0,0,0,2226,2227,3,0,0,0,2227,2228,
		5,74,0,0,2228,273,1,0,0,0,2229,2232,3,44,22,0,2230,2232,3,46,23,0,2231,
		2229,1,0,0,0,2231,2230,1,0,0,0,2232,275,1,0,0,0,2233,2234,5,16,0,0,2234,
		2235,3,268,134,0,2235,2236,5,17,0,0,2236,277,1,0,0,0,2237,2238,3,282,141,
		0,2238,2239,3,280,140,0,2239,279,1,0,0,0,2240,2242,3,284,142,0,2241,2240,
		1,0,0,0,2242,2243,1,0,0,0,2243,2241,1,0,0,0,2243,2244,1,0,0,0,2244,281,
		1,0,0,0,2245,2246,5,158,0,0,2246,2258,3,276,138,0,2247,2248,5,158,0,0,
		2248,2249,3,0,0,0,2249,2250,5,159,0,0,2250,2251,3,0,0,0,2251,2258,1,0,
		0,0,2252,2253,5,158,0,0,2253,2254,3,32,16,0,2254,2255,5,159,0,0,2255,2256,
		3,32,16,0,2256,2258,1,0,0,0,2257,2245,1,0,0,0,2257,2247,1,0,0,0,2257,2252,
		1,0,0,0,2258,283,1,0,0,0,2259,2260,3,288,144,0,2260,2261,3,294,147,0,2261,
		2272,1,0,0,0,2262,2263,3,286,143,0,2263,2264,3,294,147,0,2264,2272,1,0,
		0,0,2265,2266,3,290,145,0,2266,2267,3,294,147,0,2267,2272,1,0,0,0,2268,
		2269,3,292,146,0,2269,2270,3,294,147,0,2270,2272,1,0,0,0,2271,2259,1,0,
		0,0,2271,2262,1,0,0,0,2271,2265,1,0,0,0,2271,2268,1,0,0,0,2272,285,1,0,
		0,0,2273,2274,5,160,0,0,2274,2280,3,276,138,0,2275,2276,5,160,0,0,2276,
		2280,3,0,0,0,2277,2278,5,160,0,0,2278,2280,3,32,16,0,2279,2273,1,0,0,0,
		2279,2275,1,0,0,0,2279,2277,1,0,0,0,2280,287,1,0,0,0,2281,2282,5,161,0,
		0,2282,2283,3,146,73,0,2283,289,1,0,0,0,2284,2285,5,162,0,0,2285,291,1,
		0,0,0,2286,2287,5,163,0,0,2287,293,1,0,0,0,2288,2300,3,276,138,0,2289,
		2290,5,164,0,0,2290,2291,3,0,0,0,2291,2292,5,159,0,0,2292,2293,3,0,0,0,
		2293,2300,1,0,0,0,2294,2295,5,164,0,0,2295,2296,3,32,16,0,2296,2297,5,
		159,0,0,2297,2298,3,32,16,0,2298,2300,1,0,0,0,2299,2288,1,0,0,0,2299,2289,
		1,0,0,0,2299,2294,1,0,0,0,2300,295,1,0,0,0,2301,2302,3,298,149,0,2302,
		2303,3,302,151,0,2303,297,1,0,0,0,2304,2305,5,165,0,0,2305,2306,3,300,
		150,0,2306,2307,3,0,0,0,2307,2308,5,35,0,0,2308,2312,1,0,0,0,2309,2310,
		5,165,0,0,2310,2312,3,300,150,0,2311,2304,1,0,0,0,2311,2309,1,0,0,0,2312,
		299,1,0,0,0,2313,2317,1,0,0,0,2314,2317,5,166,0,0,2315,2317,5,2,0,0,2316,
		2313,1,0,0,0,2316,2314,1,0,0,0,2316,2315,1,0,0,0,2317,301,1,0,0,0,2318,
		2319,5,16,0,0,2319,2320,3,304,152,0,2320,2321,5,17,0,0,2321,2328,1,0,0,
		0,2322,2324,3,308,154,0,2323,2322,1,0,0,0,2324,2325,1,0,0,0,2325,2323,
		1,0,0,0,2325,2326,1,0,0,0,2326,2328,1,0,0,0,2327,2318,1,0,0,0,2327,2323,
		1,0,0,0,2328,303,1,0,0,0,2329,2330,3,308,154,0,2330,2331,5,27,0,0,2331,
		2333,1,0,0,0,2332,2329,1,0,0,0,2333,2336,1,0,0,0,2334,2332,1,0,0,0,2334,
		2335,1,0,0,0,2335,2337,1,0,0,0,2336,2334,1,0,0,0,2337,2338,3,308,154,0,
		2338,305,1,0,0,0,2339,2345,1,0,0,0,2340,2341,5,41,0,0,2341,2342,3,32,16,
		0,2342,2343,5,42,0,0,2343,2345,1,0,0,0,2344,2339,1,0,0,0,2344,2340,1,0,
		0,0,2345,307,1,0,0,0,2346,2347,5,180,0,0,2347,2348,5,261,0,0,2348,2349,
		5,29,0,0,2349,2350,3,6,3,0,2350,2351,5,30,0,0,2351,2413,1,0,0,0,2352,2353,
		5,259,0,0,2353,2354,5,29,0,0,2354,2355,3,0,0,0,2355,2356,5,30,0,0,2356,
		2413,1,0,0,0,2357,2358,5,259,0,0,2358,2413,3,0,0,0,2359,2360,5,83,0,0,
		2360,2361,5,29,0,0,2361,2362,3,312,156,0,2362,2363,5,30,0,0,2363,2413,
		1,0,0,0,2364,2365,5,187,0,0,2365,2366,5,29,0,0,2366,2367,3,36,18,0,2367,
		2368,5,30,0,0,2368,2369,3,306,153,0,2369,2413,1,0,0,0,2370,2371,5,188,
		0,0,2371,2372,5,29,0,0,2372,2373,3,36,18,0,2373,2374,5,30,0,0,2374,2375,
		3,306,153,0,2375,2413,1,0,0,0,2376,2377,5,186,0,0,2377,2378,5,29,0,0,2378,
		2379,3,34,17,0,2379,2380,5,30,0,0,2380,2381,3,306,153,0,2381,2413,1,0,
		0,0,2382,2383,5,185,0,0,2383,2384,5,29,0,0,2384,2385,3,32,16,0,2385,2386,
		5,30,0,0,2386,2387,3,306,153,0,2387,2413,1,0,0,0,2388,2389,5,184,0,0,2389,
		2390,5,29,0,0,2390,2391,3,32,16,0,2391,2392,5,30,0,0,2392,2393,3,306,153,
		0,2393,2413,1,0,0,0,2394,2395,5,183,0,0,2395,2396,5,29,0,0,2396,2397,3,
		32,16,0,2397,2398,5,30,0,0,2398,2399,3,306,153,0,2399,2413,1,0,0,0,2400,
		2401,5,187,0,0,2401,2413,3,306,153,0,2402,2403,5,188,0,0,2403,2413,3,306,
		153,0,2404,2405,5,186,0,0,2405,2413,3,306,153,0,2406,2407,5,185,0,0,2407,
		2413,3,306,153,0,2408,2409,5,184,0,0,2409,2413,3,306,153,0,2410,2411,5,
		183,0,0,2411,2413,3,306,153,0,2412,2346,1,0,0,0,2412,2352,1,0,0,0,2412,
		2357,1,0,0,0,2412,2359,1,0,0,0,2412,2364,1,0,0,0,2412,2370,1,0,0,0,2412,
		2376,1,0,0,0,2412,2382,1,0,0,0,2412,2388,1,0,0,0,2412,2394,1,0,0,0,2412,
		2400,1,0,0,0,2412,2402,1,0,0,0,2412,2404,1,0,0,0,2412,2406,1,0,0,0,2412,
		2408,1,0,0,0,2412,2410,1,0,0,0,2413,309,1,0,0,0,2414,2415,5,187,0,0,2415,
		2416,5,29,0,0,2416,2417,3,36,18,0,2417,2418,5,30,0,0,2418,2490,1,0,0,0,
		2419,2420,5,188,0,0,2420,2421,5,29,0,0,2421,2422,3,36,18,0,2422,2423,5,
		30,0,0,2423,2490,1,0,0,0,2424,2425,5,187,0,0,2425,2426,5,29,0,0,2426,2427,
		3,32,16,0,2427,2428,5,30,0,0,2428,2490,1,0,0,0,2429,2430,5,188,0,0,2430,
		2431,5,29,0,0,2431,2432,3,34,17,0,2432,2433,5,30,0,0,2433,2490,1,0,0,0,
		2434,2435,5,186,0,0,2435,2436,5,29,0,0,2436,2437,3,34,17,0,2437,2438,5,
		30,0,0,2438,2490,1,0,0,0,2439,2440,5,185,0,0,2440,2441,5,29,0,0,2441,2442,
		3,32,16,0,2442,2443,5,30,0,0,2443,2490,1,0,0,0,2444,2445,5,184,0,0,2445,
		2446,5,29,0,0,2446,2447,3,32,16,0,2447,2448,5,30,0,0,2448,2490,1,0,0,0,
		2449,2450,5,183,0,0,2450,2451,5,29,0,0,2451,2452,3,32,16,0,2452,2453,5,
		30,0,0,2453,2490,1,0,0,0,2454,2455,5,192,0,0,2455,2456,5,29,0,0,2456,2457,
		3,34,17,0,2457,2458,5,30,0,0,2458,2490,1,0,0,0,2459,2460,5,191,0,0,2460,
		2461,5,29,0,0,2461,2462,3,32,16,0,2462,2463,5,30,0,0,2463,2490,1,0,0,0,
		2464,2465,5,190,0,0,2465,2466,5,29,0,0,2466,2467,3,32,16,0,2467,2468,5,
		30,0,0,2468,2490,1,0,0,0,2469,2470,5,189,0,0,2470,2471,5,29,0,0,2471,2472,
		3,32,16,0,2472,2473,5,30,0,0,2473,2490,1,0,0,0,2474,2475,5,180,0,0,2475,
		2476,5,29,0,0,2476,2477,3,32,16,0,2477,2478,5,30,0,0,2478,2490,1,0,0,0,
		2479,2480,5,182,0,0,2480,2481,5,29,0,0,2481,2482,3,184,92,0,2482,2483,
		5,30,0,0,2483,2490,1,0,0,0,2484,2485,5,83,0,0,2485,2486,5,29,0,0,2486,
		2487,3,312,156,0,2487,2488,5,30,0,0,2488,2490,1,0,0,0,2489,2414,1,0,0,
		0,2489,2419,1,0,0,0,2489,2424,1,0,0,0,2489,2429,1,0,0,0,2489,2434,1,0,
		0,0,2489,2439,1,0,0,0,2489,2444,1,0,0,0,2489,2449,1,0,0,0,2489,2454,1,
		0,0,0,2489,2459,1,0,0,0,2489,2464,1,0,0,0,2489,2469,1,0,0,0,2489,2474,
		1,0,0,0,2489,2479,1,0,0,0,2489,2484,1,0,0,0,2490,311,1,0,0,0,2491,2493,
		3,314,157,0,2492,2491,1,0,0,0,2493,2496,1,0,0,0,2494,2492,1,0,0,0,2494,
		2495,1,0,0,0,2495,313,1,0,0,0,2496,2494,1,0,0,0,2497,2498,7,12,0,0,2498,
		315,1,0,0,0,2499,2503,3,310,155,0,2500,2503,3,6,3,0,2501,2503,5,178,0,
		0,2502,2499,1,0,0,0,2502,2500,1,0,0,0,2502,2501,1,0,0,0,2503,317,1,0,0,
		0,2504,2653,3,310,155,0,2505,2506,5,181,0,0,2506,2507,5,29,0,0,2507,2508,
		5,178,0,0,2508,2653,5,30,0,0,2509,2510,5,181,0,0,2510,2511,5,29,0,0,2511,
		2512,5,263,0,0,2512,2653,5,30,0,0,2513,2514,5,195,0,0,2514,2515,5,29,0,
		0,2515,2516,5,38,0,0,2516,2517,5,263,0,0,2517,2653,5,30,0,0,2518,2519,
		5,195,0,0,2519,2520,5,29,0,0,2520,2521,3,138,69,0,2521,2522,5,30,0,0,2522,
		2653,1,0,0,0,2523,2524,5,195,0,0,2524,2525,5,29,0,0,2525,2526,5,178,0,
		0,2526,2653,5,30,0,0,2527,2528,5,196,0,0,2528,2529,5,29,0,0,2529,2530,
		3,318,159,0,2530,2531,5,30,0,0,2531,2653,1,0,0,0,2532,2533,5,187,0,0,2533,
		2534,5,41,0,0,2534,2535,3,32,16,0,2535,2536,5,42,0,0,2536,2537,5,29,0,
		0,2537,2538,3,320,160,0,2538,2539,5,30,0,0,2539,2653,1,0,0,0,2540,2541,
		5,188,0,0,2541,2542,5,41,0,0,2542,2543,3,32,16,0,2543,2544,5,42,0,0,2544,
		2545,5,29,0,0,2545,2546,3,322,161,0,2546,2547,5,30,0,0,2547,2653,1,0,0,
		0,2548,2549,5,186,0,0,2549,2550,5,41,0,0,2550,2551,3,32,16,0,2551,2552,
		5,42,0,0,2552,2553,5,29,0,0,2553,2554,3,324,162,0,2554,2555,5,30,0,0,2555,
		2653,1,0,0,0,2556,2557,5,185,0,0,2557,2558,5,41,0,0,2558,2559,3,32,16,
		0,2559,2560,5,42,0,0,2560,2561,5,29,0,0,2561,2562,3,326,163,0,2562,2563,
		5,30,0,0,2563,2653,1,0,0,0,2564,2565,5,184,0,0,2565,2566,5,41,0,0,2566,
		2567,3,32,16,0,2567,2568,5,42,0,0,2568,2569,5,29,0,0,2569,2570,3,328,164,
		0,2570,2571,5,30,0,0,2571,2653,1,0,0,0,2572,2573,5,183,0,0,2573,2574,5,
		41,0,0,2574,2575,3,32,16,0,2575,2576,5,42,0,0,2576,2577,5,29,0,0,2577,
		2578,3,330,165,0,2578,2579,5,30,0,0,2579,2653,1,0,0,0,2580,2581,5,192,
		0,0,2581,2582,5,41,0,0,2582,2583,3,32,16,0,2583,2584,5,42,0,0,2584,2585,
		5,29,0,0,2585,2586,3,324,162,0,2586,2587,5,30,0,0,2587,2653,1,0,0,0,2588,
		2589,5,191,0,0,2589,2590,5,41,0,0,2590,2591,3,32,16,0,2591,2592,5,42,0,
		0,2592,2593,5,29,0,0,2593,2594,3,326,163,0,2594,2595,5,30,0,0,2595,2653,
		1,0,0,0,2596,2597,5,190,0,0,2597,2598,5,41,0,0,2598,2599,3,32,16,0,2599,
		2600,5,42,0,0,2600,2601,5,29,0,0,2601,2602,3,328,164,0,2602,2603,5,30,
		0,0,2603,2653,1,0,0,0,2604,2605,5,189,0,0,2605,2606,5,41,0,0,2606,2607,
		3,32,16,0,2607,2608,5,42,0,0,2608,2609,5,29,0,0,2609,2610,3,330,165,0,
		2610,2611,5,30,0,0,2611,2653,1,0,0,0,2612,2613,5,180,0,0,2613,2614,5,41,
		0,0,2614,2615,3,32,16,0,2615,2616,5,42,0,0,2616,2617,5,29,0,0,2617,2618,
		3,328,164,0,2618,2619,5,30,0,0,2619,2653,1,0,0,0,2620,2621,5,182,0,0,2621,
		2622,5,41,0,0,2622,2623,3,32,16,0,2623,2624,5,42,0,0,2624,2625,5,29,0,
		0,2625,2626,3,332,166,0,2626,2627,5,30,0,0,2627,2653,1,0,0,0,2628,2629,
		5,181,0,0,2629,2630,5,41,0,0,2630,2631,3,32,16,0,2631,2632,5,42,0,0,2632,
		2633,5,29,0,0,2633,2634,3,334,167,0,2634,2635,5,30,0,0,2635,2653,1,0,0,
		0,2636,2637,5,195,0,0,2637,2638,5,41,0,0,2638,2639,3,32,16,0,2639,2640,
		5,42,0,0,2640,2641,5,29,0,0,2641,2642,3,336,168,0,2642,2643,5,30,0,0,2643,
		2653,1,0,0,0,2644,2645,5,196,0,0,2645,2646,5,41,0,0,2646,2647,3,32,16,
		0,2647,2648,5,42,0,0,2648,2649,5,29,0,0,2649,2650,3,340,170,0,2650,2651,
		5,30,0,0,2651,2653,1,0,0,0,2652,2504,1,0,0,0,2652,2505,1,0,0,0,2652,2509,
		1,0,0,0,2652,2513,1,0,0,0,2652,2518,1,0,0,0,2652,2523,1,0,0,0,2652,2527,
		1,0,0,0,2652,2532,1,0,0,0,2652,2540,1,0,0,0,2652,2548,1,0,0,0,2652,2556,
		1,0,0,0,2652,2564,1,0,0,0,2652,2572,1,0,0,0,2652,2580,1,0,0,0,2652,2588,
		1,0,0,0,2652,2596,1,0,0,0,2652,2604,1,0,0,0,2652,2612,1,0,0,0,2652,2620,
		1,0,0,0,2652,2628,1,0,0,0,2652,2636,1,0,0,0,2652,2644,1,0,0,0,2653,319,
		1,0,0,0,2654,2657,3,36,18,0,2655,2657,3,32,16,0,2656,2654,1,0,0,0,2656,
		2655,1,0,0,0,2657,2660,1,0,0,0,2658,2656,1,0,0,0,2658,2659,1,0,0,0,2659,
		321,1,0,0,0,2660,2658,1,0,0,0,2661,2664,3,36,18,0,2662,2664,3,34,17,0,
		2663,2661,1,0,0,0,2663,2662,1,0,0,0,2664,2667,1,0,0,0,2665,2663,1,0,0,
		0,2665,2666,1,0,0,0,2666,323,1,0,0,0,2667,2665,1,0,0,0,2668,2670,3,34,
		17,0,2669,2668,1,0,0,0,2670,2673,1,0,0,0,2671,2669,1,0,0,0,2671,2672,1,
		0,0,0,2672,325,1,0,0,0,2673,2671,1,0,0,0,2674,2676,3,32,16,0,2675,2674,
		1,0,0,0,2676,2679,1,0,0,0,2677,2675,1,0,0,0,2677,2678,1,0,0,0,2678,327,
		1,0,0,0,2679,2677,1,0,0,0,2680,2682,3,32,16,0,2681,2680,1,0,0,0,2682,2685,
		1,0,0,0,2683,2681,1,0,0,0,2683,2684,1,0,0,0,2684,329,1,0,0,0,2685,2683,
		1,0,0,0,2686,2688,3,32,16,0,2687,2686,1,0,0,0,2688,2691,1,0,0,0,2689,2687,
		1,0,0,0,2689,2690,1,0,0,0,2690,331,1,0,0,0,2691,2689,1,0,0,0,2692,2694,
		3,184,92,0,2693,2692,1,0,0,0,2694,2697,1,0,0,0,2695,2693,1,0,0,0,2695,
		2696,1,0,0,0,2696,333,1,0,0,0,2697,2695,1,0,0,0,2698,2700,7,13,0,0,2699,
		2698,1,0,0,0,2700,2703,1,0,0,0,2701,2699,1,0,0,0,2701,2702,1,0,0,0,2702,
		335,1,0,0,0,2703,2701,1,0,0,0,2704,2706,3,338,169,0,2705,2704,1,0,0,0,
		2706,2709,1,0,0,0,2707,2705,1,0,0,0,2707,2708,1,0,0,0,2708,337,1,0,0,0,
		2709,2707,1,0,0,0,2710,2715,5,178,0,0,2711,2712,5,38,0,0,2712,2715,5,263,
		0,0,2713,2715,3,138,69,0,2714,2710,1,0,0,0,2714,2711,1,0,0,0,2714,2713,
		1,0,0,0,2715,339,1,0,0,0,2716,2718,3,318,159,0,2717,2716,1,0,0,0,2718,
		2721,1,0,0,0,2719,2717,1,0,0,0,2719,2720,1,0,0,0,2720,341,1,0,0,0,2721,
		2719,1,0,0,0,2722,2726,3,44,22,0,2723,2726,3,46,23,0,2724,2726,3,2,1,0,
		2725,2722,1,0,0,0,2725,2723,1,0,0,0,2725,2724,1,0,0,0,2726,343,1,0,0,0,
		2727,2728,5,167,0,0,2728,2729,5,35,0,0,2729,2730,5,29,0,0,2730,2731,3,
		312,156,0,2731,2732,5,30,0,0,2732,2753,1,0,0,0,2733,2734,5,168,0,0,2734,
		2735,3,38,19,0,2735,2736,5,74,0,0,2736,2737,3,38,19,0,2737,2738,5,74,0,
		0,2738,2739,3,38,19,0,2739,2740,5,74,0,0,2740,2741,3,38,19,0,2741,2753,
		1,0,0,0,2742,2743,5,169,0,0,2743,2753,3,6,3,0,2744,2745,5,169,0,0,2745,
		2746,5,35,0,0,2746,2747,5,29,0,0,2747,2748,3,312,156,0,2748,2749,5,30,
		0,0,2749,2753,1,0,0,0,2750,2753,3,342,171,0,2751,2753,3,40,20,0,2752,2727,
		1,0,0,0,2752,2733,1,0,0,0,2752,2742,1,0,0,0,2752,2744,1,0,0,0,2752,2750,
		1,0,0,0,2752,2751,1,0,0,0,2753,345,1,0,0,0,2754,2755,5,24,0,0,2755,2756,
		5,39,0,0,2756,2757,3,98,49,0,2757,2758,3,2,1,0,2758,2767,1,0,0,0,2759,
		2760,5,24,0,0,2760,2761,5,39,0,0,2761,2762,3,98,49,0,2762,2763,3,2,1,0,
		2763,2764,5,33,0,0,2764,2765,3,2,1,0,2765,2767,1,0,0,0,2766,2754,1,0,0,
		0,2766,2759,1,0,0,0,2767,347,1,0,0,0,2768,2770,3,350,175,0,2769,2768,1,
		0,0,0,2770,2773,1,0,0,0,2771,2769,1,0,0,0,2771,2772,1,0,0,0,2772,349,1,
		0,0,0,2773,2771,1,0,0,0,2774,2775,5,179,0,0,2775,2776,5,35,0,0,2776,2777,
		5,29,0,0,2777,2778,3,312,156,0,2778,2779,5,30,0,0,2779,2789,1,0,0,0,2780,
		2789,3,344,172,0,2781,2782,5,170,0,0,2782,2783,5,35,0,0,2783,2784,5,29,
		0,0,2784,2785,3,312,156,0,2785,2786,5,30,0,0,2786,2789,1,0,0,0,2787,2789,
		5,54,0,0,2788,2774,1,0,0,0,2788,2780,1,0,0,0,2788,2781,1,0,0,0,2788,2787,
		1,0,0,0,2789,351,1,0,0,0,2790,2791,5,49,0,0,2791,2795,5,39,0,0,2792,2794,
		3,356,178,0,2793,2792,1,0,0,0,2794,2797,1,0,0,0,2795,2793,1,0,0,0,2795,
		2796,1,0,0,0,2796,2798,1,0,0,0,2797,2795,1,0,0,0,2798,2799,3,2,1,0,2799,
		353,1,0,0,0,2800,2804,5,300,0,0,2801,2803,3,356,178,0,2802,2801,1,0,0,
		0,2803,2806,1,0,0,0,2804,2802,1,0,0,0,2804,2805,1,0,0,0,2805,2807,1,0,
		0,0,2806,2804,1,0,0,0,2807,2808,3,2,1,0,2808,355,1,0,0,0,2809,2825,5,51,
		0,0,2810,2825,5,50,0,0,2811,2825,5,171,0,0,2812,2813,5,61,0,0,2813,2825,
		5,50,0,0,2814,2815,5,61,0,0,2815,2825,5,51,0,0,2816,2817,5,61,0,0,2817,
		2825,5,62,0,0,2818,2819,5,61,0,0,2819,2825,5,63,0,0,2820,2821,5,61,0,0,
		2821,2825,5,64,0,0,2822,2823,5,61,0,0,2823,2825,5,65,0,0,2824,2809,1,0,
		0,0,2824,2810,1,0,0,0,2824,2811,1,0,0,0,2824,2812,1,0,0,0,2824,2814,1,
		0,0,0,2824,2816,1,0,0,0,2824,2818,1,0,0,0,2824,2820,1,0,0,0,2824,2822,
		1,0,0,0,2825,357,1,0,0,0,2826,2828,3,360,180,0,2827,2826,1,0,0,0,2828,
		2831,1,0,0,0,2829,2827,1,0,0,0,2829,2830,1,0,0,0,2830,359,1,0,0,0,2831,
		2829,1,0,0,0,2832,2833,5,20,0,0,2833,2846,3,2,1,0,2834,2835,5,49,0,0,2835,
		2836,5,39,0,0,2836,2846,3,140,70,0,2837,2838,5,24,0,0,2838,2839,5,39,0,
		0,2839,2846,3,2,1,0,2840,2846,3,196,98,0,2841,2842,5,49,0,0,2842,2846,
		3,32,16,0,2843,2846,3,342,171,0,2844,2846,3,40,20,0,2845,2832,1,0,0,0,
		2845,2834,1,0,0,0,2845,2837,1,0,0,0,2845,2840,1,0,0,0,2845,2841,1,0,0,
		0,2845,2843,1,0,0,0,2845,2844,1,0,0,0,2846,361,1,0,0,0,2847,2851,5,273,
		0,0,2848,2850,3,364,182,0,2849,2848,1,0,0,0,2850,2853,1,0,0,0,2851,2849,
		1,0,0,0,2851,2852,1,0,0,0,2852,2854,1,0,0,0,2853,2851,1,0,0,0,2854,2867,
		3,2,1,0,2855,2859,5,273,0,0,2856,2858,3,364,182,0,2857,2856,1,0,0,0,2858,
		2861,1,0,0,0,2859,2857,1,0,0,0,2859,2860,1,0,0,0,2860,2862,1,0,0,0,2861,
		2859,1,0,0,0,2862,2863,3,2,1,0,2863,2864,5,33,0,0,2864,2865,3,2,1,0,2865,
		2867,1,0,0,0,2866,2847,1,0,0,0,2866,2855,1,0,0,0,2867,363,1,0,0,0,2868,
		2869,7,14,0,0,2869,365,1,0,0,0,2870,2872,3,368,184,0,2871,2870,1,0,0,0,
		2872,2875,1,0,0,0,2873,2871,1,0,0,0,2873,2874,1,0,0,0,2874,367,1,0,0,0,
		2875,2873,1,0,0,0,2876,2877,5,20,0,0,2877,2878,3,2,1,0,2878,2879,5,43,
		0,0,2879,2880,3,32,16,0,2880,2887,1,0,0,0,2881,2882,5,24,0,0,2882,2883,
		5,39,0,0,2883,2887,3,2,1,0,2884,2887,3,342,171,0,2885,2887,3,40,20,0,2886,
		2876,1,0,0,0,2886,2881,1,0,0,0,2886,2884,1,0,0,0,2886,2885,1,0,0,0,2887,
		369,1,0,0,0,172,378,382,390,398,451,492,501,525,529,547,574,597,633,639,
		646,648,658,660,667,678,686,707,709,725,770,775,780,785,793,903,909,925,
		931,937,944,1052,1057,1063,1068,1070,1078,1090,1102,1109,1116,1118,1145,
		1152,1160,1168,1181,1188,1191,1210,1296,1305,1312,1315,1323,1344,1376,
		1399,1411,1420,1445,1462,1470,1474,1489,1496,1541,1551,1567,1579,1591,
		1605,1617,1628,1635,1645,1658,1663,1668,1677,1688,1771,1780,1793,1804,
		1812,1822,1824,1851,1858,1863,1870,1876,1886,1890,1897,1912,1918,1932,
		1945,1953,1960,1964,1969,1985,1990,1992,2005,2031,2038,2040,2045,2051,
		2080,2085,2108,2113,2177,2186,2199,2210,2221,2224,2231,2243,2257,2271,
		2279,2299,2311,2316,2325,2327,2334,2344,2412,2489,2494,2502,2652,2656,
		2658,2663,2665,2671,2677,2683,2689,2695,2701,2707,2714,2719,2725,2752,
		2766,2771,2788,2795,2804,2824,2829,2845,2851,2859,2866,2873,2886
	};

	public static readonly ATN _ATN =
		new ATNDeserializer().Deserialize(_serializedATN);


}
} // namespace ILAssembler