View Javadoc
1   // Generated from net/sourceforge/pmd/lang/swift/antlr4/Swift.g4 by ANTLR 4.5.2
2   package net.sourceforge.pmd.lang.swift.antlr4;
3   import org.antlr.v4.runtime.atn.*;
4   import org.antlr.v4.runtime.dfa.DFA;
5   import org.antlr.v4.runtime.*;
6   import org.antlr.v4.runtime.misc.*;
7   import org.antlr.v4.runtime.tree.*;
8   import java.util.List;
9   import java.util.Iterator;
10  import java.util.ArrayList;
11  
12  @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
13  public class SwiftParser extends Parser {
14  	static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); }
15  
16  	protected static final DFA[] _decisionToDFA;
17  	protected static final PredictionContextCache _sharedContextCache =
18  		new PredictionContextCache();
19  	public static final int
20  		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, 
21  		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
22  		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
23  		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
24  		T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 
25  		T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, 
26  		T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, 
27  		T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, 
28  		T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, 
29  		T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, 
30  		T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, 
31  		T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, 
32  		T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 
33  		T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 
34  		T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 
35  		T__107=108, T__108=109, T__109=110, T__110=111, T__111=112, T__112=113, 
36  		T__113=114, T__114=115, T__115=116, T__116=117, T__117=118, T__118=119, 
37  		T__119=120, T__120=121, T__121=122, T__122=123, T__123=124, T__124=125, 
38  		T__125=126, T__126=127, T__127=128, T__128=129, T__129=130, T__130=131, 
39  		BooleanLiteral=132, NilLiteral=133, OperatorHead=134, OperatorCharacter=135, 
40  		DotOperatorHead=136, Identifier=137, ImplicitParameterName=138, BinaryLiteral=139, 
41  		OctalLiteral=140, DecimalLiteral=141, HexadecimalLiteral=142, FloatingPointLiteral=143, 
42  		VersionLiteral=144, StringLiteral=145, EscapedCharacter=146, WS=147, BlockComment=148, 
43  		LineComment=149;
44  	public static final int
45  		RULE_topLevel = 0, RULE_statement = 1, RULE_statements = 2, RULE_loopStatement = 3, 
46  		RULE_forStatement = 4, RULE_forInit = 5, RULE_forInStatement = 6, RULE_whileStatement = 7, 
47  		RULE_repeatWhileStatement = 8, RULE_branchStatement = 9, RULE_ifStatement = 10, 
48  		RULE_elseClause = 11, RULE_guardStatement = 12, RULE_switchStatement = 13, 
49  		RULE_switchCases = 14, RULE_switchCase = 15, RULE_caseLabel = 16, RULE_caseItemList = 17, 
50  		RULE_caseItem = 18, RULE_defaultLabel = 19, RULE_labeledStatement = 20, 
51  		RULE_statementLabel = 21, RULE_labelName = 22, RULE_controlTransferStatement = 23, 
52  		RULE_breakStatement = 24, RULE_continueStatement = 25, RULE_fallthroughStatement = 26, 
53  		RULE_returnStatement = 27, RULE_throwStatement = 28, RULE_deferStatement = 29, 
54  		RULE_doStatement = 30, RULE_catchClauses = 31, RULE_catchClause = 32, 
55  		RULE_conditionClause = 33, RULE_conditionList = 34, RULE_condition = 35, 
56  		RULE_caseCondition = 36, RULE_optionalBindingCondition = 37, RULE_optionalBindingHead = 38, 
57  		RULE_optionalBindingContinuationList = 39, RULE_optionalBindingContinuation = 40, 
58  		RULE_whereClause = 41, RULE_whereExpression = 42, RULE_availabilityCondition = 43, 
59  		RULE_availabilityArguments = 44, RULE_availabilityArgument = 45, RULE_platformName = 46, 
60  		RULE_platformVersion = 47, RULE_genericParameterClause = 48, RULE_genericParameterList = 49, 
61  		RULE_genericParameter = 50, RULE_requirementClause = 51, RULE_requirementList = 52, 
62  		RULE_requirement = 53, RULE_conformanceRequirement = 54, RULE_sameTypeRequirement = 55, 
63  		RULE_genericArgumentClause = 56, RULE_genericArgumentList = 57, RULE_genericArgument = 58, 
64  		RULE_declaration = 59, RULE_declarations = 60, RULE_declarationModifiers = 61, 
65  		RULE_declarationModifier = 62, RULE_accessLevelModifier = 63, RULE_accessLevelModifiers = 64, 
66  		RULE_codeBlock = 65, RULE_importDeclaration = 66, RULE_importKind = 67, 
67  		RULE_importPath = 68, RULE_importPathIdentifier = 69, RULE_constantDeclaration = 70, 
68  		RULE_patternInitializerList = 71, RULE_patternInitializer = 72, RULE_initializer = 73, 
69  		RULE_variableDeclaration = 74, RULE_variableDeclarationHead = 75, RULE_variableName = 76, 
70  		RULE_getterSetterBlock = 77, RULE_getterClause = 78, RULE_setterClause = 79, 
71  		RULE_setterName = 80, RULE_getterSetterKeywordBlock = 81, RULE_getterKeywordClause = 82, 
72  		RULE_setterKeywordClause = 83, RULE_willSetDidSetBlock = 84, RULE_willSetClause = 85, 
73  		RULE_didSetClause = 86, RULE_typealiasDeclaration = 87, RULE_typealiasHead = 88, 
74  		RULE_typealiasName = 89, RULE_typealiasAssignment = 90, RULE_functionDeclaration = 91, 
75  		RULE_functionHead = 92, RULE_functionName = 93, RULE_functionSignature = 94, 
76  		RULE_functionResult = 95, RULE_functionBody = 96, RULE_parameterClauses = 97, 
77  		RULE_parameterClause = 98, RULE_parameterList = 99, RULE_parameter = 100, 
78  		RULE_externalParameterName = 101, RULE_localParameterName = 102, RULE_defaultArgumentClause = 103, 
79  		RULE_enumDeclaration = 104, RULE_enumDef = 105, RULE_unionStyleEnum = 106, 
80  		RULE_unionStyleEnumMembers = 107, RULE_unionStyleEnumMember = 108, RULE_unionStyleEnumCaseClause = 109, 
81  		RULE_unionStyleEnumCaseList = 110, RULE_unionStyleEnumCase = 111, RULE_enumName = 112, 
82  		RULE_enumCaseName = 113, RULE_rawValueStyleEnum = 114, RULE_rawValueStyleEnumMembers = 115, 
83  		RULE_rawValueStyleEnumMember = 116, RULE_rawValueStyleEnumCaseClause = 117, 
84  		RULE_rawValueStyleEnumCaseList = 118, RULE_rawValueStyleEnumCase = 119, 
85  		RULE_rawValueAssignment = 120, RULE_structDeclaration = 121, RULE_structName = 122, 
86  		RULE_structBody = 123, RULE_classDeclaration = 124, RULE_className = 125, 
87  		RULE_classBody = 126, RULE_protocolDeclaration = 127, RULE_protocolName = 128, 
88  		RULE_protocolBody = 129, RULE_protocolMemberDeclaration = 130, RULE_protocolMemberDeclarations = 131, 
89  		RULE_protocolPropertyDeclaration = 132, RULE_protocolMethodDeclaration = 133, 
90  		RULE_protocolInitializerDeclaration = 134, RULE_protocolSubscriptDeclaration = 135, 
91  		RULE_protocolAssociatedTypeDeclaration = 136, RULE_initializerDeclaration = 137, 
92  		RULE_initializerHead = 138, RULE_initializerBody = 139, RULE_deinitializerDeclaration = 140, 
93  		RULE_extensionDeclaration = 141, RULE_extensionBody = 142, RULE_subscriptDeclaration = 143, 
94  		RULE_subscriptHead = 144, RULE_subscriptResult = 145, RULE_operatorDeclaration = 146, 
95  		RULE_prefixOperatorDeclaration = 147, RULE_postfixOperatorDeclaration = 148, 
96  		RULE_infixOperatorDeclaration = 149, RULE_infixOperatorAttributes = 150, 
97  		RULE_precedenceClause = 151, RULE_precedenceLevel = 152, RULE_associativityClause = 153, 
98  		RULE_associativity = 154, RULE_pattern = 155, RULE_wildcardPattern = 156, 
99  		RULE_identifierPattern = 157, RULE_valueBindingPattern = 158, RULE_tuplePattern = 159, 
100 		RULE_tuplePatternElementList = 160, RULE_tuplePatternElement = 161, RULE_enumCasePattern = 162, 
101 		RULE_typeCastingPattern = 163, RULE_isPattern = 164, RULE_asPattern = 165, 
102 		RULE_expressionPattern = 166, RULE_attribute = 167, RULE_attributeName = 168, 
103 		RULE_attributeArgumentClause = 169, RULE_attributes = 170, RULE_balancedTokens = 171, 
104 		RULE_balancedToken = 172, RULE_expressionList = 173, RULE_expression = 174, 
105 		RULE_prefixExpression = 175, RULE_inOutExpression = 176, RULE_tryOperator = 177, 
106 		RULE_binaryExpression = 178, RULE_assignmentOperator = 179, RULE_conditionalOperator = 180, 
107 		RULE_typeCastingOperator = 181, RULE_primaryExpression = 182, RULE_literalExpression = 183, 
108 		RULE_arrayLiteral = 184, RULE_arrayLiteralItems = 185, RULE_arrayLiteralItem = 186, 
109 		RULE_dictionaryLiteral = 187, RULE_dictionaryLiteralItems = 188, RULE_dictionaryLiteralItem = 189, 
110 		RULE_selfExpression = 190, RULE_superclassExpression = 191, RULE_superclassMethodExpression = 192, 
111 		RULE_superclassSubscriptExpression = 193, RULE_superclassInitializerExpression = 194, 
112 		RULE_closureExpression = 195, RULE_closureSignature = 196, RULE_captureList = 197, 
113 		RULE_captureListItems = 198, RULE_captureListItem = 199, RULE_captureSpecifier = 200, 
114 		RULE_implicitMemberExpression = 201, RULE_parenthesizedExpression = 202, 
115 		RULE_expressionElementList = 203, RULE_expressionElement = 204, RULE_wildcardExpression = 205, 
116 		RULE_postfixExpression = 206, RULE_operatorHead = 207, RULE_operatorCharacter = 208, 
117 		RULE_operator = 209, RULE_binaryOperator = 210, RULE_prefixOperator = 211, 
118 		RULE_postfixOperator = 212, RULE_sType = 213, RULE_arrayType = 214, RULE_dictionaryType = 215, 
119 		RULE_optionalType = 216, RULE_implicitlyUnwrappedOptionalType = 217, RULE_typeAnnotation = 218, 
120 		RULE_typeIdentifier = 219, RULE_typeName = 220, RULE_tupleType = 221, 
121 		RULE_tupleTypeBody = 222, RULE_tupleTypeElementList = 223, RULE_tupleTypeElement = 224, 
122 		RULE_elementName = 225, RULE_protocolCompositionType = 226, RULE_protocolIdentifierList = 227, 
123 		RULE_protocolIdentifier = 228, RULE_metatypeType = 229, RULE_typeInheritanceClause = 230, 
124 		RULE_typeInheritanceList = 231, RULE_classRequirement = 232, RULE_compilerControlStatement = 233, 
125 		RULE_buildConfigurationStatement = 234, RULE_buildConfigurationElseIfClauses = 235, 
126 		RULE_buildConfigurationElseIfClause = 236, RULE_buildConfigurationElseClause = 237, 
127 		RULE_buildConfiguration = 238, RULE_platformTestingFunction = 239, RULE_operatingSystem = 240, 
128 		RULE_architecture = 241, RULE_lineControlStatement = 242, RULE_lineNumber = 243, 
129 		RULE_fileName = 244, RULE_identifier = 245, RULE_keyword = 246, RULE_contextSensitiveKeyword = 247, 
130 		RULE_identifierList = 248, RULE_booleanLiteral = 249, RULE_literal = 250, 
131 		RULE_numericLiteral = 251, RULE_integerLiteral = 252;
132 	public static final String[] ruleNames = {
133 		"topLevel", "statement", "statements", "loopStatement", "forStatement", 
134 		"forInit", "forInStatement", "whileStatement", "repeatWhileStatement", 
135 		"branchStatement", "ifStatement", "elseClause", "guardStatement", "switchStatement", 
136 		"switchCases", "switchCase", "caseLabel", "caseItemList", "caseItem", 
137 		"defaultLabel", "labeledStatement", "statementLabel", "labelName", "controlTransferStatement", 
138 		"breakStatement", "continueStatement", "fallthroughStatement", "returnStatement", 
139 		"throwStatement", "deferStatement", "doStatement", "catchClauses", "catchClause", 
140 		"conditionClause", "conditionList", "condition", "caseCondition", "optionalBindingCondition", 
141 		"optionalBindingHead", "optionalBindingContinuationList", "optionalBindingContinuation", 
142 		"whereClause", "whereExpression", "availabilityCondition", "availabilityArguments", 
143 		"availabilityArgument", "platformName", "platformVersion", "genericParameterClause", 
144 		"genericParameterList", "genericParameter", "requirementClause", "requirementList", 
145 		"requirement", "conformanceRequirement", "sameTypeRequirement", "genericArgumentClause", 
146 		"genericArgumentList", "genericArgument", "declaration", "declarations", 
147 		"declarationModifiers", "declarationModifier", "accessLevelModifier", 
148 		"accessLevelModifiers", "codeBlock", "importDeclaration", "importKind", 
149 		"importPath", "importPathIdentifier", "constantDeclaration", "patternInitializerList", 
150 		"patternInitializer", "initializer", "variableDeclaration", "variableDeclarationHead", 
151 		"variableName", "getterSetterBlock", "getterClause", "setterClause", "setterName", 
152 		"getterSetterKeywordBlock", "getterKeywordClause", "setterKeywordClause", 
153 		"willSetDidSetBlock", "willSetClause", "didSetClause", "typealiasDeclaration", 
154 		"typealiasHead", "typealiasName", "typealiasAssignment", "functionDeclaration", 
155 		"functionHead", "functionName", "functionSignature", "functionResult", 
156 		"functionBody", "parameterClauses", "parameterClause", "parameterList", 
157 		"parameter", "externalParameterName", "localParameterName", "defaultArgumentClause", 
158 		"enumDeclaration", "enumDef", "unionStyleEnum", "unionStyleEnumMembers", 
159 		"unionStyleEnumMember", "unionStyleEnumCaseClause", "unionStyleEnumCaseList", 
160 		"unionStyleEnumCase", "enumName", "enumCaseName", "rawValueStyleEnum", 
161 		"rawValueStyleEnumMembers", "rawValueStyleEnumMember", "rawValueStyleEnumCaseClause", 
162 		"rawValueStyleEnumCaseList", "rawValueStyleEnumCase", "rawValueAssignment", 
163 		"structDeclaration", "structName", "structBody", "classDeclaration", "className", 
164 		"classBody", "protocolDeclaration", "protocolName", "protocolBody", "protocolMemberDeclaration", 
165 		"protocolMemberDeclarations", "protocolPropertyDeclaration", "protocolMethodDeclaration", 
166 		"protocolInitializerDeclaration", "protocolSubscriptDeclaration", "protocolAssociatedTypeDeclaration", 
167 		"initializerDeclaration", "initializerHead", "initializerBody", "deinitializerDeclaration", 
168 		"extensionDeclaration", "extensionBody", "subscriptDeclaration", "subscriptHead", 
169 		"subscriptResult", "operatorDeclaration", "prefixOperatorDeclaration", 
170 		"postfixOperatorDeclaration", "infixOperatorDeclaration", "infixOperatorAttributes", 
171 		"precedenceClause", "precedenceLevel", "associativityClause", "associativity", 
172 		"pattern", "wildcardPattern", "identifierPattern", "valueBindingPattern", 
173 		"tuplePattern", "tuplePatternElementList", "tuplePatternElement", "enumCasePattern", 
174 		"typeCastingPattern", "isPattern", "asPattern", "expressionPattern", "attribute", 
175 		"attributeName", "attributeArgumentClause", "attributes", "balancedTokens", 
176 		"balancedToken", "expressionList", "expression", "prefixExpression", "inOutExpression", 
177 		"tryOperator", "binaryExpression", "assignmentOperator", "conditionalOperator", 
178 		"typeCastingOperator", "primaryExpression", "literalExpression", "arrayLiteral", 
179 		"arrayLiteralItems", "arrayLiteralItem", "dictionaryLiteral", "dictionaryLiteralItems", 
180 		"dictionaryLiteralItem", "selfExpression", "superclassExpression", "superclassMethodExpression", 
181 		"superclassSubscriptExpression", "superclassInitializerExpression", "closureExpression", 
182 		"closureSignature", "captureList", "captureListItems", "captureListItem", 
183 		"captureSpecifier", "implicitMemberExpression", "parenthesizedExpression", 
184 		"expressionElementList", "expressionElement", "wildcardExpression", "postfixExpression", 
185 		"operatorHead", "operatorCharacter", "operator", "binaryOperator", "prefixOperator", 
186 		"postfixOperator", "sType", "arrayType", "dictionaryType", "optionalType", 
187 		"implicitlyUnwrappedOptionalType", "typeAnnotation", "typeIdentifier", 
188 		"typeName", "tupleType", "tupleTypeBody", "tupleTypeElementList", "tupleTypeElement", 
189 		"elementName", "protocolCompositionType", "protocolIdentifierList", "protocolIdentifier", 
190 		"metatypeType", "typeInheritanceClause", "typeInheritanceList", "classRequirement", 
191 		"compilerControlStatement", "buildConfigurationStatement", "buildConfigurationElseIfClauses", 
192 		"buildConfigurationElseIfClause", "buildConfigurationElseClause", "buildConfiguration", 
193 		"platformTestingFunction", "operatingSystem", "architecture", "lineControlStatement", 
194 		"lineNumber", "fileName", "identifier", "keyword", "contextSensitiveKeyword", 
195 		"identifierList", "booleanLiteral", "literal", "numericLiteral", "integerLiteral"
196 	};
197 
198 	private static final String[] _LITERAL_NAMES = {
199 		null, "';'", "':'", "'for'", "'('", "')'", "'case'", "'in'", "'while'", 
200 		"'repeat'", "'if'", "'else'", "'guard'", "'switch'", "'{'", "'}'", "','", 
201 		"'default'", "'break'", "'continue'", "'fallthrough'", "'return'", "'throw'", 
202 		"'defer'", "'do'", "'catch'", "'let'", "'var'", "'where'", "'#available'", 
203 		"'*'", "'iOS'", "'iOSApplicationExtension'", "'OSX'", "'OSXApplicationExtension'", 
204 		"'watchOS'", "'watchOSApplicationExtension'", "'tvOS'", "'tvOSApplicationExtension'", 
205 		"'<'", "'>'", "'=='", "'class'", "'convenience'", "'dynamic'", "'final'", 
206 		"'infix'", "'lazy'", "'mutating'", "'nonmutating'", "'optional'", "'override'", 
207 		"'postfix'", "'prefix'", "'required'", "'static'", "'unowned'", "'safe'", 
208 		"'unsafe'", "'weak'", "'internal'", "'set'", "'private'", "'public'", 
209 		"'import'", "'typealias'", "'struct'", "'enum'", "'protocol'", "'func'", 
210 		"'.'", "'='", "'get'", "'willSet'", "'didSet'", "'throws'", "'rethrows'", 
211 		"'->'", "'...'", "'inout'", "'#'", "'_'", "'indirect'", "'init'", "'?'", 
212 		"'!'", "'deinit'", "'extension'", "'subscript'", "'operator'", "'precedence'", 
213 		"'associativity'", "'left'", "'right'", "'none'", "'is'", "'as'", "'@'", 
214 		"'['", "']'", "'-'", "'''", "'/'", "'\"'", "'&'", "'try'", "'__FILE__'", 
215 		"'__LINE__'", "'__COLUMN__'", "'__FUNCTION__'", "'self'", "'super'", "'unowned(safe)'", 
216 		"'unowned(unsafe)'", "'dynamicType'", "'&&'", "'||'", "'Type'", "'Protocol'", 
217 		"'Self'", "'#if'", "'#endif'", "'#elseif'", "'#else'", "'os'", "'arch'", 
218 		"'i386'", "'x86_64'", "'arm'", "'arm64'", "'#line'", "'OSXApplicationExtension-'", 
219 		null, "'nil'", null, null, "'..'"
220 	};
221 	private static final String[] _SYMBOLIC_NAMES = {
222 		null, null, null, null, null, null, null, null, null, null, null, null, 
223 		null, null, null, null, null, null, null, null, null, null, null, null, 
224 		null, null, null, null, null, null, null, null, null, null, null, null, 
225 		null, null, null, null, null, null, null, null, null, null, null, null, 
226 		null, null, null, null, null, null, null, null, null, null, null, null, 
227 		null, null, null, null, null, null, null, null, null, null, null, null, 
228 		null, null, null, null, null, null, null, null, null, null, null, null, 
229 		null, null, null, null, null, null, null, null, null, null, null, null, 
230 		null, null, null, null, null, null, null, null, null, null, null, null, 
231 		null, null, null, null, null, null, null, null, null, null, null, null, 
232 		null, null, null, null, null, null, null, null, null, null, null, null, 
233 		"BooleanLiteral", "NilLiteral", "OperatorHead", "OperatorCharacter", "DotOperatorHead", 
234 		"Identifier", "ImplicitParameterName", "BinaryLiteral", "OctalLiteral", 
235 		"DecimalLiteral", "HexadecimalLiteral", "FloatingPointLiteral", "VersionLiteral", 
236 		"StringLiteral", "EscapedCharacter", "WS", "BlockComment", "LineComment"
237 	};
238 	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
239 
240 	/**
241 	 * @deprecated Use {@link #VOCABULARY} instead.
242 	 */
243 	@Deprecated
244 	public static final String[] tokenNames;
245 	static {
246 		tokenNames = new String[_SYMBOLIC_NAMES.length];
247 		for (int i = 0; i < tokenNames.length; i++) {
248 			tokenNames[i] = VOCABULARY.getLiteralName(i);
249 			if (tokenNames[i] == null) {
250 				tokenNames[i] = VOCABULARY.getSymbolicName(i);
251 			}
252 
253 			if (tokenNames[i] == null) {
254 				tokenNames[i] = "<INVALID>";
255 			}
256 		}
257 	}
258 
259 	@Override
260 	@Deprecated
261 	public String[] getTokenNames() {
262 		return tokenNames;
263 	}
264 
265 	@Override
266 
267 	public Vocabulary getVocabulary() {
268 		return VOCABULARY;
269 	}
270 
271 	@Override
272 	public String getGrammarFileName() { return "Swift.g4"; }
273 
274 	@Override
275 	public String[] getRuleNames() { return ruleNames; }
276 
277 	@Override
278 	public String getSerializedATN() { return _serializedATN; }
279 
280 	@Override
281 	public ATN getATN() { return _ATN; }
282 
283 	public SwiftParser(TokenStream input) {
284 		super(input);
285 		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
286 	}
287 	public static class TopLevelContext extends ParserRuleContext {
288 		public TerminalNode EOF() { return getToken(SwiftParser.EOF, 0); }
289 		public List<StatementContext> statement() {
290 			return getRuleContexts(StatementContext.class);
291 		}
292 		public StatementContext statement(int i) {
293 			return getRuleContext(StatementContext.class,i);
294 		}
295 		public List<ExpressionContext> expression() {
296 			return getRuleContexts(ExpressionContext.class);
297 		}
298 		public ExpressionContext expression(int i) {
299 			return getRuleContext(ExpressionContext.class,i);
300 		}
301 		public TopLevelContext(ParserRuleContext parent, int invokingState) {
302 			super(parent, invokingState);
303 		}
304 		@Override public int getRuleIndex() { return RULE_topLevel; }
305 		@Override
306 		public void enterRule(ParseTreeListener listener) {
307 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTopLevel(this);
308 		}
309 		@Override
310 		public void exitRule(ParseTreeListener listener) {
311 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTopLevel(this);
312 		}
313 	}
314 
315 	public final TopLevelContext topLevel() throws RecognitionException {
316 		TopLevelContext _localctx = new TopLevelContext(_ctx, getState());
317 		enterRule(_localctx, 0, RULE_topLevel);
318 		int _la;
319 		try {
320 			enterOuterAlt(_localctx, 1);
321 			{
322 			setState(510);
323 			_errHandler.sync(this);
324 			_la = _input.LA(1);
325 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
326 				{
327 				setState(508);
328 				_errHandler.sync(this);
329 				switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
330 				case 1:
331 					{
332 					setState(506);
333 					statement();
334 					}
335 					break;
336 				case 2:
337 					{
338 					setState(507);
339 					expression();
340 					}
341 					break;
342 				}
343 				}
344 				setState(512);
345 				_errHandler.sync(this);
346 				_la = _input.LA(1);
347 			}
348 			setState(513);
349 			match(EOF);
350 			}
351 		}
352 		catch (RecognitionException re) {
353 			_localctx.exception = re;
354 			_errHandler.reportError(this, re);
355 			_errHandler.recover(this, re);
356 		}
357 		finally {
358 			exitRule();
359 		}
360 		return _localctx;
361 	}
362 
363 	public static class StatementContext extends ParserRuleContext {
364 		public DeclarationContext declaration() {
365 			return getRuleContext(DeclarationContext.class,0);
366 		}
367 		public LoopStatementContext loopStatement() {
368 			return getRuleContext(LoopStatementContext.class,0);
369 		}
370 		public BranchStatementContext branchStatement() {
371 			return getRuleContext(BranchStatementContext.class,0);
372 		}
373 		public LabeledStatementContext labeledStatement() {
374 			return getRuleContext(LabeledStatementContext.class,0);
375 		}
376 		public ControlTransferStatementContext controlTransferStatement() {
377 			return getRuleContext(ControlTransferStatementContext.class,0);
378 		}
379 		public DeferStatementContext deferStatement() {
380 			return getRuleContext(DeferStatementContext.class,0);
381 		}
382 		public DoStatementContext doStatement() {
383 			return getRuleContext(DoStatementContext.class,0);
384 		}
385 		public CompilerControlStatementContext compilerControlStatement() {
386 			return getRuleContext(CompilerControlStatementContext.class,0);
387 		}
388 		public ExpressionContext expression() {
389 			return getRuleContext(ExpressionContext.class,0);
390 		}
391 		public StatementContext(ParserRuleContext parent, int invokingState) {
392 			super(parent, invokingState);
393 		}
394 		@Override public int getRuleIndex() { return RULE_statement; }
395 		@Override
396 		public void enterRule(ParseTreeListener listener) {
397 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterStatement(this);
398 		}
399 		@Override
400 		public void exitRule(ParseTreeListener listener) {
401 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitStatement(this);
402 		}
403 	}
404 
405 	public final StatementContext statement() throws RecognitionException {
406 		StatementContext _localctx = new StatementContext(_ctx, getState());
407 		enterRule(_localctx, 2, RULE_statement);
408 		int _la;
409 		try {
410 			setState(548);
411 			_errHandler.sync(this);
412 			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
413 			case 1:
414 				enterOuterAlt(_localctx, 1);
415 				{
416 				setState(515);
417 				declaration();
418 				setState(517);
419 				_la = _input.LA(1);
420 				if (_la==T__0) {
421 					{
422 					setState(516);
423 					match(T__0);
424 					}
425 				}
426 
427 				}
428 				break;
429 			case 2:
430 				enterOuterAlt(_localctx, 2);
431 				{
432 				setState(519);
433 				loopStatement();
434 				setState(521);
435 				_la = _input.LA(1);
436 				if (_la==T__0) {
437 					{
438 					setState(520);
439 					match(T__0);
440 					}
441 				}
442 
443 				}
444 				break;
445 			case 3:
446 				enterOuterAlt(_localctx, 3);
447 				{
448 				setState(523);
449 				branchStatement();
450 				setState(525);
451 				_la = _input.LA(1);
452 				if (_la==T__0) {
453 					{
454 					setState(524);
455 					match(T__0);
456 					}
457 				}
458 
459 				}
460 				break;
461 			case 4:
462 				enterOuterAlt(_localctx, 4);
463 				{
464 				setState(527);
465 				labeledStatement();
466 				}
467 				break;
468 			case 5:
469 				enterOuterAlt(_localctx, 5);
470 				{
471 				setState(528);
472 				controlTransferStatement();
473 				setState(530);
474 				_la = _input.LA(1);
475 				if (_la==T__0) {
476 					{
477 					setState(529);
478 					match(T__0);
479 					}
480 				}
481 
482 				}
483 				break;
484 			case 6:
485 				enterOuterAlt(_localctx, 6);
486 				{
487 				setState(532);
488 				deferStatement();
489 				setState(534);
490 				_la = _input.LA(1);
491 				if (_la==T__0) {
492 					{
493 					setState(533);
494 					match(T__0);
495 					}
496 				}
497 
498 				}
499 				break;
500 			case 7:
501 				enterOuterAlt(_localctx, 7);
502 				{
503 				setState(536);
504 				doStatement();
505 				setState(538);
506 				_la = _input.LA(1);
507 				if (_la==T__1) {
508 					{
509 					setState(537);
510 					match(T__1);
511 					}
512 				}
513 
514 				}
515 				break;
516 			case 8:
517 				enterOuterAlt(_localctx, 8);
518 				{
519 				setState(540);
520 				compilerControlStatement();
521 				setState(542);
522 				_la = _input.LA(1);
523 				if (_la==T__0) {
524 					{
525 					setState(541);
526 					match(T__0);
527 					}
528 				}
529 
530 				}
531 				break;
532 			case 9:
533 				enterOuterAlt(_localctx, 9);
534 				{
535 				setState(544);
536 				expression();
537 				setState(546);
538 				_la = _input.LA(1);
539 				if (_la==T__0) {
540 					{
541 					setState(545);
542 					match(T__0);
543 					}
544 				}
545 
546 				}
547 				break;
548 			}
549 		}
550 		catch (RecognitionException re) {
551 			_localctx.exception = re;
552 			_errHandler.reportError(this, re);
553 			_errHandler.recover(this, re);
554 		}
555 		finally {
556 			exitRule();
557 		}
558 		return _localctx;
559 	}
560 
561 	public static class StatementsContext extends ParserRuleContext {
562 		public List<StatementContext> statement() {
563 			return getRuleContexts(StatementContext.class);
564 		}
565 		public StatementContext statement(int i) {
566 			return getRuleContext(StatementContext.class,i);
567 		}
568 		public StatementsContext(ParserRuleContext parent, int invokingState) {
569 			super(parent, invokingState);
570 		}
571 		@Override public int getRuleIndex() { return RULE_statements; }
572 		@Override
573 		public void enterRule(ParseTreeListener listener) {
574 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterStatements(this);
575 		}
576 		@Override
577 		public void exitRule(ParseTreeListener listener) {
578 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitStatements(this);
579 		}
580 	}
581 
582 	public final StatementsContext statements() throws RecognitionException {
583 		StatementsContext _localctx = new StatementsContext(_ctx, getState());
584 		enterRule(_localctx, 4, RULE_statements);
585 		int _la;
586 		try {
587 			enterOuterAlt(_localctx, 1);
588 			{
589 			setState(551); 
590 			_errHandler.sync(this);
591 			_la = _input.LA(1);
592 			do {
593 				{
594 				{
595 				setState(550);
596 				statement();
597 				}
598 				}
599 				setState(553); 
600 				_errHandler.sync(this);
601 				_la = _input.LA(1);
602 			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0) );
603 			}
604 		}
605 		catch (RecognitionException re) {
606 			_localctx.exception = re;
607 			_errHandler.reportError(this, re);
608 			_errHandler.recover(this, re);
609 		}
610 		finally {
611 			exitRule();
612 		}
613 		return _localctx;
614 	}
615 
616 	public static class LoopStatementContext extends ParserRuleContext {
617 		public ForStatementContext forStatement() {
618 			return getRuleContext(ForStatementContext.class,0);
619 		}
620 		public ForInStatementContext forInStatement() {
621 			return getRuleContext(ForInStatementContext.class,0);
622 		}
623 		public WhileStatementContext whileStatement() {
624 			return getRuleContext(WhileStatementContext.class,0);
625 		}
626 		public RepeatWhileStatementContext repeatWhileStatement() {
627 			return getRuleContext(RepeatWhileStatementContext.class,0);
628 		}
629 		public LoopStatementContext(ParserRuleContext parent, int invokingState) {
630 			super(parent, invokingState);
631 		}
632 		@Override public int getRuleIndex() { return RULE_loopStatement; }
633 		@Override
634 		public void enterRule(ParseTreeListener listener) {
635 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLoopStatement(this);
636 		}
637 		@Override
638 		public void exitRule(ParseTreeListener listener) {
639 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLoopStatement(this);
640 		}
641 	}
642 
643 	public final LoopStatementContext loopStatement() throws RecognitionException {
644 		LoopStatementContext _localctx = new LoopStatementContext(_ctx, getState());
645 		enterRule(_localctx, 6, RULE_loopStatement);
646 		try {
647 			setState(559);
648 			_errHandler.sync(this);
649 			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
650 			case 1:
651 				enterOuterAlt(_localctx, 1);
652 				{
653 				setState(555);
654 				forStatement();
655 				}
656 				break;
657 			case 2:
658 				enterOuterAlt(_localctx, 2);
659 				{
660 				setState(556);
661 				forInStatement();
662 				}
663 				break;
664 			case 3:
665 				enterOuterAlt(_localctx, 3);
666 				{
667 				setState(557);
668 				whileStatement();
669 				}
670 				break;
671 			case 4:
672 				enterOuterAlt(_localctx, 4);
673 				{
674 				setState(558);
675 				repeatWhileStatement();
676 				}
677 				break;
678 			}
679 		}
680 		catch (RecognitionException re) {
681 			_localctx.exception = re;
682 			_errHandler.reportError(this, re);
683 			_errHandler.recover(this, re);
684 		}
685 		finally {
686 			exitRule();
687 		}
688 		return _localctx;
689 	}
690 
691 	public static class ForStatementContext extends ParserRuleContext {
692 		public CodeBlockContext codeBlock() {
693 			return getRuleContext(CodeBlockContext.class,0);
694 		}
695 		public ForInitContext forInit() {
696 			return getRuleContext(ForInitContext.class,0);
697 		}
698 		public ExpressionContext expression() {
699 			return getRuleContext(ExpressionContext.class,0);
700 		}
701 		public ExpressionListContext expressionList() {
702 			return getRuleContext(ExpressionListContext.class,0);
703 		}
704 		public ForStatementContext(ParserRuleContext parent, int invokingState) {
705 			super(parent, invokingState);
706 		}
707 		@Override public int getRuleIndex() { return RULE_forStatement; }
708 		@Override
709 		public void enterRule(ParseTreeListener listener) {
710 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterForStatement(this);
711 		}
712 		@Override
713 		public void exitRule(ParseTreeListener listener) {
714 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitForStatement(this);
715 		}
716 	}
717 
718 	public final ForStatementContext forStatement() throws RecognitionException {
719 		ForStatementContext _localctx = new ForStatementContext(_ctx, getState());
720 		enterRule(_localctx, 8, RULE_forStatement);
721 		int _la;
722 		try {
723 			setState(589);
724 			_errHandler.sync(this);
725 			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
726 			case 1:
727 				enterOuterAlt(_localctx, 1);
728 				{
729 				setState(561);
730 				match(T__2);
731 				setState(563);
732 				_la = _input.LA(1);
733 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__96 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
734 					{
735 					setState(562);
736 					forInit();
737 					}
738 				}
739 
740 				setState(565);
741 				match(T__0);
742 				setState(567);
743 				_la = _input.LA(1);
744 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
745 					{
746 					setState(566);
747 					expression();
748 					}
749 				}
750 
751 				setState(569);
752 				match(T__0);
753 				setState(571);
754 				_errHandler.sync(this);
755 				switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
756 				case 1:
757 					{
758 					setState(570);
759 					expressionList();
760 					}
761 					break;
762 				}
763 				setState(573);
764 				codeBlock();
765 				}
766 				break;
767 			case 2:
768 				enterOuterAlt(_localctx, 2);
769 				{
770 				setState(574);
771 				match(T__2);
772 				setState(575);
773 				match(T__3);
774 				setState(577);
775 				_la = _input.LA(1);
776 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__96 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
777 					{
778 					setState(576);
779 					forInit();
780 					}
781 				}
782 
783 				setState(579);
784 				match(T__0);
785 				setState(581);
786 				_la = _input.LA(1);
787 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
788 					{
789 					setState(580);
790 					expression();
791 					}
792 				}
793 
794 				setState(583);
795 				match(T__0);
796 				setState(585);
797 				_la = _input.LA(1);
798 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
799 					{
800 					setState(584);
801 					expressionList();
802 					}
803 				}
804 
805 				setState(587);
806 				match(T__4);
807 				setState(588);
808 				codeBlock();
809 				}
810 				break;
811 			}
812 		}
813 		catch (RecognitionException re) {
814 			_localctx.exception = re;
815 			_errHandler.reportError(this, re);
816 			_errHandler.recover(this, re);
817 		}
818 		finally {
819 			exitRule();
820 		}
821 		return _localctx;
822 	}
823 
824 	public static class ForInitContext extends ParserRuleContext {
825 		public VariableDeclarationContext variableDeclaration() {
826 			return getRuleContext(VariableDeclarationContext.class,0);
827 		}
828 		public ExpressionListContext expressionList() {
829 			return getRuleContext(ExpressionListContext.class,0);
830 		}
831 		public ForInitContext(ParserRuleContext parent, int invokingState) {
832 			super(parent, invokingState);
833 		}
834 		@Override public int getRuleIndex() { return RULE_forInit; }
835 		@Override
836 		public void enterRule(ParseTreeListener listener) {
837 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterForInit(this);
838 		}
839 		@Override
840 		public void exitRule(ParseTreeListener listener) {
841 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitForInit(this);
842 		}
843 	}
844 
845 	public final ForInitContext forInit() throws RecognitionException {
846 		ForInitContext _localctx = new ForInitContext(_ctx, getState());
847 		enterRule(_localctx, 10, RULE_forInit);
848 		try {
849 			setState(593);
850 			_errHandler.sync(this);
851 			switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
852 			case 1:
853 				enterOuterAlt(_localctx, 1);
854 				{
855 				setState(591);
856 				variableDeclaration();
857 				}
858 				break;
859 			case 2:
860 				enterOuterAlt(_localctx, 2);
861 				{
862 				setState(592);
863 				expressionList();
864 				}
865 				break;
866 			}
867 		}
868 		catch (RecognitionException re) {
869 			_localctx.exception = re;
870 			_errHandler.reportError(this, re);
871 			_errHandler.recover(this, re);
872 		}
873 		finally {
874 			exitRule();
875 		}
876 		return _localctx;
877 	}
878 
879 	public static class ForInStatementContext extends ParserRuleContext {
880 		public PatternContext pattern() {
881 			return getRuleContext(PatternContext.class,0);
882 		}
883 		public ExpressionContext expression() {
884 			return getRuleContext(ExpressionContext.class,0);
885 		}
886 		public CodeBlockContext codeBlock() {
887 			return getRuleContext(CodeBlockContext.class,0);
888 		}
889 		public WhereClauseContext whereClause() {
890 			return getRuleContext(WhereClauseContext.class,0);
891 		}
892 		public ForInStatementContext(ParserRuleContext parent, int invokingState) {
893 			super(parent, invokingState);
894 		}
895 		@Override public int getRuleIndex() { return RULE_forInStatement; }
896 		@Override
897 		public void enterRule(ParseTreeListener listener) {
898 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterForInStatement(this);
899 		}
900 		@Override
901 		public void exitRule(ParseTreeListener listener) {
902 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitForInStatement(this);
903 		}
904 	}
905 
906 	public final ForInStatementContext forInStatement() throws RecognitionException {
907 		ForInStatementContext _localctx = new ForInStatementContext(_ctx, getState());
908 		enterRule(_localctx, 12, RULE_forInStatement);
909 		int _la;
910 		try {
911 			enterOuterAlt(_localctx, 1);
912 			{
913 			setState(595);
914 			match(T__2);
915 			setState(597);
916 			_la = _input.LA(1);
917 			if (_la==T__5) {
918 				{
919 				setState(596);
920 				match(T__5);
921 				}
922 			}
923 
924 			setState(599);
925 			pattern(0);
926 			setState(600);
927 			match(T__6);
928 			setState(601);
929 			expression();
930 			setState(603);
931 			_la = _input.LA(1);
932 			if (_la==T__27) {
933 				{
934 				setState(602);
935 				whereClause();
936 				}
937 			}
938 
939 			setState(605);
940 			codeBlock();
941 			}
942 		}
943 		catch (RecognitionException re) {
944 			_localctx.exception = re;
945 			_errHandler.reportError(this, re);
946 			_errHandler.recover(this, re);
947 		}
948 		finally {
949 			exitRule();
950 		}
951 		return _localctx;
952 	}
953 
954 	public static class WhileStatementContext extends ParserRuleContext {
955 		public ConditionClauseContext conditionClause() {
956 			return getRuleContext(ConditionClauseContext.class,0);
957 		}
958 		public CodeBlockContext codeBlock() {
959 			return getRuleContext(CodeBlockContext.class,0);
960 		}
961 		public WhileStatementContext(ParserRuleContext parent, int invokingState) {
962 			super(parent, invokingState);
963 		}
964 		@Override public int getRuleIndex() { return RULE_whileStatement; }
965 		@Override
966 		public void enterRule(ParseTreeListener listener) {
967 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWhileStatement(this);
968 		}
969 		@Override
970 		public void exitRule(ParseTreeListener listener) {
971 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWhileStatement(this);
972 		}
973 	}
974 
975 	public final WhileStatementContext whileStatement() throws RecognitionException {
976 		WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState());
977 		enterRule(_localctx, 14, RULE_whileStatement);
978 		try {
979 			enterOuterAlt(_localctx, 1);
980 			{
981 			setState(607);
982 			match(T__7);
983 			setState(608);
984 			conditionClause();
985 			setState(609);
986 			codeBlock();
987 			}
988 		}
989 		catch (RecognitionException re) {
990 			_localctx.exception = re;
991 			_errHandler.reportError(this, re);
992 			_errHandler.recover(this, re);
993 		}
994 		finally {
995 			exitRule();
996 		}
997 		return _localctx;
998 	}
999 
1000 	public static class RepeatWhileStatementContext extends ParserRuleContext {
1001 		public CodeBlockContext codeBlock() {
1002 			return getRuleContext(CodeBlockContext.class,0);
1003 		}
1004 		public ConditionClauseContext conditionClause() {
1005 			return getRuleContext(ConditionClauseContext.class,0);
1006 		}
1007 		public RepeatWhileStatementContext(ParserRuleContext parent, int invokingState) {
1008 			super(parent, invokingState);
1009 		}
1010 		@Override public int getRuleIndex() { return RULE_repeatWhileStatement; }
1011 		@Override
1012 		public void enterRule(ParseTreeListener listener) {
1013 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRepeatWhileStatement(this);
1014 		}
1015 		@Override
1016 		public void exitRule(ParseTreeListener listener) {
1017 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRepeatWhileStatement(this);
1018 		}
1019 	}
1020 
1021 	public final RepeatWhileStatementContext repeatWhileStatement() throws RecognitionException {
1022 		RepeatWhileStatementContext _localctx = new RepeatWhileStatementContext(_ctx, getState());
1023 		enterRule(_localctx, 16, RULE_repeatWhileStatement);
1024 		try {
1025 			enterOuterAlt(_localctx, 1);
1026 			{
1027 			setState(611);
1028 			match(T__8);
1029 			setState(612);
1030 			codeBlock();
1031 			setState(613);
1032 			match(T__7);
1033 			setState(614);
1034 			conditionClause();
1035 			}
1036 		}
1037 		catch (RecognitionException re) {
1038 			_localctx.exception = re;
1039 			_errHandler.reportError(this, re);
1040 			_errHandler.recover(this, re);
1041 		}
1042 		finally {
1043 			exitRule();
1044 		}
1045 		return _localctx;
1046 	}
1047 
1048 	public static class BranchStatementContext extends ParserRuleContext {
1049 		public IfStatementContext ifStatement() {
1050 			return getRuleContext(IfStatementContext.class,0);
1051 		}
1052 		public GuardStatementContext guardStatement() {
1053 			return getRuleContext(GuardStatementContext.class,0);
1054 		}
1055 		public SwitchStatementContext switchStatement() {
1056 			return getRuleContext(SwitchStatementContext.class,0);
1057 		}
1058 		public BranchStatementContext(ParserRuleContext parent, int invokingState) {
1059 			super(parent, invokingState);
1060 		}
1061 		@Override public int getRuleIndex() { return RULE_branchStatement; }
1062 		@Override
1063 		public void enterRule(ParseTreeListener listener) {
1064 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBranchStatement(this);
1065 		}
1066 		@Override
1067 		public void exitRule(ParseTreeListener listener) {
1068 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBranchStatement(this);
1069 		}
1070 	}
1071 
1072 	public final BranchStatementContext branchStatement() throws RecognitionException {
1073 		BranchStatementContext _localctx = new BranchStatementContext(_ctx, getState());
1074 		enterRule(_localctx, 18, RULE_branchStatement);
1075 		try {
1076 			setState(619);
1077 			switch (_input.LA(1)) {
1078 			case T__9:
1079 				enterOuterAlt(_localctx, 1);
1080 				{
1081 				setState(616);
1082 				ifStatement();
1083 				}
1084 				break;
1085 			case T__11:
1086 				enterOuterAlt(_localctx, 2);
1087 				{
1088 				setState(617);
1089 				guardStatement();
1090 				}
1091 				break;
1092 			case T__12:
1093 				enterOuterAlt(_localctx, 3);
1094 				{
1095 				setState(618);
1096 				switchStatement();
1097 				}
1098 				break;
1099 			default:
1100 				throw new NoViableAltException(this);
1101 			}
1102 		}
1103 		catch (RecognitionException re) {
1104 			_localctx.exception = re;
1105 			_errHandler.reportError(this, re);
1106 			_errHandler.recover(this, re);
1107 		}
1108 		finally {
1109 			exitRule();
1110 		}
1111 		return _localctx;
1112 	}
1113 
1114 	public static class IfStatementContext extends ParserRuleContext {
1115 		public ConditionClauseContext conditionClause() {
1116 			return getRuleContext(ConditionClauseContext.class,0);
1117 		}
1118 		public CodeBlockContext codeBlock() {
1119 			return getRuleContext(CodeBlockContext.class,0);
1120 		}
1121 		public ElseClauseContext elseClause() {
1122 			return getRuleContext(ElseClauseContext.class,0);
1123 		}
1124 		public IfStatementContext(ParserRuleContext parent, int invokingState) {
1125 			super(parent, invokingState);
1126 		}
1127 		@Override public int getRuleIndex() { return RULE_ifStatement; }
1128 		@Override
1129 		public void enterRule(ParseTreeListener listener) {
1130 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterIfStatement(this);
1131 		}
1132 		@Override
1133 		public void exitRule(ParseTreeListener listener) {
1134 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitIfStatement(this);
1135 		}
1136 	}
1137 
1138 	public final IfStatementContext ifStatement() throws RecognitionException {
1139 		IfStatementContext _localctx = new IfStatementContext(_ctx, getState());
1140 		enterRule(_localctx, 20, RULE_ifStatement);
1141 		int _la;
1142 		try {
1143 			enterOuterAlt(_localctx, 1);
1144 			{
1145 			setState(621);
1146 			match(T__9);
1147 			setState(622);
1148 			conditionClause();
1149 			setState(623);
1150 			codeBlock();
1151 			setState(625);
1152 			_la = _input.LA(1);
1153 			if (_la==T__10) {
1154 				{
1155 				setState(624);
1156 				elseClause();
1157 				}
1158 			}
1159 
1160 			}
1161 		}
1162 		catch (RecognitionException re) {
1163 			_localctx.exception = re;
1164 			_errHandler.reportError(this, re);
1165 			_errHandler.recover(this, re);
1166 		}
1167 		finally {
1168 			exitRule();
1169 		}
1170 		return _localctx;
1171 	}
1172 
1173 	public static class ElseClauseContext extends ParserRuleContext {
1174 		public CodeBlockContext codeBlock() {
1175 			return getRuleContext(CodeBlockContext.class,0);
1176 		}
1177 		public IfStatementContext ifStatement() {
1178 			return getRuleContext(IfStatementContext.class,0);
1179 		}
1180 		public ElseClauseContext(ParserRuleContext parent, int invokingState) {
1181 			super(parent, invokingState);
1182 		}
1183 		@Override public int getRuleIndex() { return RULE_elseClause; }
1184 		@Override
1185 		public void enterRule(ParseTreeListener listener) {
1186 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterElseClause(this);
1187 		}
1188 		@Override
1189 		public void exitRule(ParseTreeListener listener) {
1190 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitElseClause(this);
1191 		}
1192 	}
1193 
1194 	public final ElseClauseContext elseClause() throws RecognitionException {
1195 		ElseClauseContext _localctx = new ElseClauseContext(_ctx, getState());
1196 		enterRule(_localctx, 22, RULE_elseClause);
1197 		try {
1198 			setState(631);
1199 			_errHandler.sync(this);
1200 			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
1201 			case 1:
1202 				enterOuterAlt(_localctx, 1);
1203 				{
1204 				setState(627);
1205 				match(T__10);
1206 				setState(628);
1207 				codeBlock();
1208 				}
1209 				break;
1210 			case 2:
1211 				enterOuterAlt(_localctx, 2);
1212 				{
1213 				setState(629);
1214 				match(T__10);
1215 				setState(630);
1216 				ifStatement();
1217 				}
1218 				break;
1219 			}
1220 		}
1221 		catch (RecognitionException re) {
1222 			_localctx.exception = re;
1223 			_errHandler.reportError(this, re);
1224 			_errHandler.recover(this, re);
1225 		}
1226 		finally {
1227 			exitRule();
1228 		}
1229 		return _localctx;
1230 	}
1231 
1232 	public static class GuardStatementContext extends ParserRuleContext {
1233 		public ConditionClauseContext conditionClause() {
1234 			return getRuleContext(ConditionClauseContext.class,0);
1235 		}
1236 		public CodeBlockContext codeBlock() {
1237 			return getRuleContext(CodeBlockContext.class,0);
1238 		}
1239 		public GuardStatementContext(ParserRuleContext parent, int invokingState) {
1240 			super(parent, invokingState);
1241 		}
1242 		@Override public int getRuleIndex() { return RULE_guardStatement; }
1243 		@Override
1244 		public void enterRule(ParseTreeListener listener) {
1245 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGuardStatement(this);
1246 		}
1247 		@Override
1248 		public void exitRule(ParseTreeListener listener) {
1249 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGuardStatement(this);
1250 		}
1251 	}
1252 
1253 	public final GuardStatementContext guardStatement() throws RecognitionException {
1254 		GuardStatementContext _localctx = new GuardStatementContext(_ctx, getState());
1255 		enterRule(_localctx, 24, RULE_guardStatement);
1256 		try {
1257 			enterOuterAlt(_localctx, 1);
1258 			{
1259 			setState(633);
1260 			match(T__11);
1261 			setState(634);
1262 			conditionClause();
1263 			setState(635);
1264 			match(T__10);
1265 			setState(636);
1266 			codeBlock();
1267 			}
1268 		}
1269 		catch (RecognitionException re) {
1270 			_localctx.exception = re;
1271 			_errHandler.reportError(this, re);
1272 			_errHandler.recover(this, re);
1273 		}
1274 		finally {
1275 			exitRule();
1276 		}
1277 		return _localctx;
1278 	}
1279 
1280 	public static class SwitchStatementContext extends ParserRuleContext {
1281 		public ExpressionContext expression() {
1282 			return getRuleContext(ExpressionContext.class,0);
1283 		}
1284 		public SwitchCasesContext switchCases() {
1285 			return getRuleContext(SwitchCasesContext.class,0);
1286 		}
1287 		public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
1288 			super(parent, invokingState);
1289 		}
1290 		@Override public int getRuleIndex() { return RULE_switchStatement; }
1291 		@Override
1292 		public void enterRule(ParseTreeListener listener) {
1293 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSwitchStatement(this);
1294 		}
1295 		@Override
1296 		public void exitRule(ParseTreeListener listener) {
1297 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSwitchStatement(this);
1298 		}
1299 	}
1300 
1301 	public final SwitchStatementContext switchStatement() throws RecognitionException {
1302 		SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
1303 		enterRule(_localctx, 26, RULE_switchStatement);
1304 		int _la;
1305 		try {
1306 			enterOuterAlt(_localctx, 1);
1307 			{
1308 			setState(638);
1309 			match(T__12);
1310 			setState(639);
1311 			expression();
1312 			setState(640);
1313 			match(T__13);
1314 			setState(642);
1315 			_la = _input.LA(1);
1316 			if (_la==T__5 || _la==T__16) {
1317 				{
1318 				setState(641);
1319 				switchCases();
1320 				}
1321 			}
1322 
1323 			setState(644);
1324 			match(T__14);
1325 			}
1326 		}
1327 		catch (RecognitionException re) {
1328 			_localctx.exception = re;
1329 			_errHandler.reportError(this, re);
1330 			_errHandler.recover(this, re);
1331 		}
1332 		finally {
1333 			exitRule();
1334 		}
1335 		return _localctx;
1336 	}
1337 
1338 	public static class SwitchCasesContext extends ParserRuleContext {
1339 		public SwitchCaseContext switchCase() {
1340 			return getRuleContext(SwitchCaseContext.class,0);
1341 		}
1342 		public SwitchCasesContext switchCases() {
1343 			return getRuleContext(SwitchCasesContext.class,0);
1344 		}
1345 		public SwitchCasesContext(ParserRuleContext parent, int invokingState) {
1346 			super(parent, invokingState);
1347 		}
1348 		@Override public int getRuleIndex() { return RULE_switchCases; }
1349 		@Override
1350 		public void enterRule(ParseTreeListener listener) {
1351 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSwitchCases(this);
1352 		}
1353 		@Override
1354 		public void exitRule(ParseTreeListener listener) {
1355 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSwitchCases(this);
1356 		}
1357 	}
1358 
1359 	public final SwitchCasesContext switchCases() throws RecognitionException {
1360 		SwitchCasesContext _localctx = new SwitchCasesContext(_ctx, getState());
1361 		enterRule(_localctx, 28, RULE_switchCases);
1362 		int _la;
1363 		try {
1364 			enterOuterAlt(_localctx, 1);
1365 			{
1366 			setState(646);
1367 			switchCase();
1368 			setState(648);
1369 			_la = _input.LA(1);
1370 			if (_la==T__5 || _la==T__16) {
1371 				{
1372 				setState(647);
1373 				switchCases();
1374 				}
1375 			}
1376 
1377 			}
1378 		}
1379 		catch (RecognitionException re) {
1380 			_localctx.exception = re;
1381 			_errHandler.reportError(this, re);
1382 			_errHandler.recover(this, re);
1383 		}
1384 		finally {
1385 			exitRule();
1386 		}
1387 		return _localctx;
1388 	}
1389 
1390 	public static class SwitchCaseContext extends ParserRuleContext {
1391 		public CaseLabelContext caseLabel() {
1392 			return getRuleContext(CaseLabelContext.class,0);
1393 		}
1394 		public StatementsContext statements() {
1395 			return getRuleContext(StatementsContext.class,0);
1396 		}
1397 		public DefaultLabelContext defaultLabel() {
1398 			return getRuleContext(DefaultLabelContext.class,0);
1399 		}
1400 		public SwitchCaseContext(ParserRuleContext parent, int invokingState) {
1401 			super(parent, invokingState);
1402 		}
1403 		@Override public int getRuleIndex() { return RULE_switchCase; }
1404 		@Override
1405 		public void enterRule(ParseTreeListener listener) {
1406 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSwitchCase(this);
1407 		}
1408 		@Override
1409 		public void exitRule(ParseTreeListener listener) {
1410 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSwitchCase(this);
1411 		}
1412 	}
1413 
1414 	public final SwitchCaseContext switchCase() throws RecognitionException {
1415 		SwitchCaseContext _localctx = new SwitchCaseContext(_ctx, getState());
1416 		enterRule(_localctx, 30, RULE_switchCase);
1417 		try {
1418 			setState(662);
1419 			_errHandler.sync(this);
1420 			switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
1421 			case 1:
1422 				enterOuterAlt(_localctx, 1);
1423 				{
1424 				setState(650);
1425 				caseLabel();
1426 				setState(651);
1427 				statements();
1428 				}
1429 				break;
1430 			case 2:
1431 				enterOuterAlt(_localctx, 2);
1432 				{
1433 				setState(653);
1434 				defaultLabel();
1435 				setState(654);
1436 				statements();
1437 				}
1438 				break;
1439 			case 3:
1440 				enterOuterAlt(_localctx, 3);
1441 				{
1442 				setState(656);
1443 				caseLabel();
1444 				setState(657);
1445 				match(T__0);
1446 				}
1447 				break;
1448 			case 4:
1449 				enterOuterAlt(_localctx, 4);
1450 				{
1451 				setState(659);
1452 				defaultLabel();
1453 				setState(660);
1454 				match(T__0);
1455 				}
1456 				break;
1457 			}
1458 		}
1459 		catch (RecognitionException re) {
1460 			_localctx.exception = re;
1461 			_errHandler.reportError(this, re);
1462 			_errHandler.recover(this, re);
1463 		}
1464 		finally {
1465 			exitRule();
1466 		}
1467 		return _localctx;
1468 	}
1469 
1470 	public static class CaseLabelContext extends ParserRuleContext {
1471 		public CaseItemListContext caseItemList() {
1472 			return getRuleContext(CaseItemListContext.class,0);
1473 		}
1474 		public CaseLabelContext(ParserRuleContext parent, int invokingState) {
1475 			super(parent, invokingState);
1476 		}
1477 		@Override public int getRuleIndex() { return RULE_caseLabel; }
1478 		@Override
1479 		public void enterRule(ParseTreeListener listener) {
1480 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaseLabel(this);
1481 		}
1482 		@Override
1483 		public void exitRule(ParseTreeListener listener) {
1484 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaseLabel(this);
1485 		}
1486 	}
1487 
1488 	public final CaseLabelContext caseLabel() throws RecognitionException {
1489 		CaseLabelContext _localctx = new CaseLabelContext(_ctx, getState());
1490 		enterRule(_localctx, 32, RULE_caseLabel);
1491 		try {
1492 			enterOuterAlt(_localctx, 1);
1493 			{
1494 			setState(664);
1495 			match(T__5);
1496 			setState(665);
1497 			caseItemList();
1498 			setState(666);
1499 			match(T__1);
1500 			}
1501 		}
1502 		catch (RecognitionException re) {
1503 			_localctx.exception = re;
1504 			_errHandler.reportError(this, re);
1505 			_errHandler.recover(this, re);
1506 		}
1507 		finally {
1508 			exitRule();
1509 		}
1510 		return _localctx;
1511 	}
1512 
1513 	public static class CaseItemListContext extends ParserRuleContext {
1514 		public List<CaseItemContext> caseItem() {
1515 			return getRuleContexts(CaseItemContext.class);
1516 		}
1517 		public CaseItemContext caseItem(int i) {
1518 			return getRuleContext(CaseItemContext.class,i);
1519 		}
1520 		public CaseItemListContext(ParserRuleContext parent, int invokingState) {
1521 			super(parent, invokingState);
1522 		}
1523 		@Override public int getRuleIndex() { return RULE_caseItemList; }
1524 		@Override
1525 		public void enterRule(ParseTreeListener listener) {
1526 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaseItemList(this);
1527 		}
1528 		@Override
1529 		public void exitRule(ParseTreeListener listener) {
1530 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaseItemList(this);
1531 		}
1532 	}
1533 
1534 	public final CaseItemListContext caseItemList() throws RecognitionException {
1535 		CaseItemListContext _localctx = new CaseItemListContext(_ctx, getState());
1536 		enterRule(_localctx, 34, RULE_caseItemList);
1537 		int _la;
1538 		try {
1539 			enterOuterAlt(_localctx, 1);
1540 			{
1541 			setState(668);
1542 			caseItem();
1543 			setState(673);
1544 			_errHandler.sync(this);
1545 			_la = _input.LA(1);
1546 			while (_la==T__15) {
1547 				{
1548 				{
1549 				setState(669);
1550 				match(T__15);
1551 				setState(670);
1552 				caseItem();
1553 				}
1554 				}
1555 				setState(675);
1556 				_errHandler.sync(this);
1557 				_la = _input.LA(1);
1558 			}
1559 			}
1560 		}
1561 		catch (RecognitionException re) {
1562 			_localctx.exception = re;
1563 			_errHandler.reportError(this, re);
1564 			_errHandler.recover(this, re);
1565 		}
1566 		finally {
1567 			exitRule();
1568 		}
1569 		return _localctx;
1570 	}
1571 
1572 	public static class CaseItemContext extends ParserRuleContext {
1573 		public PatternContext pattern() {
1574 			return getRuleContext(PatternContext.class,0);
1575 		}
1576 		public WhereClauseContext whereClause() {
1577 			return getRuleContext(WhereClauseContext.class,0);
1578 		}
1579 		public CaseItemContext(ParserRuleContext parent, int invokingState) {
1580 			super(parent, invokingState);
1581 		}
1582 		@Override public int getRuleIndex() { return RULE_caseItem; }
1583 		@Override
1584 		public void enterRule(ParseTreeListener listener) {
1585 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaseItem(this);
1586 		}
1587 		@Override
1588 		public void exitRule(ParseTreeListener listener) {
1589 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaseItem(this);
1590 		}
1591 	}
1592 
1593 	public final CaseItemContext caseItem() throws RecognitionException {
1594 		CaseItemContext _localctx = new CaseItemContext(_ctx, getState());
1595 		enterRule(_localctx, 36, RULE_caseItem);
1596 		int _la;
1597 		try {
1598 			enterOuterAlt(_localctx, 1);
1599 			{
1600 			setState(676);
1601 			pattern(0);
1602 			setState(678);
1603 			_la = _input.LA(1);
1604 			if (_la==T__27) {
1605 				{
1606 				setState(677);
1607 				whereClause();
1608 				}
1609 			}
1610 
1611 			}
1612 		}
1613 		catch (RecognitionException re) {
1614 			_localctx.exception = re;
1615 			_errHandler.reportError(this, re);
1616 			_errHandler.recover(this, re);
1617 		}
1618 		finally {
1619 			exitRule();
1620 		}
1621 		return _localctx;
1622 	}
1623 
1624 	public static class DefaultLabelContext extends ParserRuleContext {
1625 		public DefaultLabelContext(ParserRuleContext parent, int invokingState) {
1626 			super(parent, invokingState);
1627 		}
1628 		@Override public int getRuleIndex() { return RULE_defaultLabel; }
1629 		@Override
1630 		public void enterRule(ParseTreeListener listener) {
1631 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDefaultLabel(this);
1632 		}
1633 		@Override
1634 		public void exitRule(ParseTreeListener listener) {
1635 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDefaultLabel(this);
1636 		}
1637 	}
1638 
1639 	public final DefaultLabelContext defaultLabel() throws RecognitionException {
1640 		DefaultLabelContext _localctx = new DefaultLabelContext(_ctx, getState());
1641 		enterRule(_localctx, 38, RULE_defaultLabel);
1642 		try {
1643 			enterOuterAlt(_localctx, 1);
1644 			{
1645 			setState(680);
1646 			match(T__16);
1647 			setState(681);
1648 			match(T__1);
1649 			}
1650 		}
1651 		catch (RecognitionException re) {
1652 			_localctx.exception = re;
1653 			_errHandler.reportError(this, re);
1654 			_errHandler.recover(this, re);
1655 		}
1656 		finally {
1657 			exitRule();
1658 		}
1659 		return _localctx;
1660 	}
1661 
1662 	public static class LabeledStatementContext extends ParserRuleContext {
1663 		public StatementLabelContext statementLabel() {
1664 			return getRuleContext(StatementLabelContext.class,0);
1665 		}
1666 		public LoopStatementContext loopStatement() {
1667 			return getRuleContext(LoopStatementContext.class,0);
1668 		}
1669 		public SwitchStatementContext switchStatement() {
1670 			return getRuleContext(SwitchStatementContext.class,0);
1671 		}
1672 		public LabeledStatementContext(ParserRuleContext parent, int invokingState) {
1673 			super(parent, invokingState);
1674 		}
1675 		@Override public int getRuleIndex() { return RULE_labeledStatement; }
1676 		@Override
1677 		public void enterRule(ParseTreeListener listener) {
1678 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLabeledStatement(this);
1679 		}
1680 		@Override
1681 		public void exitRule(ParseTreeListener listener) {
1682 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLabeledStatement(this);
1683 		}
1684 	}
1685 
1686 	public final LabeledStatementContext labeledStatement() throws RecognitionException {
1687 		LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState());
1688 		enterRule(_localctx, 40, RULE_labeledStatement);
1689 		try {
1690 			setState(689);
1691 			_errHandler.sync(this);
1692 			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
1693 			case 1:
1694 				enterOuterAlt(_localctx, 1);
1695 				{
1696 				setState(683);
1697 				statementLabel();
1698 				setState(684);
1699 				loopStatement();
1700 				}
1701 				break;
1702 			case 2:
1703 				enterOuterAlt(_localctx, 2);
1704 				{
1705 				setState(686);
1706 				statementLabel();
1707 				setState(687);
1708 				switchStatement();
1709 				}
1710 				break;
1711 			}
1712 		}
1713 		catch (RecognitionException re) {
1714 			_localctx.exception = re;
1715 			_errHandler.reportError(this, re);
1716 			_errHandler.recover(this, re);
1717 		}
1718 		finally {
1719 			exitRule();
1720 		}
1721 		return _localctx;
1722 	}
1723 
1724 	public static class StatementLabelContext extends ParserRuleContext {
1725 		public LabelNameContext labelName() {
1726 			return getRuleContext(LabelNameContext.class,0);
1727 		}
1728 		public StatementLabelContext(ParserRuleContext parent, int invokingState) {
1729 			super(parent, invokingState);
1730 		}
1731 		@Override public int getRuleIndex() { return RULE_statementLabel; }
1732 		@Override
1733 		public void enterRule(ParseTreeListener listener) {
1734 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterStatementLabel(this);
1735 		}
1736 		@Override
1737 		public void exitRule(ParseTreeListener listener) {
1738 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitStatementLabel(this);
1739 		}
1740 	}
1741 
1742 	public final StatementLabelContext statementLabel() throws RecognitionException {
1743 		StatementLabelContext _localctx = new StatementLabelContext(_ctx, getState());
1744 		enterRule(_localctx, 42, RULE_statementLabel);
1745 		try {
1746 			enterOuterAlt(_localctx, 1);
1747 			{
1748 			setState(691);
1749 			labelName();
1750 			setState(692);
1751 			match(T__1);
1752 			}
1753 		}
1754 		catch (RecognitionException re) {
1755 			_localctx.exception = re;
1756 			_errHandler.reportError(this, re);
1757 			_errHandler.recover(this, re);
1758 		}
1759 		finally {
1760 			exitRule();
1761 		}
1762 		return _localctx;
1763 	}
1764 
1765 	public static class LabelNameContext extends ParserRuleContext {
1766 		public IdentifierContext identifier() {
1767 			return getRuleContext(IdentifierContext.class,0);
1768 		}
1769 		public LabelNameContext(ParserRuleContext parent, int invokingState) {
1770 			super(parent, invokingState);
1771 		}
1772 		@Override public int getRuleIndex() { return RULE_labelName; }
1773 		@Override
1774 		public void enterRule(ParseTreeListener listener) {
1775 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLabelName(this);
1776 		}
1777 		@Override
1778 		public void exitRule(ParseTreeListener listener) {
1779 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLabelName(this);
1780 		}
1781 	}
1782 
1783 	public final LabelNameContext labelName() throws RecognitionException {
1784 		LabelNameContext _localctx = new LabelNameContext(_ctx, getState());
1785 		enterRule(_localctx, 44, RULE_labelName);
1786 		try {
1787 			enterOuterAlt(_localctx, 1);
1788 			{
1789 			setState(694);
1790 			identifier();
1791 			}
1792 		}
1793 		catch (RecognitionException re) {
1794 			_localctx.exception = re;
1795 			_errHandler.reportError(this, re);
1796 			_errHandler.recover(this, re);
1797 		}
1798 		finally {
1799 			exitRule();
1800 		}
1801 		return _localctx;
1802 	}
1803 
1804 	public static class ControlTransferStatementContext extends ParserRuleContext {
1805 		public BreakStatementContext breakStatement() {
1806 			return getRuleContext(BreakStatementContext.class,0);
1807 		}
1808 		public ContinueStatementContext continueStatement() {
1809 			return getRuleContext(ContinueStatementContext.class,0);
1810 		}
1811 		public FallthroughStatementContext fallthroughStatement() {
1812 			return getRuleContext(FallthroughStatementContext.class,0);
1813 		}
1814 		public ReturnStatementContext returnStatement() {
1815 			return getRuleContext(ReturnStatementContext.class,0);
1816 		}
1817 		public ThrowStatementContext throwStatement() {
1818 			return getRuleContext(ThrowStatementContext.class,0);
1819 		}
1820 		public ControlTransferStatementContext(ParserRuleContext parent, int invokingState) {
1821 			super(parent, invokingState);
1822 		}
1823 		@Override public int getRuleIndex() { return RULE_controlTransferStatement; }
1824 		@Override
1825 		public void enterRule(ParseTreeListener listener) {
1826 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterControlTransferStatement(this);
1827 		}
1828 		@Override
1829 		public void exitRule(ParseTreeListener listener) {
1830 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitControlTransferStatement(this);
1831 		}
1832 	}
1833 
1834 	public final ControlTransferStatementContext controlTransferStatement() throws RecognitionException {
1835 		ControlTransferStatementContext _localctx = new ControlTransferStatementContext(_ctx, getState());
1836 		enterRule(_localctx, 46, RULE_controlTransferStatement);
1837 		try {
1838 			setState(701);
1839 			switch (_input.LA(1)) {
1840 			case T__17:
1841 				enterOuterAlt(_localctx, 1);
1842 				{
1843 				setState(696);
1844 				breakStatement();
1845 				}
1846 				break;
1847 			case T__18:
1848 				enterOuterAlt(_localctx, 2);
1849 				{
1850 				setState(697);
1851 				continueStatement();
1852 				}
1853 				break;
1854 			case T__19:
1855 				enterOuterAlt(_localctx, 3);
1856 				{
1857 				setState(698);
1858 				fallthroughStatement();
1859 				}
1860 				break;
1861 			case T__20:
1862 				enterOuterAlt(_localctx, 4);
1863 				{
1864 				setState(699);
1865 				returnStatement();
1866 				}
1867 				break;
1868 			case T__21:
1869 				enterOuterAlt(_localctx, 5);
1870 				{
1871 				setState(700);
1872 				throwStatement();
1873 				}
1874 				break;
1875 			default:
1876 				throw new NoViableAltException(this);
1877 			}
1878 		}
1879 		catch (RecognitionException re) {
1880 			_localctx.exception = re;
1881 			_errHandler.reportError(this, re);
1882 			_errHandler.recover(this, re);
1883 		}
1884 		finally {
1885 			exitRule();
1886 		}
1887 		return _localctx;
1888 	}
1889 
1890 	public static class BreakStatementContext extends ParserRuleContext {
1891 		public LabelNameContext labelName() {
1892 			return getRuleContext(LabelNameContext.class,0);
1893 		}
1894 		public BreakStatementContext(ParserRuleContext parent, int invokingState) {
1895 			super(parent, invokingState);
1896 		}
1897 		@Override public int getRuleIndex() { return RULE_breakStatement; }
1898 		@Override
1899 		public void enterRule(ParseTreeListener listener) {
1900 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBreakStatement(this);
1901 		}
1902 		@Override
1903 		public void exitRule(ParseTreeListener listener) {
1904 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBreakStatement(this);
1905 		}
1906 	}
1907 
1908 	public final BreakStatementContext breakStatement() throws RecognitionException {
1909 		BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
1910 		enterRule(_localctx, 48, RULE_breakStatement);
1911 		try {
1912 			enterOuterAlt(_localctx, 1);
1913 			{
1914 			setState(703);
1915 			match(T__17);
1916 			setState(705);
1917 			_errHandler.sync(this);
1918 			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
1919 			case 1:
1920 				{
1921 				setState(704);
1922 				labelName();
1923 				}
1924 				break;
1925 			}
1926 			}
1927 		}
1928 		catch (RecognitionException re) {
1929 			_localctx.exception = re;
1930 			_errHandler.reportError(this, re);
1931 			_errHandler.recover(this, re);
1932 		}
1933 		finally {
1934 			exitRule();
1935 		}
1936 		return _localctx;
1937 	}
1938 
1939 	public static class ContinueStatementContext extends ParserRuleContext {
1940 		public LabelNameContext labelName() {
1941 			return getRuleContext(LabelNameContext.class,0);
1942 		}
1943 		public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
1944 			super(parent, invokingState);
1945 		}
1946 		@Override public int getRuleIndex() { return RULE_continueStatement; }
1947 		@Override
1948 		public void enterRule(ParseTreeListener listener) {
1949 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterContinueStatement(this);
1950 		}
1951 		@Override
1952 		public void exitRule(ParseTreeListener listener) {
1953 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitContinueStatement(this);
1954 		}
1955 	}
1956 
1957 	public final ContinueStatementContext continueStatement() throws RecognitionException {
1958 		ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
1959 		enterRule(_localctx, 50, RULE_continueStatement);
1960 		try {
1961 			enterOuterAlt(_localctx, 1);
1962 			{
1963 			setState(707);
1964 			match(T__18);
1965 			setState(709);
1966 			_errHandler.sync(this);
1967 			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
1968 			case 1:
1969 				{
1970 				setState(708);
1971 				labelName();
1972 				}
1973 				break;
1974 			}
1975 			}
1976 		}
1977 		catch (RecognitionException re) {
1978 			_localctx.exception = re;
1979 			_errHandler.reportError(this, re);
1980 			_errHandler.recover(this, re);
1981 		}
1982 		finally {
1983 			exitRule();
1984 		}
1985 		return _localctx;
1986 	}
1987 
1988 	public static class FallthroughStatementContext extends ParserRuleContext {
1989 		public FallthroughStatementContext(ParserRuleContext parent, int invokingState) {
1990 			super(parent, invokingState);
1991 		}
1992 		@Override public int getRuleIndex() { return RULE_fallthroughStatement; }
1993 		@Override
1994 		public void enterRule(ParseTreeListener listener) {
1995 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFallthroughStatement(this);
1996 		}
1997 		@Override
1998 		public void exitRule(ParseTreeListener listener) {
1999 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFallthroughStatement(this);
2000 		}
2001 	}
2002 
2003 	public final FallthroughStatementContext fallthroughStatement() throws RecognitionException {
2004 		FallthroughStatementContext _localctx = new FallthroughStatementContext(_ctx, getState());
2005 		enterRule(_localctx, 52, RULE_fallthroughStatement);
2006 		try {
2007 			enterOuterAlt(_localctx, 1);
2008 			{
2009 			setState(711);
2010 			match(T__19);
2011 			}
2012 		}
2013 		catch (RecognitionException re) {
2014 			_localctx.exception = re;
2015 			_errHandler.reportError(this, re);
2016 			_errHandler.recover(this, re);
2017 		}
2018 		finally {
2019 			exitRule();
2020 		}
2021 		return _localctx;
2022 	}
2023 
2024 	public static class ReturnStatementContext extends ParserRuleContext {
2025 		public ExpressionContext expression() {
2026 			return getRuleContext(ExpressionContext.class,0);
2027 		}
2028 		public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
2029 			super(parent, invokingState);
2030 		}
2031 		@Override public int getRuleIndex() { return RULE_returnStatement; }
2032 		@Override
2033 		public void enterRule(ParseTreeListener listener) {
2034 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterReturnStatement(this);
2035 		}
2036 		@Override
2037 		public void exitRule(ParseTreeListener listener) {
2038 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitReturnStatement(this);
2039 		}
2040 	}
2041 
2042 	public final ReturnStatementContext returnStatement() throws RecognitionException {
2043 		ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
2044 		enterRule(_localctx, 54, RULE_returnStatement);
2045 		try {
2046 			enterOuterAlt(_localctx, 1);
2047 			{
2048 			setState(713);
2049 			match(T__20);
2050 			setState(715);
2051 			_errHandler.sync(this);
2052 			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
2053 			case 1:
2054 				{
2055 				setState(714);
2056 				expression();
2057 				}
2058 				break;
2059 			}
2060 			}
2061 		}
2062 		catch (RecognitionException re) {
2063 			_localctx.exception = re;
2064 			_errHandler.reportError(this, re);
2065 			_errHandler.recover(this, re);
2066 		}
2067 		finally {
2068 			exitRule();
2069 		}
2070 		return _localctx;
2071 	}
2072 
2073 	public static class ThrowStatementContext extends ParserRuleContext {
2074 		public ExpressionContext expression() {
2075 			return getRuleContext(ExpressionContext.class,0);
2076 		}
2077 		public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
2078 			super(parent, invokingState);
2079 		}
2080 		@Override public int getRuleIndex() { return RULE_throwStatement; }
2081 		@Override
2082 		public void enterRule(ParseTreeListener listener) {
2083 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterThrowStatement(this);
2084 		}
2085 		@Override
2086 		public void exitRule(ParseTreeListener listener) {
2087 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitThrowStatement(this);
2088 		}
2089 	}
2090 
2091 	public final ThrowStatementContext throwStatement() throws RecognitionException {
2092 		ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
2093 		enterRule(_localctx, 56, RULE_throwStatement);
2094 		try {
2095 			enterOuterAlt(_localctx, 1);
2096 			{
2097 			setState(717);
2098 			match(T__21);
2099 			setState(718);
2100 			expression();
2101 			}
2102 		}
2103 		catch (RecognitionException re) {
2104 			_localctx.exception = re;
2105 			_errHandler.reportError(this, re);
2106 			_errHandler.recover(this, re);
2107 		}
2108 		finally {
2109 			exitRule();
2110 		}
2111 		return _localctx;
2112 	}
2113 
2114 	public static class DeferStatementContext extends ParserRuleContext {
2115 		public CodeBlockContext codeBlock() {
2116 			return getRuleContext(CodeBlockContext.class,0);
2117 		}
2118 		public DeferStatementContext(ParserRuleContext parent, int invokingState) {
2119 			super(parent, invokingState);
2120 		}
2121 		@Override public int getRuleIndex() { return RULE_deferStatement; }
2122 		@Override
2123 		public void enterRule(ParseTreeListener listener) {
2124 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDeferStatement(this);
2125 		}
2126 		@Override
2127 		public void exitRule(ParseTreeListener listener) {
2128 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDeferStatement(this);
2129 		}
2130 	}
2131 
2132 	public final DeferStatementContext deferStatement() throws RecognitionException {
2133 		DeferStatementContext _localctx = new DeferStatementContext(_ctx, getState());
2134 		enterRule(_localctx, 58, RULE_deferStatement);
2135 		try {
2136 			enterOuterAlt(_localctx, 1);
2137 			{
2138 			setState(720);
2139 			match(T__22);
2140 			setState(721);
2141 			codeBlock();
2142 			}
2143 		}
2144 		catch (RecognitionException re) {
2145 			_localctx.exception = re;
2146 			_errHandler.reportError(this, re);
2147 			_errHandler.recover(this, re);
2148 		}
2149 		finally {
2150 			exitRule();
2151 		}
2152 		return _localctx;
2153 	}
2154 
2155 	public static class DoStatementContext extends ParserRuleContext {
2156 		public CodeBlockContext codeBlock() {
2157 			return getRuleContext(CodeBlockContext.class,0);
2158 		}
2159 		public CatchClausesContext catchClauses() {
2160 			return getRuleContext(CatchClausesContext.class,0);
2161 		}
2162 		public DoStatementContext(ParserRuleContext parent, int invokingState) {
2163 			super(parent, invokingState);
2164 		}
2165 		@Override public int getRuleIndex() { return RULE_doStatement; }
2166 		@Override
2167 		public void enterRule(ParseTreeListener listener) {
2168 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDoStatement(this);
2169 		}
2170 		@Override
2171 		public void exitRule(ParseTreeListener listener) {
2172 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDoStatement(this);
2173 		}
2174 	}
2175 
2176 	public final DoStatementContext doStatement() throws RecognitionException {
2177 		DoStatementContext _localctx = new DoStatementContext(_ctx, getState());
2178 		enterRule(_localctx, 60, RULE_doStatement);
2179 		int _la;
2180 		try {
2181 			enterOuterAlt(_localctx, 1);
2182 			{
2183 			setState(723);
2184 			match(T__23);
2185 			setState(724);
2186 			codeBlock();
2187 			setState(726);
2188 			_la = _input.LA(1);
2189 			if (_la==T__24) {
2190 				{
2191 				setState(725);
2192 				catchClauses();
2193 				}
2194 			}
2195 
2196 			}
2197 		}
2198 		catch (RecognitionException re) {
2199 			_localctx.exception = re;
2200 			_errHandler.reportError(this, re);
2201 			_errHandler.recover(this, re);
2202 		}
2203 		finally {
2204 			exitRule();
2205 		}
2206 		return _localctx;
2207 	}
2208 
2209 	public static class CatchClausesContext extends ParserRuleContext {
2210 		public CatchClauseContext catchClause() {
2211 			return getRuleContext(CatchClauseContext.class,0);
2212 		}
2213 		public CatchClausesContext catchClauses() {
2214 			return getRuleContext(CatchClausesContext.class,0);
2215 		}
2216 		public CatchClausesContext(ParserRuleContext parent, int invokingState) {
2217 			super(parent, invokingState);
2218 		}
2219 		@Override public int getRuleIndex() { return RULE_catchClauses; }
2220 		@Override
2221 		public void enterRule(ParseTreeListener listener) {
2222 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCatchClauses(this);
2223 		}
2224 		@Override
2225 		public void exitRule(ParseTreeListener listener) {
2226 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCatchClauses(this);
2227 		}
2228 	}
2229 
2230 	public final CatchClausesContext catchClauses() throws RecognitionException {
2231 		CatchClausesContext _localctx = new CatchClausesContext(_ctx, getState());
2232 		enterRule(_localctx, 62, RULE_catchClauses);
2233 		int _la;
2234 		try {
2235 			enterOuterAlt(_localctx, 1);
2236 			{
2237 			setState(728);
2238 			catchClause();
2239 			setState(730);
2240 			_la = _input.LA(1);
2241 			if (_la==T__24) {
2242 				{
2243 				setState(729);
2244 				catchClauses();
2245 				}
2246 			}
2247 
2248 			}
2249 		}
2250 		catch (RecognitionException re) {
2251 			_localctx.exception = re;
2252 			_errHandler.reportError(this, re);
2253 			_errHandler.recover(this, re);
2254 		}
2255 		finally {
2256 			exitRule();
2257 		}
2258 		return _localctx;
2259 	}
2260 
2261 	public static class CatchClauseContext extends ParserRuleContext {
2262 		public CodeBlockContext codeBlock() {
2263 			return getRuleContext(CodeBlockContext.class,0);
2264 		}
2265 		public PatternContext pattern() {
2266 			return getRuleContext(PatternContext.class,0);
2267 		}
2268 		public WhereClauseContext whereClause() {
2269 			return getRuleContext(WhereClauseContext.class,0);
2270 		}
2271 		public CatchClauseContext(ParserRuleContext parent, int invokingState) {
2272 			super(parent, invokingState);
2273 		}
2274 		@Override public int getRuleIndex() { return RULE_catchClause; }
2275 		@Override
2276 		public void enterRule(ParseTreeListener listener) {
2277 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCatchClause(this);
2278 		}
2279 		@Override
2280 		public void exitRule(ParseTreeListener listener) {
2281 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCatchClause(this);
2282 		}
2283 	}
2284 
2285 	public final CatchClauseContext catchClause() throws RecognitionException {
2286 		CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
2287 		enterRule(_localctx, 64, RULE_catchClause);
2288 		int _la;
2289 		try {
2290 			enterOuterAlt(_localctx, 1);
2291 			{
2292 			setState(732);
2293 			match(T__24);
2294 			setState(734);
2295 			_errHandler.sync(this);
2296 			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
2297 			case 1:
2298 				{
2299 				setState(733);
2300 				pattern(0);
2301 				}
2302 				break;
2303 			}
2304 			setState(737);
2305 			_la = _input.LA(1);
2306 			if (_la==T__27) {
2307 				{
2308 				setState(736);
2309 				whereClause();
2310 				}
2311 			}
2312 
2313 			setState(739);
2314 			codeBlock();
2315 			}
2316 		}
2317 		catch (RecognitionException re) {
2318 			_localctx.exception = re;
2319 			_errHandler.reportError(this, re);
2320 			_errHandler.recover(this, re);
2321 		}
2322 		finally {
2323 			exitRule();
2324 		}
2325 		return _localctx;
2326 	}
2327 
2328 	public static class ConditionClauseContext extends ParserRuleContext {
2329 		public ExpressionContext expression() {
2330 			return getRuleContext(ExpressionContext.class,0);
2331 		}
2332 		public ConditionListContext conditionList() {
2333 			return getRuleContext(ConditionListContext.class,0);
2334 		}
2335 		public AvailabilityConditionContext availabilityCondition() {
2336 			return getRuleContext(AvailabilityConditionContext.class,0);
2337 		}
2338 		public ConditionClauseContext(ParserRuleContext parent, int invokingState) {
2339 			super(parent, invokingState);
2340 		}
2341 		@Override public int getRuleIndex() { return RULE_conditionClause; }
2342 		@Override
2343 		public void enterRule(ParseTreeListener listener) {
2344 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterConditionClause(this);
2345 		}
2346 		@Override
2347 		public void exitRule(ParseTreeListener listener) {
2348 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitConditionClause(this);
2349 		}
2350 	}
2351 
2352 	public final ConditionClauseContext conditionClause() throws RecognitionException {
2353 		ConditionClauseContext _localctx = new ConditionClauseContext(_ctx, getState());
2354 		enterRule(_localctx, 66, RULE_conditionClause);
2355 		try {
2356 			setState(751);
2357 			_errHandler.sync(this);
2358 			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
2359 			case 1:
2360 				enterOuterAlt(_localctx, 1);
2361 				{
2362 				setState(741);
2363 				expression();
2364 				}
2365 				break;
2366 			case 2:
2367 				enterOuterAlt(_localctx, 2);
2368 				{
2369 				setState(742);
2370 				expression();
2371 				setState(743);
2372 				match(T__15);
2373 				setState(744);
2374 				conditionList();
2375 				}
2376 				break;
2377 			case 3:
2378 				enterOuterAlt(_localctx, 3);
2379 				{
2380 				setState(746);
2381 				conditionList();
2382 				}
2383 				break;
2384 			case 4:
2385 				enterOuterAlt(_localctx, 4);
2386 				{
2387 				setState(747);
2388 				availabilityCondition();
2389 				setState(748);
2390 				match(T__15);
2391 				setState(749);
2392 				expression();
2393 				}
2394 				break;
2395 			}
2396 		}
2397 		catch (RecognitionException re) {
2398 			_localctx.exception = re;
2399 			_errHandler.reportError(this, re);
2400 			_errHandler.recover(this, re);
2401 		}
2402 		finally {
2403 			exitRule();
2404 		}
2405 		return _localctx;
2406 	}
2407 
2408 	public static class ConditionListContext extends ParserRuleContext {
2409 		public List<ConditionContext> condition() {
2410 			return getRuleContexts(ConditionContext.class);
2411 		}
2412 		public ConditionContext condition(int i) {
2413 			return getRuleContext(ConditionContext.class,i);
2414 		}
2415 		public ConditionListContext(ParserRuleContext parent, int invokingState) {
2416 			super(parent, invokingState);
2417 		}
2418 		@Override public int getRuleIndex() { return RULE_conditionList; }
2419 		@Override
2420 		public void enterRule(ParseTreeListener listener) {
2421 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterConditionList(this);
2422 		}
2423 		@Override
2424 		public void exitRule(ParseTreeListener listener) {
2425 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitConditionList(this);
2426 		}
2427 	}
2428 
2429 	public final ConditionListContext conditionList() throws RecognitionException {
2430 		ConditionListContext _localctx = new ConditionListContext(_ctx, getState());
2431 		enterRule(_localctx, 68, RULE_conditionList);
2432 		int _la;
2433 		try {
2434 			enterOuterAlt(_localctx, 1);
2435 			{
2436 			setState(753);
2437 			condition();
2438 			setState(758);
2439 			_errHandler.sync(this);
2440 			_la = _input.LA(1);
2441 			while (_la==T__15) {
2442 				{
2443 				{
2444 				setState(754);
2445 				match(T__15);
2446 				setState(755);
2447 				condition();
2448 				}
2449 				}
2450 				setState(760);
2451 				_errHandler.sync(this);
2452 				_la = _input.LA(1);
2453 			}
2454 			}
2455 		}
2456 		catch (RecognitionException re) {
2457 			_localctx.exception = re;
2458 			_errHandler.reportError(this, re);
2459 			_errHandler.recover(this, re);
2460 		}
2461 		finally {
2462 			exitRule();
2463 		}
2464 		return _localctx;
2465 	}
2466 
2467 	public static class ConditionContext extends ParserRuleContext {
2468 		public AvailabilityConditionContext availabilityCondition() {
2469 			return getRuleContext(AvailabilityConditionContext.class,0);
2470 		}
2471 		public CaseConditionContext caseCondition() {
2472 			return getRuleContext(CaseConditionContext.class,0);
2473 		}
2474 		public OptionalBindingConditionContext optionalBindingCondition() {
2475 			return getRuleContext(OptionalBindingConditionContext.class,0);
2476 		}
2477 		public ConditionContext(ParserRuleContext parent, int invokingState) {
2478 			super(parent, invokingState);
2479 		}
2480 		@Override public int getRuleIndex() { return RULE_condition; }
2481 		@Override
2482 		public void enterRule(ParseTreeListener listener) {
2483 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCondition(this);
2484 		}
2485 		@Override
2486 		public void exitRule(ParseTreeListener listener) {
2487 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCondition(this);
2488 		}
2489 	}
2490 
2491 	public final ConditionContext condition() throws RecognitionException {
2492 		ConditionContext _localctx = new ConditionContext(_ctx, getState());
2493 		enterRule(_localctx, 70, RULE_condition);
2494 		try {
2495 			setState(764);
2496 			switch (_input.LA(1)) {
2497 			case T__28:
2498 				enterOuterAlt(_localctx, 1);
2499 				{
2500 				setState(761);
2501 				availabilityCondition();
2502 				}
2503 				break;
2504 			case T__5:
2505 				enterOuterAlt(_localctx, 2);
2506 				{
2507 				setState(762);
2508 				caseCondition();
2509 				}
2510 				break;
2511 			case T__25:
2512 			case T__26:
2513 				enterOuterAlt(_localctx, 3);
2514 				{
2515 				setState(763);
2516 				optionalBindingCondition();
2517 				}
2518 				break;
2519 			default:
2520 				throw new NoViableAltException(this);
2521 			}
2522 		}
2523 		catch (RecognitionException re) {
2524 			_localctx.exception = re;
2525 			_errHandler.reportError(this, re);
2526 			_errHandler.recover(this, re);
2527 		}
2528 		finally {
2529 			exitRule();
2530 		}
2531 		return _localctx;
2532 	}
2533 
2534 	public static class CaseConditionContext extends ParserRuleContext {
2535 		public PatternContext pattern() {
2536 			return getRuleContext(PatternContext.class,0);
2537 		}
2538 		public InitializerContext initializer() {
2539 			return getRuleContext(InitializerContext.class,0);
2540 		}
2541 		public WhereClauseContext whereClause() {
2542 			return getRuleContext(WhereClauseContext.class,0);
2543 		}
2544 		public CaseConditionContext(ParserRuleContext parent, int invokingState) {
2545 			super(parent, invokingState);
2546 		}
2547 		@Override public int getRuleIndex() { return RULE_caseCondition; }
2548 		@Override
2549 		public void enterRule(ParseTreeListener listener) {
2550 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaseCondition(this);
2551 		}
2552 		@Override
2553 		public void exitRule(ParseTreeListener listener) {
2554 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaseCondition(this);
2555 		}
2556 	}
2557 
2558 	public final CaseConditionContext caseCondition() throws RecognitionException {
2559 		CaseConditionContext _localctx = new CaseConditionContext(_ctx, getState());
2560 		enterRule(_localctx, 72, RULE_caseCondition);
2561 		int _la;
2562 		try {
2563 			enterOuterAlt(_localctx, 1);
2564 			{
2565 			setState(766);
2566 			match(T__5);
2567 			setState(767);
2568 			pattern(0);
2569 			setState(768);
2570 			initializer();
2571 			setState(770);
2572 			_la = _input.LA(1);
2573 			if (_la==T__27) {
2574 				{
2575 				setState(769);
2576 				whereClause();
2577 				}
2578 			}
2579 
2580 			}
2581 		}
2582 		catch (RecognitionException re) {
2583 			_localctx.exception = re;
2584 			_errHandler.reportError(this, re);
2585 			_errHandler.recover(this, re);
2586 		}
2587 		finally {
2588 			exitRule();
2589 		}
2590 		return _localctx;
2591 	}
2592 
2593 	public static class OptionalBindingConditionContext extends ParserRuleContext {
2594 		public OptionalBindingHeadContext optionalBindingHead() {
2595 			return getRuleContext(OptionalBindingHeadContext.class,0);
2596 		}
2597 		public OptionalBindingContinuationListContext optionalBindingContinuationList() {
2598 			return getRuleContext(OptionalBindingContinuationListContext.class,0);
2599 		}
2600 		public WhereClauseContext whereClause() {
2601 			return getRuleContext(WhereClauseContext.class,0);
2602 		}
2603 		public OptionalBindingConditionContext(ParserRuleContext parent, int invokingState) {
2604 			super(parent, invokingState);
2605 		}
2606 		@Override public int getRuleIndex() { return RULE_optionalBindingCondition; }
2607 		@Override
2608 		public void enterRule(ParseTreeListener listener) {
2609 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOptionalBindingCondition(this);
2610 		}
2611 		@Override
2612 		public void exitRule(ParseTreeListener listener) {
2613 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOptionalBindingCondition(this);
2614 		}
2615 	}
2616 
2617 	public final OptionalBindingConditionContext optionalBindingCondition() throws RecognitionException {
2618 		OptionalBindingConditionContext _localctx = new OptionalBindingConditionContext(_ctx, getState());
2619 		enterRule(_localctx, 74, RULE_optionalBindingCondition);
2620 		int _la;
2621 		try {
2622 			enterOuterAlt(_localctx, 1);
2623 			{
2624 			setState(772);
2625 			optionalBindingHead();
2626 			setState(775);
2627 			_errHandler.sync(this);
2628 			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
2629 			case 1:
2630 				{
2631 				setState(773);
2632 				match(T__15);
2633 				setState(774);
2634 				optionalBindingContinuationList();
2635 				}
2636 				break;
2637 			}
2638 			setState(778);
2639 			_la = _input.LA(1);
2640 			if (_la==T__27) {
2641 				{
2642 				setState(777);
2643 				whereClause();
2644 				}
2645 			}
2646 
2647 			}
2648 		}
2649 		catch (RecognitionException re) {
2650 			_localctx.exception = re;
2651 			_errHandler.reportError(this, re);
2652 			_errHandler.recover(this, re);
2653 		}
2654 		finally {
2655 			exitRule();
2656 		}
2657 		return _localctx;
2658 	}
2659 
2660 	public static class OptionalBindingHeadContext extends ParserRuleContext {
2661 		public PatternContext pattern() {
2662 			return getRuleContext(PatternContext.class,0);
2663 		}
2664 		public InitializerContext initializer() {
2665 			return getRuleContext(InitializerContext.class,0);
2666 		}
2667 		public OptionalBindingHeadContext(ParserRuleContext parent, int invokingState) {
2668 			super(parent, invokingState);
2669 		}
2670 		@Override public int getRuleIndex() { return RULE_optionalBindingHead; }
2671 		@Override
2672 		public void enterRule(ParseTreeListener listener) {
2673 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOptionalBindingHead(this);
2674 		}
2675 		@Override
2676 		public void exitRule(ParseTreeListener listener) {
2677 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOptionalBindingHead(this);
2678 		}
2679 	}
2680 
2681 	public final OptionalBindingHeadContext optionalBindingHead() throws RecognitionException {
2682 		OptionalBindingHeadContext _localctx = new OptionalBindingHeadContext(_ctx, getState());
2683 		enterRule(_localctx, 76, RULE_optionalBindingHead);
2684 		try {
2685 			setState(788);
2686 			switch (_input.LA(1)) {
2687 			case T__25:
2688 				enterOuterAlt(_localctx, 1);
2689 				{
2690 				setState(780);
2691 				match(T__25);
2692 				setState(781);
2693 				pattern(0);
2694 				setState(782);
2695 				initializer();
2696 				}
2697 				break;
2698 			case T__26:
2699 				enterOuterAlt(_localctx, 2);
2700 				{
2701 				setState(784);
2702 				match(T__26);
2703 				setState(785);
2704 				pattern(0);
2705 				setState(786);
2706 				initializer();
2707 				}
2708 				break;
2709 			default:
2710 				throw new NoViableAltException(this);
2711 			}
2712 		}
2713 		catch (RecognitionException re) {
2714 			_localctx.exception = re;
2715 			_errHandler.reportError(this, re);
2716 			_errHandler.recover(this, re);
2717 		}
2718 		finally {
2719 			exitRule();
2720 		}
2721 		return _localctx;
2722 	}
2723 
2724 	public static class OptionalBindingContinuationListContext extends ParserRuleContext {
2725 		public List<OptionalBindingContinuationContext> optionalBindingContinuation() {
2726 			return getRuleContexts(OptionalBindingContinuationContext.class);
2727 		}
2728 		public OptionalBindingContinuationContext optionalBindingContinuation(int i) {
2729 			return getRuleContext(OptionalBindingContinuationContext.class,i);
2730 		}
2731 		public OptionalBindingContinuationListContext(ParserRuleContext parent, int invokingState) {
2732 			super(parent, invokingState);
2733 		}
2734 		@Override public int getRuleIndex() { return RULE_optionalBindingContinuationList; }
2735 		@Override
2736 		public void enterRule(ParseTreeListener listener) {
2737 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOptionalBindingContinuationList(this);
2738 		}
2739 		@Override
2740 		public void exitRule(ParseTreeListener listener) {
2741 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOptionalBindingContinuationList(this);
2742 		}
2743 	}
2744 
2745 	public final OptionalBindingContinuationListContext optionalBindingContinuationList() throws RecognitionException {
2746 		OptionalBindingContinuationListContext _localctx = new OptionalBindingContinuationListContext(_ctx, getState());
2747 		enterRule(_localctx, 78, RULE_optionalBindingContinuationList);
2748 		try {
2749 			int _alt;
2750 			enterOuterAlt(_localctx, 1);
2751 			{
2752 			setState(790);
2753 			optionalBindingContinuation();
2754 			setState(795);
2755 			_errHandler.sync(this);
2756 			_alt = getInterpreter().adaptivePredict(_input,47,_ctx);
2757 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2758 				if ( _alt==1 ) {
2759 					{
2760 					{
2761 					setState(791);
2762 					match(T__15);
2763 					setState(792);
2764 					optionalBindingContinuation();
2765 					}
2766 					} 
2767 				}
2768 				setState(797);
2769 				_errHandler.sync(this);
2770 				_alt = getInterpreter().adaptivePredict(_input,47,_ctx);
2771 			}
2772 			}
2773 		}
2774 		catch (RecognitionException re) {
2775 			_localctx.exception = re;
2776 			_errHandler.reportError(this, re);
2777 			_errHandler.recover(this, re);
2778 		}
2779 		finally {
2780 			exitRule();
2781 		}
2782 		return _localctx;
2783 	}
2784 
2785 	public static class OptionalBindingContinuationContext extends ParserRuleContext {
2786 		public OptionalBindingHeadContext optionalBindingHead() {
2787 			return getRuleContext(OptionalBindingHeadContext.class,0);
2788 		}
2789 		public PatternContext pattern() {
2790 			return getRuleContext(PatternContext.class,0);
2791 		}
2792 		public InitializerContext initializer() {
2793 			return getRuleContext(InitializerContext.class,0);
2794 		}
2795 		public OptionalBindingContinuationContext(ParserRuleContext parent, int invokingState) {
2796 			super(parent, invokingState);
2797 		}
2798 		@Override public int getRuleIndex() { return RULE_optionalBindingContinuation; }
2799 		@Override
2800 		public void enterRule(ParseTreeListener listener) {
2801 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOptionalBindingContinuation(this);
2802 		}
2803 		@Override
2804 		public void exitRule(ParseTreeListener listener) {
2805 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOptionalBindingContinuation(this);
2806 		}
2807 	}
2808 
2809 	public final OptionalBindingContinuationContext optionalBindingContinuation() throws RecognitionException {
2810 		OptionalBindingContinuationContext _localctx = new OptionalBindingContinuationContext(_ctx, getState());
2811 		enterRule(_localctx, 80, RULE_optionalBindingContinuation);
2812 		try {
2813 			setState(802);
2814 			_errHandler.sync(this);
2815 			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
2816 			case 1:
2817 				enterOuterAlt(_localctx, 1);
2818 				{
2819 				setState(798);
2820 				optionalBindingHead();
2821 				}
2822 				break;
2823 			case 2:
2824 				enterOuterAlt(_localctx, 2);
2825 				{
2826 				setState(799);
2827 				pattern(0);
2828 				setState(800);
2829 				initializer();
2830 				}
2831 				break;
2832 			}
2833 		}
2834 		catch (RecognitionException re) {
2835 			_localctx.exception = re;
2836 			_errHandler.reportError(this, re);
2837 			_errHandler.recover(this, re);
2838 		}
2839 		finally {
2840 			exitRule();
2841 		}
2842 		return _localctx;
2843 	}
2844 
2845 	public static class WhereClauseContext extends ParserRuleContext {
2846 		public WhereExpressionContext whereExpression() {
2847 			return getRuleContext(WhereExpressionContext.class,0);
2848 		}
2849 		public WhereClauseContext(ParserRuleContext parent, int invokingState) {
2850 			super(parent, invokingState);
2851 		}
2852 		@Override public int getRuleIndex() { return RULE_whereClause; }
2853 		@Override
2854 		public void enterRule(ParseTreeListener listener) {
2855 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWhereClause(this);
2856 		}
2857 		@Override
2858 		public void exitRule(ParseTreeListener listener) {
2859 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWhereClause(this);
2860 		}
2861 	}
2862 
2863 	public final WhereClauseContext whereClause() throws RecognitionException {
2864 		WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
2865 		enterRule(_localctx, 82, RULE_whereClause);
2866 		try {
2867 			enterOuterAlt(_localctx, 1);
2868 			{
2869 			setState(804);
2870 			match(T__27);
2871 			setState(805);
2872 			whereExpression();
2873 			}
2874 		}
2875 		catch (RecognitionException re) {
2876 			_localctx.exception = re;
2877 			_errHandler.reportError(this, re);
2878 			_errHandler.recover(this, re);
2879 		}
2880 		finally {
2881 			exitRule();
2882 		}
2883 		return _localctx;
2884 	}
2885 
2886 	public static class WhereExpressionContext extends ParserRuleContext {
2887 		public ExpressionContext expression() {
2888 			return getRuleContext(ExpressionContext.class,0);
2889 		}
2890 		public WhereExpressionContext(ParserRuleContext parent, int invokingState) {
2891 			super(parent, invokingState);
2892 		}
2893 		@Override public int getRuleIndex() { return RULE_whereExpression; }
2894 		@Override
2895 		public void enterRule(ParseTreeListener listener) {
2896 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWhereExpression(this);
2897 		}
2898 		@Override
2899 		public void exitRule(ParseTreeListener listener) {
2900 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWhereExpression(this);
2901 		}
2902 	}
2903 
2904 	public final WhereExpressionContext whereExpression() throws RecognitionException {
2905 		WhereExpressionContext _localctx = new WhereExpressionContext(_ctx, getState());
2906 		enterRule(_localctx, 84, RULE_whereExpression);
2907 		try {
2908 			enterOuterAlt(_localctx, 1);
2909 			{
2910 			setState(807);
2911 			expression();
2912 			}
2913 		}
2914 		catch (RecognitionException re) {
2915 			_localctx.exception = re;
2916 			_errHandler.reportError(this, re);
2917 			_errHandler.recover(this, re);
2918 		}
2919 		finally {
2920 			exitRule();
2921 		}
2922 		return _localctx;
2923 	}
2924 
2925 	public static class AvailabilityConditionContext extends ParserRuleContext {
2926 		public AvailabilityArgumentsContext availabilityArguments() {
2927 			return getRuleContext(AvailabilityArgumentsContext.class,0);
2928 		}
2929 		public AvailabilityConditionContext(ParserRuleContext parent, int invokingState) {
2930 			super(parent, invokingState);
2931 		}
2932 		@Override public int getRuleIndex() { return RULE_availabilityCondition; }
2933 		@Override
2934 		public void enterRule(ParseTreeListener listener) {
2935 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAvailabilityCondition(this);
2936 		}
2937 		@Override
2938 		public void exitRule(ParseTreeListener listener) {
2939 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAvailabilityCondition(this);
2940 		}
2941 	}
2942 
2943 	public final AvailabilityConditionContext availabilityCondition() throws RecognitionException {
2944 		AvailabilityConditionContext _localctx = new AvailabilityConditionContext(_ctx, getState());
2945 		enterRule(_localctx, 86, RULE_availabilityCondition);
2946 		try {
2947 			enterOuterAlt(_localctx, 1);
2948 			{
2949 			setState(809);
2950 			match(T__28);
2951 			setState(810);
2952 			match(T__3);
2953 			setState(811);
2954 			availabilityArguments();
2955 			setState(812);
2956 			match(T__4);
2957 			}
2958 		}
2959 		catch (RecognitionException re) {
2960 			_localctx.exception = re;
2961 			_errHandler.reportError(this, re);
2962 			_errHandler.recover(this, re);
2963 		}
2964 		finally {
2965 			exitRule();
2966 		}
2967 		return _localctx;
2968 	}
2969 
2970 	public static class AvailabilityArgumentsContext extends ParserRuleContext {
2971 		public AvailabilityArgumentContext availabilityArgument() {
2972 			return getRuleContext(AvailabilityArgumentContext.class,0);
2973 		}
2974 		public List<AvailabilityArgumentsContext> availabilityArguments() {
2975 			return getRuleContexts(AvailabilityArgumentsContext.class);
2976 		}
2977 		public AvailabilityArgumentsContext availabilityArguments(int i) {
2978 			return getRuleContext(AvailabilityArgumentsContext.class,i);
2979 		}
2980 		public AvailabilityArgumentsContext(ParserRuleContext parent, int invokingState) {
2981 			super(parent, invokingState);
2982 		}
2983 		@Override public int getRuleIndex() { return RULE_availabilityArguments; }
2984 		@Override
2985 		public void enterRule(ParseTreeListener listener) {
2986 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAvailabilityArguments(this);
2987 		}
2988 		@Override
2989 		public void exitRule(ParseTreeListener listener) {
2990 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAvailabilityArguments(this);
2991 		}
2992 	}
2993 
2994 	public final AvailabilityArgumentsContext availabilityArguments() throws RecognitionException {
2995 		AvailabilityArgumentsContext _localctx = new AvailabilityArgumentsContext(_ctx, getState());
2996 		enterRule(_localctx, 88, RULE_availabilityArguments);
2997 		try {
2998 			int _alt;
2999 			enterOuterAlt(_localctx, 1);
3000 			{
3001 			setState(814);
3002 			availabilityArgument();
3003 			setState(819);
3004 			_errHandler.sync(this);
3005 			_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
3006 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
3007 				if ( _alt==1 ) {
3008 					{
3009 					{
3010 					setState(815);
3011 					match(T__15);
3012 					setState(816);
3013 					availabilityArguments();
3014 					}
3015 					} 
3016 				}
3017 				setState(821);
3018 				_errHandler.sync(this);
3019 				_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
3020 			}
3021 			}
3022 		}
3023 		catch (RecognitionException re) {
3024 			_localctx.exception = re;
3025 			_errHandler.reportError(this, re);
3026 			_errHandler.recover(this, re);
3027 		}
3028 		finally {
3029 			exitRule();
3030 		}
3031 		return _localctx;
3032 	}
3033 
3034 	public static class AvailabilityArgumentContext extends ParserRuleContext {
3035 		public PlatformNameContext platformName() {
3036 			return getRuleContext(PlatformNameContext.class,0);
3037 		}
3038 		public PlatformVersionContext platformVersion() {
3039 			return getRuleContext(PlatformVersionContext.class,0);
3040 		}
3041 		public AvailabilityArgumentContext(ParserRuleContext parent, int invokingState) {
3042 			super(parent, invokingState);
3043 		}
3044 		@Override public int getRuleIndex() { return RULE_availabilityArgument; }
3045 		@Override
3046 		public void enterRule(ParseTreeListener listener) {
3047 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAvailabilityArgument(this);
3048 		}
3049 		@Override
3050 		public void exitRule(ParseTreeListener listener) {
3051 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAvailabilityArgument(this);
3052 		}
3053 	}
3054 
3055 	public final AvailabilityArgumentContext availabilityArgument() throws RecognitionException {
3056 		AvailabilityArgumentContext _localctx = new AvailabilityArgumentContext(_ctx, getState());
3057 		enterRule(_localctx, 90, RULE_availabilityArgument);
3058 		try {
3059 			setState(826);
3060 			switch (_input.LA(1)) {
3061 			case T__30:
3062 			case T__31:
3063 			case T__32:
3064 			case T__33:
3065 			case T__34:
3066 			case T__35:
3067 			case T__36:
3068 			case T__37:
3069 				enterOuterAlt(_localctx, 1);
3070 				{
3071 				setState(822);
3072 				platformName();
3073 				setState(823);
3074 				platformVersion();
3075 				}
3076 				break;
3077 			case T__29:
3078 				enterOuterAlt(_localctx, 2);
3079 				{
3080 				setState(825);
3081 				match(T__29);
3082 				}
3083 				break;
3084 			default:
3085 				throw new NoViableAltException(this);
3086 			}
3087 		}
3088 		catch (RecognitionException re) {
3089 			_localctx.exception = re;
3090 			_errHandler.reportError(this, re);
3091 			_errHandler.recover(this, re);
3092 		}
3093 		finally {
3094 			exitRule();
3095 		}
3096 		return _localctx;
3097 	}
3098 
3099 	public static class PlatformNameContext extends ParserRuleContext {
3100 		public PlatformNameContext(ParserRuleContext parent, int invokingState) {
3101 			super(parent, invokingState);
3102 		}
3103 		@Override public int getRuleIndex() { return RULE_platformName; }
3104 		@Override
3105 		public void enterRule(ParseTreeListener listener) {
3106 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPlatformName(this);
3107 		}
3108 		@Override
3109 		public void exitRule(ParseTreeListener listener) {
3110 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPlatformName(this);
3111 		}
3112 	}
3113 
3114 	public final PlatformNameContext platformName() throws RecognitionException {
3115 		PlatformNameContext _localctx = new PlatformNameContext(_ctx, getState());
3116 		enterRule(_localctx, 92, RULE_platformName);
3117 		int _la;
3118 		try {
3119 			enterOuterAlt(_localctx, 1);
3120 			{
3121 			setState(828);
3122 			_la = _input.LA(1);
3123 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37))) != 0)) ) {
3124 			_errHandler.recoverInline(this);
3125 			} else {
3126 				consume();
3127 			}
3128 			}
3129 		}
3130 		catch (RecognitionException re) {
3131 			_localctx.exception = re;
3132 			_errHandler.reportError(this, re);
3133 			_errHandler.recover(this, re);
3134 		}
3135 		finally {
3136 			exitRule();
3137 		}
3138 		return _localctx;
3139 	}
3140 
3141 	public static class PlatformVersionContext extends ParserRuleContext {
3142 		public TerminalNode VersionLiteral() { return getToken(SwiftParser.VersionLiteral, 0); }
3143 		public TerminalNode DecimalLiteral() { return getToken(SwiftParser.DecimalLiteral, 0); }
3144 		public TerminalNode FloatingPointLiteral() { return getToken(SwiftParser.FloatingPointLiteral, 0); }
3145 		public PlatformVersionContext(ParserRuleContext parent, int invokingState) {
3146 			super(parent, invokingState);
3147 		}
3148 		@Override public int getRuleIndex() { return RULE_platformVersion; }
3149 		@Override
3150 		public void enterRule(ParseTreeListener listener) {
3151 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPlatformVersion(this);
3152 		}
3153 		@Override
3154 		public void exitRule(ParseTreeListener listener) {
3155 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPlatformVersion(this);
3156 		}
3157 	}
3158 
3159 	public final PlatformVersionContext platformVersion() throws RecognitionException {
3160 		PlatformVersionContext _localctx = new PlatformVersionContext(_ctx, getState());
3161 		enterRule(_localctx, 94, RULE_platformVersion);
3162 		int _la;
3163 		try {
3164 			enterOuterAlt(_localctx, 1);
3165 			{
3166 			setState(830);
3167 			_la = _input.LA(1);
3168 			if ( !(((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & ((1L << (DecimalLiteral - 141)) | (1L << (FloatingPointLiteral - 141)) | (1L << (VersionLiteral - 141)))) != 0)) ) {
3169 			_errHandler.recoverInline(this);
3170 			} else {
3171 				consume();
3172 			}
3173 			}
3174 		}
3175 		catch (RecognitionException re) {
3176 			_localctx.exception = re;
3177 			_errHandler.reportError(this, re);
3178 			_errHandler.recover(this, re);
3179 		}
3180 		finally {
3181 			exitRule();
3182 		}
3183 		return _localctx;
3184 	}
3185 
3186 	public static class GenericParameterClauseContext extends ParserRuleContext {
3187 		public GenericParameterListContext genericParameterList() {
3188 			return getRuleContext(GenericParameterListContext.class,0);
3189 		}
3190 		public RequirementClauseContext requirementClause() {
3191 			return getRuleContext(RequirementClauseContext.class,0);
3192 		}
3193 		public GenericParameterClauseContext(ParserRuleContext parent, int invokingState) {
3194 			super(parent, invokingState);
3195 		}
3196 		@Override public int getRuleIndex() { return RULE_genericParameterClause; }
3197 		@Override
3198 		public void enterRule(ParseTreeListener listener) {
3199 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGenericParameterClause(this);
3200 		}
3201 		@Override
3202 		public void exitRule(ParseTreeListener listener) {
3203 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGenericParameterClause(this);
3204 		}
3205 	}
3206 
3207 	public final GenericParameterClauseContext genericParameterClause() throws RecognitionException {
3208 		GenericParameterClauseContext _localctx = new GenericParameterClauseContext(_ctx, getState());
3209 		enterRule(_localctx, 96, RULE_genericParameterClause);
3210 		int _la;
3211 		try {
3212 			enterOuterAlt(_localctx, 1);
3213 			{
3214 			setState(832);
3215 			match(T__38);
3216 			setState(833);
3217 			genericParameterList();
3218 			setState(835);
3219 			_la = _input.LA(1);
3220 			if (_la==T__27) {
3221 				{
3222 				setState(834);
3223 				requirementClause();
3224 				}
3225 			}
3226 
3227 			setState(837);
3228 			match(T__39);
3229 			}
3230 		}
3231 		catch (RecognitionException re) {
3232 			_localctx.exception = re;
3233 			_errHandler.reportError(this, re);
3234 			_errHandler.recover(this, re);
3235 		}
3236 		finally {
3237 			exitRule();
3238 		}
3239 		return _localctx;
3240 	}
3241 
3242 	public static class GenericParameterListContext extends ParserRuleContext {
3243 		public List<GenericParameterContext> genericParameter() {
3244 			return getRuleContexts(GenericParameterContext.class);
3245 		}
3246 		public GenericParameterContext genericParameter(int i) {
3247 			return getRuleContext(GenericParameterContext.class,i);
3248 		}
3249 		public GenericParameterListContext(ParserRuleContext parent, int invokingState) {
3250 			super(parent, invokingState);
3251 		}
3252 		@Override public int getRuleIndex() { return RULE_genericParameterList; }
3253 		@Override
3254 		public void enterRule(ParseTreeListener listener) {
3255 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGenericParameterList(this);
3256 		}
3257 		@Override
3258 		public void exitRule(ParseTreeListener listener) {
3259 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGenericParameterList(this);
3260 		}
3261 	}
3262 
3263 	public final GenericParameterListContext genericParameterList() throws RecognitionException {
3264 		GenericParameterListContext _localctx = new GenericParameterListContext(_ctx, getState());
3265 		enterRule(_localctx, 98, RULE_genericParameterList);
3266 		int _la;
3267 		try {
3268 			enterOuterAlt(_localctx, 1);
3269 			{
3270 			setState(839);
3271 			genericParameter();
3272 			setState(844);
3273 			_errHandler.sync(this);
3274 			_la = _input.LA(1);
3275 			while (_la==T__15) {
3276 				{
3277 				{
3278 				setState(840);
3279 				match(T__15);
3280 				setState(841);
3281 				genericParameter();
3282 				}
3283 				}
3284 				setState(846);
3285 				_errHandler.sync(this);
3286 				_la = _input.LA(1);
3287 			}
3288 			}
3289 		}
3290 		catch (RecognitionException re) {
3291 			_localctx.exception = re;
3292 			_errHandler.reportError(this, re);
3293 			_errHandler.recover(this, re);
3294 		}
3295 		finally {
3296 			exitRule();
3297 		}
3298 		return _localctx;
3299 	}
3300 
3301 	public static class GenericParameterContext extends ParserRuleContext {
3302 		public TypeNameContext typeName() {
3303 			return getRuleContext(TypeNameContext.class,0);
3304 		}
3305 		public TypeIdentifierContext typeIdentifier() {
3306 			return getRuleContext(TypeIdentifierContext.class,0);
3307 		}
3308 		public ProtocolCompositionTypeContext protocolCompositionType() {
3309 			return getRuleContext(ProtocolCompositionTypeContext.class,0);
3310 		}
3311 		public GenericParameterContext(ParserRuleContext parent, int invokingState) {
3312 			super(parent, invokingState);
3313 		}
3314 		@Override public int getRuleIndex() { return RULE_genericParameter; }
3315 		@Override
3316 		public void enterRule(ParseTreeListener listener) {
3317 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGenericParameter(this);
3318 		}
3319 		@Override
3320 		public void exitRule(ParseTreeListener listener) {
3321 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGenericParameter(this);
3322 		}
3323 	}
3324 
3325 	public final GenericParameterContext genericParameter() throws RecognitionException {
3326 		GenericParameterContext _localctx = new GenericParameterContext(_ctx, getState());
3327 		enterRule(_localctx, 100, RULE_genericParameter);
3328 		try {
3329 			setState(856);
3330 			_errHandler.sync(this);
3331 			switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
3332 			case 1:
3333 				enterOuterAlt(_localctx, 1);
3334 				{
3335 				setState(847);
3336 				typeName();
3337 				}
3338 				break;
3339 			case 2:
3340 				enterOuterAlt(_localctx, 2);
3341 				{
3342 				setState(848);
3343 				typeName();
3344 				setState(849);
3345 				match(T__1);
3346 				setState(850);
3347 				typeIdentifier();
3348 				}
3349 				break;
3350 			case 3:
3351 				enterOuterAlt(_localctx, 3);
3352 				{
3353 				setState(852);
3354 				typeName();
3355 				setState(853);
3356 				match(T__1);
3357 				setState(854);
3358 				protocolCompositionType();
3359 				}
3360 				break;
3361 			}
3362 		}
3363 		catch (RecognitionException re) {
3364 			_localctx.exception = re;
3365 			_errHandler.reportError(this, re);
3366 			_errHandler.recover(this, re);
3367 		}
3368 		finally {
3369 			exitRule();
3370 		}
3371 		return _localctx;
3372 	}
3373 
3374 	public static class RequirementClauseContext extends ParserRuleContext {
3375 		public RequirementListContext requirementList() {
3376 			return getRuleContext(RequirementListContext.class,0);
3377 		}
3378 		public RequirementClauseContext(ParserRuleContext parent, int invokingState) {
3379 			super(parent, invokingState);
3380 		}
3381 		@Override public int getRuleIndex() { return RULE_requirementClause; }
3382 		@Override
3383 		public void enterRule(ParseTreeListener listener) {
3384 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRequirementClause(this);
3385 		}
3386 		@Override
3387 		public void exitRule(ParseTreeListener listener) {
3388 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRequirementClause(this);
3389 		}
3390 	}
3391 
3392 	public final RequirementClauseContext requirementClause() throws RecognitionException {
3393 		RequirementClauseContext _localctx = new RequirementClauseContext(_ctx, getState());
3394 		enterRule(_localctx, 102, RULE_requirementClause);
3395 		try {
3396 			enterOuterAlt(_localctx, 1);
3397 			{
3398 			setState(858);
3399 			match(T__27);
3400 			setState(859);
3401 			requirementList();
3402 			}
3403 		}
3404 		catch (RecognitionException re) {
3405 			_localctx.exception = re;
3406 			_errHandler.reportError(this, re);
3407 			_errHandler.recover(this, re);
3408 		}
3409 		finally {
3410 			exitRule();
3411 		}
3412 		return _localctx;
3413 	}
3414 
3415 	public static class RequirementListContext extends ParserRuleContext {
3416 		public List<RequirementContext> requirement() {
3417 			return getRuleContexts(RequirementContext.class);
3418 		}
3419 		public RequirementContext requirement(int i) {
3420 			return getRuleContext(RequirementContext.class,i);
3421 		}
3422 		public RequirementListContext(ParserRuleContext parent, int invokingState) {
3423 			super(parent, invokingState);
3424 		}
3425 		@Override public int getRuleIndex() { return RULE_requirementList; }
3426 		@Override
3427 		public void enterRule(ParseTreeListener listener) {
3428 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRequirementList(this);
3429 		}
3430 		@Override
3431 		public void exitRule(ParseTreeListener listener) {
3432 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRequirementList(this);
3433 		}
3434 	}
3435 
3436 	public final RequirementListContext requirementList() throws RecognitionException {
3437 		RequirementListContext _localctx = new RequirementListContext(_ctx, getState());
3438 		enterRule(_localctx, 104, RULE_requirementList);
3439 		int _la;
3440 		try {
3441 			enterOuterAlt(_localctx, 1);
3442 			{
3443 			setState(861);
3444 			requirement();
3445 			setState(866);
3446 			_errHandler.sync(this);
3447 			_la = _input.LA(1);
3448 			while (_la==T__15) {
3449 				{
3450 				{
3451 				setState(862);
3452 				match(T__15);
3453 				setState(863);
3454 				requirement();
3455 				}
3456 				}
3457 				setState(868);
3458 				_errHandler.sync(this);
3459 				_la = _input.LA(1);
3460 			}
3461 			}
3462 		}
3463 		catch (RecognitionException re) {
3464 			_localctx.exception = re;
3465 			_errHandler.reportError(this, re);
3466 			_errHandler.recover(this, re);
3467 		}
3468 		finally {
3469 			exitRule();
3470 		}
3471 		return _localctx;
3472 	}
3473 
3474 	public static class RequirementContext extends ParserRuleContext {
3475 		public ConformanceRequirementContext conformanceRequirement() {
3476 			return getRuleContext(ConformanceRequirementContext.class,0);
3477 		}
3478 		public SameTypeRequirementContext sameTypeRequirement() {
3479 			return getRuleContext(SameTypeRequirementContext.class,0);
3480 		}
3481 		public RequirementContext(ParserRuleContext parent, int invokingState) {
3482 			super(parent, invokingState);
3483 		}
3484 		@Override public int getRuleIndex() { return RULE_requirement; }
3485 		@Override
3486 		public void enterRule(ParseTreeListener listener) {
3487 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRequirement(this);
3488 		}
3489 		@Override
3490 		public void exitRule(ParseTreeListener listener) {
3491 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRequirement(this);
3492 		}
3493 	}
3494 
3495 	public final RequirementContext requirement() throws RecognitionException {
3496 		RequirementContext _localctx = new RequirementContext(_ctx, getState());
3497 		enterRule(_localctx, 106, RULE_requirement);
3498 		try {
3499 			setState(871);
3500 			_errHandler.sync(this);
3501 			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
3502 			case 1:
3503 				enterOuterAlt(_localctx, 1);
3504 				{
3505 				setState(869);
3506 				conformanceRequirement();
3507 				}
3508 				break;
3509 			case 2:
3510 				enterOuterAlt(_localctx, 2);
3511 				{
3512 				setState(870);
3513 				sameTypeRequirement();
3514 				}
3515 				break;
3516 			}
3517 		}
3518 		catch (RecognitionException re) {
3519 			_localctx.exception = re;
3520 			_errHandler.reportError(this, re);
3521 			_errHandler.recover(this, re);
3522 		}
3523 		finally {
3524 			exitRule();
3525 		}
3526 		return _localctx;
3527 	}
3528 
3529 	public static class ConformanceRequirementContext extends ParserRuleContext {
3530 		public List<TypeIdentifierContext> typeIdentifier() {
3531 			return getRuleContexts(TypeIdentifierContext.class);
3532 		}
3533 		public TypeIdentifierContext typeIdentifier(int i) {
3534 			return getRuleContext(TypeIdentifierContext.class,i);
3535 		}
3536 		public ProtocolCompositionTypeContext protocolCompositionType() {
3537 			return getRuleContext(ProtocolCompositionTypeContext.class,0);
3538 		}
3539 		public ConformanceRequirementContext(ParserRuleContext parent, int invokingState) {
3540 			super(parent, invokingState);
3541 		}
3542 		@Override public int getRuleIndex() { return RULE_conformanceRequirement; }
3543 		@Override
3544 		public void enterRule(ParseTreeListener listener) {
3545 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterConformanceRequirement(this);
3546 		}
3547 		@Override
3548 		public void exitRule(ParseTreeListener listener) {
3549 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitConformanceRequirement(this);
3550 		}
3551 	}
3552 
3553 	public final ConformanceRequirementContext conformanceRequirement() throws RecognitionException {
3554 		ConformanceRequirementContext _localctx = new ConformanceRequirementContext(_ctx, getState());
3555 		enterRule(_localctx, 108, RULE_conformanceRequirement);
3556 		try {
3557 			setState(881);
3558 			_errHandler.sync(this);
3559 			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
3560 			case 1:
3561 				enterOuterAlt(_localctx, 1);
3562 				{
3563 				setState(873);
3564 				typeIdentifier();
3565 				setState(874);
3566 				match(T__1);
3567 				setState(875);
3568 				typeIdentifier();
3569 				}
3570 				break;
3571 			case 2:
3572 				enterOuterAlt(_localctx, 2);
3573 				{
3574 				setState(877);
3575 				typeIdentifier();
3576 				setState(878);
3577 				match(T__1);
3578 				setState(879);
3579 				protocolCompositionType();
3580 				}
3581 				break;
3582 			}
3583 		}
3584 		catch (RecognitionException re) {
3585 			_localctx.exception = re;
3586 			_errHandler.reportError(this, re);
3587 			_errHandler.recover(this, re);
3588 		}
3589 		finally {
3590 			exitRule();
3591 		}
3592 		return _localctx;
3593 	}
3594 
3595 	public static class SameTypeRequirementContext extends ParserRuleContext {
3596 		public TypeIdentifierContext typeIdentifier() {
3597 			return getRuleContext(TypeIdentifierContext.class,0);
3598 		}
3599 		public STypeContext sType() {
3600 			return getRuleContext(STypeContext.class,0);
3601 		}
3602 		public SameTypeRequirementContext(ParserRuleContext parent, int invokingState) {
3603 			super(parent, invokingState);
3604 		}
3605 		@Override public int getRuleIndex() { return RULE_sameTypeRequirement; }
3606 		@Override
3607 		public void enterRule(ParseTreeListener listener) {
3608 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSameTypeRequirement(this);
3609 		}
3610 		@Override
3611 		public void exitRule(ParseTreeListener listener) {
3612 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSameTypeRequirement(this);
3613 		}
3614 	}
3615 
3616 	public final SameTypeRequirementContext sameTypeRequirement() throws RecognitionException {
3617 		SameTypeRequirementContext _localctx = new SameTypeRequirementContext(_ctx, getState());
3618 		enterRule(_localctx, 110, RULE_sameTypeRequirement);
3619 		try {
3620 			enterOuterAlt(_localctx, 1);
3621 			{
3622 			setState(883);
3623 			typeIdentifier();
3624 			setState(884);
3625 			match(T__40);
3626 			setState(885);
3627 			sType(0);
3628 			}
3629 		}
3630 		catch (RecognitionException re) {
3631 			_localctx.exception = re;
3632 			_errHandler.reportError(this, re);
3633 			_errHandler.recover(this, re);
3634 		}
3635 		finally {
3636 			exitRule();
3637 		}
3638 		return _localctx;
3639 	}
3640 
3641 	public static class GenericArgumentClauseContext extends ParserRuleContext {
3642 		public GenericArgumentListContext genericArgumentList() {
3643 			return getRuleContext(GenericArgumentListContext.class,0);
3644 		}
3645 		public GenericArgumentClauseContext(ParserRuleContext parent, int invokingState) {
3646 			super(parent, invokingState);
3647 		}
3648 		@Override public int getRuleIndex() { return RULE_genericArgumentClause; }
3649 		@Override
3650 		public void enterRule(ParseTreeListener listener) {
3651 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGenericArgumentClause(this);
3652 		}
3653 		@Override
3654 		public void exitRule(ParseTreeListener listener) {
3655 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGenericArgumentClause(this);
3656 		}
3657 	}
3658 
3659 	public final GenericArgumentClauseContext genericArgumentClause() throws RecognitionException {
3660 		GenericArgumentClauseContext _localctx = new GenericArgumentClauseContext(_ctx, getState());
3661 		enterRule(_localctx, 112, RULE_genericArgumentClause);
3662 		try {
3663 			enterOuterAlt(_localctx, 1);
3664 			{
3665 			setState(887);
3666 			match(T__38);
3667 			setState(888);
3668 			genericArgumentList();
3669 			setState(889);
3670 			match(T__39);
3671 			}
3672 		}
3673 		catch (RecognitionException re) {
3674 			_localctx.exception = re;
3675 			_errHandler.reportError(this, re);
3676 			_errHandler.recover(this, re);
3677 		}
3678 		finally {
3679 			exitRule();
3680 		}
3681 		return _localctx;
3682 	}
3683 
3684 	public static class GenericArgumentListContext extends ParserRuleContext {
3685 		public List<GenericArgumentContext> genericArgument() {
3686 			return getRuleContexts(GenericArgumentContext.class);
3687 		}
3688 		public GenericArgumentContext genericArgument(int i) {
3689 			return getRuleContext(GenericArgumentContext.class,i);
3690 		}
3691 		public GenericArgumentListContext(ParserRuleContext parent, int invokingState) {
3692 			super(parent, invokingState);
3693 		}
3694 		@Override public int getRuleIndex() { return RULE_genericArgumentList; }
3695 		@Override
3696 		public void enterRule(ParseTreeListener listener) {
3697 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGenericArgumentList(this);
3698 		}
3699 		@Override
3700 		public void exitRule(ParseTreeListener listener) {
3701 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGenericArgumentList(this);
3702 		}
3703 	}
3704 
3705 	public final GenericArgumentListContext genericArgumentList() throws RecognitionException {
3706 		GenericArgumentListContext _localctx = new GenericArgumentListContext(_ctx, getState());
3707 		enterRule(_localctx, 114, RULE_genericArgumentList);
3708 		int _la;
3709 		try {
3710 			enterOuterAlt(_localctx, 1);
3711 			{
3712 			setState(891);
3713 			genericArgument();
3714 			setState(896);
3715 			_errHandler.sync(this);
3716 			_la = _input.LA(1);
3717 			while (_la==T__15) {
3718 				{
3719 				{
3720 				setState(892);
3721 				match(T__15);
3722 				setState(893);
3723 				genericArgument();
3724 				}
3725 				}
3726 				setState(898);
3727 				_errHandler.sync(this);
3728 				_la = _input.LA(1);
3729 			}
3730 			}
3731 		}
3732 		catch (RecognitionException re) {
3733 			_localctx.exception = re;
3734 			_errHandler.reportError(this, re);
3735 			_errHandler.recover(this, re);
3736 		}
3737 		finally {
3738 			exitRule();
3739 		}
3740 		return _localctx;
3741 	}
3742 
3743 	public static class GenericArgumentContext extends ParserRuleContext {
3744 		public STypeContext sType() {
3745 			return getRuleContext(STypeContext.class,0);
3746 		}
3747 		public GenericArgumentContext(ParserRuleContext parent, int invokingState) {
3748 			super(parent, invokingState);
3749 		}
3750 		@Override public int getRuleIndex() { return RULE_genericArgument; }
3751 		@Override
3752 		public void enterRule(ParseTreeListener listener) {
3753 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGenericArgument(this);
3754 		}
3755 		@Override
3756 		public void exitRule(ParseTreeListener listener) {
3757 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGenericArgument(this);
3758 		}
3759 	}
3760 
3761 	public final GenericArgumentContext genericArgument() throws RecognitionException {
3762 		GenericArgumentContext _localctx = new GenericArgumentContext(_ctx, getState());
3763 		enterRule(_localctx, 116, RULE_genericArgument);
3764 		try {
3765 			enterOuterAlt(_localctx, 1);
3766 			{
3767 			setState(899);
3768 			sType(0);
3769 			}
3770 		}
3771 		catch (RecognitionException re) {
3772 			_localctx.exception = re;
3773 			_errHandler.reportError(this, re);
3774 			_errHandler.recover(this, re);
3775 		}
3776 		finally {
3777 			exitRule();
3778 		}
3779 		return _localctx;
3780 	}
3781 
3782 	public static class DeclarationContext extends ParserRuleContext {
3783 		public ImportDeclarationContext importDeclaration() {
3784 			return getRuleContext(ImportDeclarationContext.class,0);
3785 		}
3786 		public ConstantDeclarationContext constantDeclaration() {
3787 			return getRuleContext(ConstantDeclarationContext.class,0);
3788 		}
3789 		public VariableDeclarationContext variableDeclaration() {
3790 			return getRuleContext(VariableDeclarationContext.class,0);
3791 		}
3792 		public TypealiasDeclarationContext typealiasDeclaration() {
3793 			return getRuleContext(TypealiasDeclarationContext.class,0);
3794 		}
3795 		public FunctionDeclarationContext functionDeclaration() {
3796 			return getRuleContext(FunctionDeclarationContext.class,0);
3797 		}
3798 		public EnumDeclarationContext enumDeclaration() {
3799 			return getRuleContext(EnumDeclarationContext.class,0);
3800 		}
3801 		public StructDeclarationContext structDeclaration() {
3802 			return getRuleContext(StructDeclarationContext.class,0);
3803 		}
3804 		public ClassDeclarationContext classDeclaration() {
3805 			return getRuleContext(ClassDeclarationContext.class,0);
3806 		}
3807 		public ProtocolDeclarationContext protocolDeclaration() {
3808 			return getRuleContext(ProtocolDeclarationContext.class,0);
3809 		}
3810 		public InitializerDeclarationContext initializerDeclaration() {
3811 			return getRuleContext(InitializerDeclarationContext.class,0);
3812 		}
3813 		public DeinitializerDeclarationContext deinitializerDeclaration() {
3814 			return getRuleContext(DeinitializerDeclarationContext.class,0);
3815 		}
3816 		public ExtensionDeclarationContext extensionDeclaration() {
3817 			return getRuleContext(ExtensionDeclarationContext.class,0);
3818 		}
3819 		public SubscriptDeclarationContext subscriptDeclaration() {
3820 			return getRuleContext(SubscriptDeclarationContext.class,0);
3821 		}
3822 		public OperatorDeclarationContext operatorDeclaration() {
3823 			return getRuleContext(OperatorDeclarationContext.class,0);
3824 		}
3825 		public CompilerControlStatementContext compilerControlStatement() {
3826 			return getRuleContext(CompilerControlStatementContext.class,0);
3827 		}
3828 		public DeclarationContext(ParserRuleContext parent, int invokingState) {
3829 			super(parent, invokingState);
3830 		}
3831 		@Override public int getRuleIndex() { return RULE_declaration; }
3832 		@Override
3833 		public void enterRule(ParseTreeListener listener) {
3834 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDeclaration(this);
3835 		}
3836 		@Override
3837 		public void exitRule(ParseTreeListener listener) {
3838 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDeclaration(this);
3839 		}
3840 	}
3841 
3842 	public final DeclarationContext declaration() throws RecognitionException {
3843 		DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
3844 		enterRule(_localctx, 118, RULE_declaration);
3845 		try {
3846 			setState(961);
3847 			_errHandler.sync(this);
3848 			switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
3849 			case 1:
3850 				enterOuterAlt(_localctx, 1);
3851 				{
3852 				setState(901);
3853 				importDeclaration();
3854 				setState(903);
3855 				_errHandler.sync(this);
3856 				switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
3857 				case 1:
3858 					{
3859 					setState(902);
3860 					match(T__0);
3861 					}
3862 					break;
3863 				}
3864 				}
3865 				break;
3866 			case 2:
3867 				enterOuterAlt(_localctx, 2);
3868 				{
3869 				setState(905);
3870 				constantDeclaration();
3871 				setState(907);
3872 				_errHandler.sync(this);
3873 				switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
3874 				case 1:
3875 					{
3876 					setState(906);
3877 					match(T__0);
3878 					}
3879 					break;
3880 				}
3881 				}
3882 				break;
3883 			case 3:
3884 				enterOuterAlt(_localctx, 3);
3885 				{
3886 				setState(909);
3887 				variableDeclaration();
3888 				setState(911);
3889 				_errHandler.sync(this);
3890 				switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
3891 				case 1:
3892 					{
3893 					setState(910);
3894 					match(T__0);
3895 					}
3896 					break;
3897 				}
3898 				}
3899 				break;
3900 			case 4:
3901 				enterOuterAlt(_localctx, 4);
3902 				{
3903 				setState(913);
3904 				typealiasDeclaration();
3905 				setState(915);
3906 				_errHandler.sync(this);
3907 				switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
3908 				case 1:
3909 					{
3910 					setState(914);
3911 					match(T__0);
3912 					}
3913 					break;
3914 				}
3915 				}
3916 				break;
3917 			case 5:
3918 				enterOuterAlt(_localctx, 5);
3919 				{
3920 				setState(917);
3921 				functionDeclaration();
3922 				setState(919);
3923 				_errHandler.sync(this);
3924 				switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
3925 				case 1:
3926 					{
3927 					setState(918);
3928 					match(T__0);
3929 					}
3930 					break;
3931 				}
3932 				}
3933 				break;
3934 			case 6:
3935 				enterOuterAlt(_localctx, 6);
3936 				{
3937 				setState(921);
3938 				enumDeclaration();
3939 				setState(923);
3940 				_errHandler.sync(this);
3941 				switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
3942 				case 1:
3943 					{
3944 					setState(922);
3945 					match(T__0);
3946 					}
3947 					break;
3948 				}
3949 				}
3950 				break;
3951 			case 7:
3952 				enterOuterAlt(_localctx, 7);
3953 				{
3954 				setState(925);
3955 				structDeclaration();
3956 				setState(927);
3957 				_errHandler.sync(this);
3958 				switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
3959 				case 1:
3960 					{
3961 					setState(926);
3962 					match(T__0);
3963 					}
3964 					break;
3965 				}
3966 				}
3967 				break;
3968 			case 8:
3969 				enterOuterAlt(_localctx, 8);
3970 				{
3971 				setState(929);
3972 				classDeclaration();
3973 				setState(931);
3974 				_errHandler.sync(this);
3975 				switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
3976 				case 1:
3977 					{
3978 					setState(930);
3979 					match(T__0);
3980 					}
3981 					break;
3982 				}
3983 				}
3984 				break;
3985 			case 9:
3986 				enterOuterAlt(_localctx, 9);
3987 				{
3988 				setState(933);
3989 				protocolDeclaration();
3990 				setState(935);
3991 				_errHandler.sync(this);
3992 				switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
3993 				case 1:
3994 					{
3995 					setState(934);
3996 					match(T__0);
3997 					}
3998 					break;
3999 				}
4000 				}
4001 				break;
4002 			case 10:
4003 				enterOuterAlt(_localctx, 10);
4004 				{
4005 				setState(937);
4006 				initializerDeclaration();
4007 				setState(939);
4008 				_errHandler.sync(this);
4009 				switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
4010 				case 1:
4011 					{
4012 					setState(938);
4013 					match(T__0);
4014 					}
4015 					break;
4016 				}
4017 				}
4018 				break;
4019 			case 11:
4020 				enterOuterAlt(_localctx, 11);
4021 				{
4022 				setState(941);
4023 				deinitializerDeclaration();
4024 				setState(943);
4025 				_errHandler.sync(this);
4026 				switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
4027 				case 1:
4028 					{
4029 					setState(942);
4030 					match(T__0);
4031 					}
4032 					break;
4033 				}
4034 				}
4035 				break;
4036 			case 12:
4037 				enterOuterAlt(_localctx, 12);
4038 				{
4039 				setState(945);
4040 				extensionDeclaration();
4041 				setState(947);
4042 				_errHandler.sync(this);
4043 				switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
4044 				case 1:
4045 					{
4046 					setState(946);
4047 					match(T__0);
4048 					}
4049 					break;
4050 				}
4051 				}
4052 				break;
4053 			case 13:
4054 				enterOuterAlt(_localctx, 13);
4055 				{
4056 				setState(949);
4057 				subscriptDeclaration();
4058 				setState(951);
4059 				_errHandler.sync(this);
4060 				switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
4061 				case 1:
4062 					{
4063 					setState(950);
4064 					match(T__0);
4065 					}
4066 					break;
4067 				}
4068 				}
4069 				break;
4070 			case 14:
4071 				enterOuterAlt(_localctx, 14);
4072 				{
4073 				setState(953);
4074 				operatorDeclaration();
4075 				setState(955);
4076 				_errHandler.sync(this);
4077 				switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
4078 				case 1:
4079 					{
4080 					setState(954);
4081 					match(T__0);
4082 					}
4083 					break;
4084 				}
4085 				}
4086 				break;
4087 			case 15:
4088 				enterOuterAlt(_localctx, 15);
4089 				{
4090 				setState(957);
4091 				compilerControlStatement();
4092 				setState(959);
4093 				_errHandler.sync(this);
4094 				switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
4095 				case 1:
4096 					{
4097 					setState(958);
4098 					match(T__0);
4099 					}
4100 					break;
4101 				}
4102 				}
4103 				break;
4104 			}
4105 		}
4106 		catch (RecognitionException re) {
4107 			_localctx.exception = re;
4108 			_errHandler.reportError(this, re);
4109 			_errHandler.recover(this, re);
4110 		}
4111 		finally {
4112 			exitRule();
4113 		}
4114 		return _localctx;
4115 	}
4116 
4117 	public static class DeclarationsContext extends ParserRuleContext {
4118 		public DeclarationContext declaration() {
4119 			return getRuleContext(DeclarationContext.class,0);
4120 		}
4121 		public DeclarationsContext declarations() {
4122 			return getRuleContext(DeclarationsContext.class,0);
4123 		}
4124 		public DeclarationsContext(ParserRuleContext parent, int invokingState) {
4125 			super(parent, invokingState);
4126 		}
4127 		@Override public int getRuleIndex() { return RULE_declarations; }
4128 		@Override
4129 		public void enterRule(ParseTreeListener listener) {
4130 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDeclarations(this);
4131 		}
4132 		@Override
4133 		public void exitRule(ParseTreeListener listener) {
4134 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDeclarations(this);
4135 		}
4136 	}
4137 
4138 	public final DeclarationsContext declarations() throws RecognitionException {
4139 		DeclarationsContext _localctx = new DeclarationsContext(_ctx, getState());
4140 		enterRule(_localctx, 120, RULE_declarations);
4141 		int _la;
4142 		try {
4143 			enterOuterAlt(_localctx, 1);
4144 			{
4145 			setState(963);
4146 			declaration();
4147 			setState(965);
4148 			_la = _input.LA(1);
4149 			if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (T__25 - 26)) | (1L << (T__26 - 26)) | (1L << (T__41 - 26)) | (1L << (T__42 - 26)) | (1L << (T__43 - 26)) | (1L << (T__44 - 26)) | (1L << (T__45 - 26)) | (1L << (T__46 - 26)) | (1L << (T__47 - 26)) | (1L << (T__48 - 26)) | (1L << (T__49 - 26)) | (1L << (T__50 - 26)) | (1L << (T__51 - 26)) | (1L << (T__52 - 26)) | (1L << (T__53 - 26)) | (1L << (T__54 - 26)) | (1L << (T__55 - 26)) | (1L << (T__58 - 26)) | (1L << (T__59 - 26)) | (1L << (T__61 - 26)) | (1L << (T__62 - 26)) | (1L << (T__63 - 26)) | (1L << (T__64 - 26)) | (1L << (T__65 - 26)) | (1L << (T__66 - 26)) | (1L << (T__67 - 26)) | (1L << (T__68 - 26)) | (1L << (T__81 - 26)) | (1L << (T__82 - 26)) | (1L << (T__85 - 26)) | (1L << (T__86 - 26)) | (1L << (T__87 - 26)))) != 0) || ((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & ((1L << (T__96 - 97)) | (1L << (T__119 - 97)) | (1L << (T__129 - 97)))) != 0)) {
4150 				{
4151 				setState(964);
4152 				declarations();
4153 				}
4154 			}
4155 
4156 			}
4157 		}
4158 		catch (RecognitionException re) {
4159 			_localctx.exception = re;
4160 			_errHandler.reportError(this, re);
4161 			_errHandler.recover(this, re);
4162 		}
4163 		finally {
4164 			exitRule();
4165 		}
4166 		return _localctx;
4167 	}
4168 
4169 	public static class DeclarationModifiersContext extends ParserRuleContext {
4170 		public DeclarationModifierContext declarationModifier() {
4171 			return getRuleContext(DeclarationModifierContext.class,0);
4172 		}
4173 		public DeclarationModifiersContext declarationModifiers() {
4174 			return getRuleContext(DeclarationModifiersContext.class,0);
4175 		}
4176 		public DeclarationModifiersContext(ParserRuleContext parent, int invokingState) {
4177 			super(parent, invokingState);
4178 		}
4179 		@Override public int getRuleIndex() { return RULE_declarationModifiers; }
4180 		@Override
4181 		public void enterRule(ParseTreeListener listener) {
4182 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDeclarationModifiers(this);
4183 		}
4184 		@Override
4185 		public void exitRule(ParseTreeListener listener) {
4186 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDeclarationModifiers(this);
4187 		}
4188 	}
4189 
4190 	public final DeclarationModifiersContext declarationModifiers() throws RecognitionException {
4191 		DeclarationModifiersContext _localctx = new DeclarationModifiersContext(_ctx, getState());
4192 		enterRule(_localctx, 122, RULE_declarationModifiers);
4193 		int _la;
4194 		try {
4195 			enterOuterAlt(_localctx, 1);
4196 			{
4197 			setState(967);
4198 			declarationModifier();
4199 			setState(969);
4200 			_la = _input.LA(1);
4201 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
4202 				{
4203 				setState(968);
4204 				declarationModifiers();
4205 				}
4206 			}
4207 
4208 			}
4209 		}
4210 		catch (RecognitionException re) {
4211 			_localctx.exception = re;
4212 			_errHandler.reportError(this, re);
4213 			_errHandler.recover(this, re);
4214 		}
4215 		finally {
4216 			exitRule();
4217 		}
4218 		return _localctx;
4219 	}
4220 
4221 	public static class DeclarationModifierContext extends ParserRuleContext {
4222 		public AccessLevelModifierContext accessLevelModifier() {
4223 			return getRuleContext(AccessLevelModifierContext.class,0);
4224 		}
4225 		public DeclarationModifierContext(ParserRuleContext parent, int invokingState) {
4226 			super(parent, invokingState);
4227 		}
4228 		@Override public int getRuleIndex() { return RULE_declarationModifier; }
4229 		@Override
4230 		public void enterRule(ParseTreeListener listener) {
4231 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDeclarationModifier(this);
4232 		}
4233 		@Override
4234 		public void exitRule(ParseTreeListener listener) {
4235 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDeclarationModifier(this);
4236 		}
4237 	}
4238 
4239 	public final DeclarationModifierContext declarationModifier() throws RecognitionException {
4240 		DeclarationModifierContext _localctx = new DeclarationModifierContext(_ctx, getState());
4241 		enterRule(_localctx, 124, RULE_declarationModifier);
4242 		try {
4243 			setState(996);
4244 			_errHandler.sync(this);
4245 			switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
4246 			case 1:
4247 				enterOuterAlt(_localctx, 1);
4248 				{
4249 				setState(971);
4250 				match(T__41);
4251 				}
4252 				break;
4253 			case 2:
4254 				enterOuterAlt(_localctx, 2);
4255 				{
4256 				setState(972);
4257 				match(T__42);
4258 				}
4259 				break;
4260 			case 3:
4261 				enterOuterAlt(_localctx, 3);
4262 				{
4263 				setState(973);
4264 				match(T__43);
4265 				}
4266 				break;
4267 			case 4:
4268 				enterOuterAlt(_localctx, 4);
4269 				{
4270 				setState(974);
4271 				match(T__44);
4272 				}
4273 				break;
4274 			case 5:
4275 				enterOuterAlt(_localctx, 5);
4276 				{
4277 				setState(975);
4278 				match(T__45);
4279 				}
4280 				break;
4281 			case 6:
4282 				enterOuterAlt(_localctx, 6);
4283 				{
4284 				setState(976);
4285 				match(T__46);
4286 				}
4287 				break;
4288 			case 7:
4289 				enterOuterAlt(_localctx, 7);
4290 				{
4291 				setState(977);
4292 				match(T__47);
4293 				}
4294 				break;
4295 			case 8:
4296 				enterOuterAlt(_localctx, 8);
4297 				{
4298 				setState(978);
4299 				match(T__48);
4300 				}
4301 				break;
4302 			case 9:
4303 				enterOuterAlt(_localctx, 9);
4304 				{
4305 				setState(979);
4306 				match(T__49);
4307 				}
4308 				break;
4309 			case 10:
4310 				enterOuterAlt(_localctx, 10);
4311 				{
4312 				setState(980);
4313 				match(T__50);
4314 				}
4315 				break;
4316 			case 11:
4317 				enterOuterAlt(_localctx, 11);
4318 				{
4319 				setState(981);
4320 				match(T__51);
4321 				}
4322 				break;
4323 			case 12:
4324 				enterOuterAlt(_localctx, 12);
4325 				{
4326 				setState(982);
4327 				match(T__52);
4328 				}
4329 				break;
4330 			case 13:
4331 				enterOuterAlt(_localctx, 13);
4332 				{
4333 				setState(983);
4334 				match(T__53);
4335 				}
4336 				break;
4337 			case 14:
4338 				enterOuterAlt(_localctx, 14);
4339 				{
4340 				setState(984);
4341 				match(T__54);
4342 				}
4343 				break;
4344 			case 15:
4345 				enterOuterAlt(_localctx, 15);
4346 				{
4347 				setState(985);
4348 				match(T__55);
4349 				}
4350 				break;
4351 			case 16:
4352 				enterOuterAlt(_localctx, 16);
4353 				{
4354 				setState(986);
4355 				match(T__55);
4356 				setState(987);
4357 				match(T__3);
4358 				setState(988);
4359 				match(T__56);
4360 				setState(989);
4361 				match(T__4);
4362 				}
4363 				break;
4364 			case 17:
4365 				enterOuterAlt(_localctx, 17);
4366 				{
4367 				setState(990);
4368 				match(T__55);
4369 				setState(991);
4370 				match(T__3);
4371 				setState(992);
4372 				match(T__57);
4373 				setState(993);
4374 				match(T__4);
4375 				}
4376 				break;
4377 			case 18:
4378 				enterOuterAlt(_localctx, 18);
4379 				{
4380 				setState(994);
4381 				match(T__58);
4382 				}
4383 				break;
4384 			case 19:
4385 				enterOuterAlt(_localctx, 19);
4386 				{
4387 				setState(995);
4388 				accessLevelModifier();
4389 				}
4390 				break;
4391 			}
4392 		}
4393 		catch (RecognitionException re) {
4394 			_localctx.exception = re;
4395 			_errHandler.reportError(this, re);
4396 			_errHandler.recover(this, re);
4397 		}
4398 		finally {
4399 			exitRule();
4400 		}
4401 		return _localctx;
4402 	}
4403 
4404 	public static class AccessLevelModifierContext extends ParserRuleContext {
4405 		public AccessLevelModifierContext(ParserRuleContext parent, int invokingState) {
4406 			super(parent, invokingState);
4407 		}
4408 		@Override public int getRuleIndex() { return RULE_accessLevelModifier; }
4409 		@Override
4410 		public void enterRule(ParseTreeListener listener) {
4411 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAccessLevelModifier(this);
4412 		}
4413 		@Override
4414 		public void exitRule(ParseTreeListener listener) {
4415 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAccessLevelModifier(this);
4416 		}
4417 	}
4418 
4419 	public final AccessLevelModifierContext accessLevelModifier() throws RecognitionException {
4420 		AccessLevelModifierContext _localctx = new AccessLevelModifierContext(_ctx, getState());
4421 		enterRule(_localctx, 126, RULE_accessLevelModifier);
4422 		try {
4423 			setState(1013);
4424 			_errHandler.sync(this);
4425 			switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
4426 			case 1:
4427 				enterOuterAlt(_localctx, 1);
4428 				{
4429 				setState(998);
4430 				match(T__59);
4431 				}
4432 				break;
4433 			case 2:
4434 				enterOuterAlt(_localctx, 2);
4435 				{
4436 				setState(999);
4437 				match(T__59);
4438 				setState(1000);
4439 				match(T__3);
4440 				setState(1001);
4441 				match(T__60);
4442 				setState(1002);
4443 				match(T__4);
4444 				}
4445 				break;
4446 			case 3:
4447 				enterOuterAlt(_localctx, 3);
4448 				{
4449 				setState(1003);
4450 				match(T__61);
4451 				}
4452 				break;
4453 			case 4:
4454 				enterOuterAlt(_localctx, 4);
4455 				{
4456 				setState(1004);
4457 				match(T__61);
4458 				setState(1005);
4459 				match(T__3);
4460 				setState(1006);
4461 				match(T__60);
4462 				setState(1007);
4463 				match(T__4);
4464 				}
4465 				break;
4466 			case 5:
4467 				enterOuterAlt(_localctx, 5);
4468 				{
4469 				setState(1008);
4470 				match(T__62);
4471 				}
4472 				break;
4473 			case 6:
4474 				enterOuterAlt(_localctx, 6);
4475 				{
4476 				setState(1009);
4477 				match(T__62);
4478 				setState(1010);
4479 				match(T__3);
4480 				setState(1011);
4481 				match(T__60);
4482 				setState(1012);
4483 				match(T__4);
4484 				}
4485 				break;
4486 			}
4487 		}
4488 		catch (RecognitionException re) {
4489 			_localctx.exception = re;
4490 			_errHandler.reportError(this, re);
4491 			_errHandler.recover(this, re);
4492 		}
4493 		finally {
4494 			exitRule();
4495 		}
4496 		return _localctx;
4497 	}
4498 
4499 	public static class AccessLevelModifiersContext extends ParserRuleContext {
4500 		public AccessLevelModifierContext accessLevelModifier() {
4501 			return getRuleContext(AccessLevelModifierContext.class,0);
4502 		}
4503 		public AccessLevelModifiersContext accessLevelModifiers() {
4504 			return getRuleContext(AccessLevelModifiersContext.class,0);
4505 		}
4506 		public AccessLevelModifiersContext(ParserRuleContext parent, int invokingState) {
4507 			super(parent, invokingState);
4508 		}
4509 		@Override public int getRuleIndex() { return RULE_accessLevelModifiers; }
4510 		@Override
4511 		public void enterRule(ParseTreeListener listener) {
4512 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAccessLevelModifiers(this);
4513 		}
4514 		@Override
4515 		public void exitRule(ParseTreeListener listener) {
4516 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAccessLevelModifiers(this);
4517 		}
4518 	}
4519 
4520 	public final AccessLevelModifiersContext accessLevelModifiers() throws RecognitionException {
4521 		AccessLevelModifiersContext _localctx = new AccessLevelModifiersContext(_ctx, getState());
4522 		enterRule(_localctx, 128, RULE_accessLevelModifiers);
4523 		try {
4524 			enterOuterAlt(_localctx, 1);
4525 			{
4526 			setState(1015);
4527 			accessLevelModifier();
4528 			setState(1017);
4529 			_errHandler.sync(this);
4530 			switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
4531 			case 1:
4532 				{
4533 				setState(1016);
4534 				accessLevelModifiers();
4535 				}
4536 				break;
4537 			}
4538 			}
4539 		}
4540 		catch (RecognitionException re) {
4541 			_localctx.exception = re;
4542 			_errHandler.reportError(this, re);
4543 			_errHandler.recover(this, re);
4544 		}
4545 		finally {
4546 			exitRule();
4547 		}
4548 		return _localctx;
4549 	}
4550 
4551 	public static class CodeBlockContext extends ParserRuleContext {
4552 		public StatementsContext statements() {
4553 			return getRuleContext(StatementsContext.class,0);
4554 		}
4555 		public CodeBlockContext(ParserRuleContext parent, int invokingState) {
4556 			super(parent, invokingState);
4557 		}
4558 		@Override public int getRuleIndex() { return RULE_codeBlock; }
4559 		@Override
4560 		public void enterRule(ParseTreeListener listener) {
4561 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCodeBlock(this);
4562 		}
4563 		@Override
4564 		public void exitRule(ParseTreeListener listener) {
4565 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCodeBlock(this);
4566 		}
4567 	}
4568 
4569 	public final CodeBlockContext codeBlock() throws RecognitionException {
4570 		CodeBlockContext _localctx = new CodeBlockContext(_ctx, getState());
4571 		enterRule(_localctx, 130, RULE_codeBlock);
4572 		int _la;
4573 		try {
4574 			enterOuterAlt(_localctx, 1);
4575 			{
4576 			setState(1019);
4577 			match(T__13);
4578 			setState(1021);
4579 			_la = _input.LA(1);
4580 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
4581 				{
4582 				setState(1020);
4583 				statements();
4584 				}
4585 			}
4586 
4587 			setState(1023);
4588 			match(T__14);
4589 			}
4590 		}
4591 		catch (RecognitionException re) {
4592 			_localctx.exception = re;
4593 			_errHandler.reportError(this, re);
4594 			_errHandler.recover(this, re);
4595 		}
4596 		finally {
4597 			exitRule();
4598 		}
4599 		return _localctx;
4600 	}
4601 
4602 	public static class ImportDeclarationContext extends ParserRuleContext {
4603 		public ImportPathContext importPath() {
4604 			return getRuleContext(ImportPathContext.class,0);
4605 		}
4606 		public AttributesContext attributes() {
4607 			return getRuleContext(AttributesContext.class,0);
4608 		}
4609 		public ImportKindContext importKind() {
4610 			return getRuleContext(ImportKindContext.class,0);
4611 		}
4612 		public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
4613 			super(parent, invokingState);
4614 		}
4615 		@Override public int getRuleIndex() { return RULE_importDeclaration; }
4616 		@Override
4617 		public void enterRule(ParseTreeListener listener) {
4618 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterImportDeclaration(this);
4619 		}
4620 		@Override
4621 		public void exitRule(ParseTreeListener listener) {
4622 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitImportDeclaration(this);
4623 		}
4624 	}
4625 
4626 	public final ImportDeclarationContext importDeclaration() throws RecognitionException {
4627 		ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
4628 		enterRule(_localctx, 132, RULE_importDeclaration);
4629 		int _la;
4630 		try {
4631 			enterOuterAlt(_localctx, 1);
4632 			{
4633 			setState(1026);
4634 			_la = _input.LA(1);
4635 			if (_la==T__96) {
4636 				{
4637 				setState(1025);
4638 				attributes();
4639 				}
4640 			}
4641 
4642 			setState(1028);
4643 			match(T__63);
4644 			setState(1030);
4645 			_la = _input.LA(1);
4646 			if (((((_la - 27)) & ~0x3f) == 0 && ((1L << (_la - 27)) & ((1L << (T__26 - 27)) | (1L << (T__41 - 27)) | (1L << (T__64 - 27)) | (1L << (T__65 - 27)) | (1L << (T__66 - 27)) | (1L << (T__67 - 27)) | (1L << (T__68 - 27)))) != 0)) {
4647 				{
4648 				setState(1029);
4649 				importKind();
4650 				}
4651 			}
4652 
4653 			setState(1032);
4654 			importPath();
4655 			}
4656 		}
4657 		catch (RecognitionException re) {
4658 			_localctx.exception = re;
4659 			_errHandler.reportError(this, re);
4660 			_errHandler.recover(this, re);
4661 		}
4662 		finally {
4663 			exitRule();
4664 		}
4665 		return _localctx;
4666 	}
4667 
4668 	public static class ImportKindContext extends ParserRuleContext {
4669 		public ImportKindContext(ParserRuleContext parent, int invokingState) {
4670 			super(parent, invokingState);
4671 		}
4672 		@Override public int getRuleIndex() { return RULE_importKind; }
4673 		@Override
4674 		public void enterRule(ParseTreeListener listener) {
4675 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterImportKind(this);
4676 		}
4677 		@Override
4678 		public void exitRule(ParseTreeListener listener) {
4679 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitImportKind(this);
4680 		}
4681 	}
4682 
4683 	public final ImportKindContext importKind() throws RecognitionException {
4684 		ImportKindContext _localctx = new ImportKindContext(_ctx, getState());
4685 		enterRule(_localctx, 134, RULE_importKind);
4686 		int _la;
4687 		try {
4688 			enterOuterAlt(_localctx, 1);
4689 			{
4690 			setState(1034);
4691 			_la = _input.LA(1);
4692 			if ( !(((((_la - 27)) & ~0x3f) == 0 && ((1L << (_la - 27)) & ((1L << (T__26 - 27)) | (1L << (T__41 - 27)) | (1L << (T__64 - 27)) | (1L << (T__65 - 27)) | (1L << (T__66 - 27)) | (1L << (T__67 - 27)) | (1L << (T__68 - 27)))) != 0)) ) {
4693 			_errHandler.recoverInline(this);
4694 			} else {
4695 				consume();
4696 			}
4697 			}
4698 		}
4699 		catch (RecognitionException re) {
4700 			_localctx.exception = re;
4701 			_errHandler.reportError(this, re);
4702 			_errHandler.recover(this, re);
4703 		}
4704 		finally {
4705 			exitRule();
4706 		}
4707 		return _localctx;
4708 	}
4709 
4710 	public static class ImportPathContext extends ParserRuleContext {
4711 		public ImportPathIdentifierContext importPathIdentifier() {
4712 			return getRuleContext(ImportPathIdentifierContext.class,0);
4713 		}
4714 		public ImportPathContext importPath() {
4715 			return getRuleContext(ImportPathContext.class,0);
4716 		}
4717 		public ImportPathContext(ParserRuleContext parent, int invokingState) {
4718 			super(parent, invokingState);
4719 		}
4720 		@Override public int getRuleIndex() { return RULE_importPath; }
4721 		@Override
4722 		public void enterRule(ParseTreeListener listener) {
4723 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterImportPath(this);
4724 		}
4725 		@Override
4726 		public void exitRule(ParseTreeListener listener) {
4727 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitImportPath(this);
4728 		}
4729 	}
4730 
4731 	public final ImportPathContext importPath() throws RecognitionException {
4732 		ImportPathContext _localctx = new ImportPathContext(_ctx, getState());
4733 		enterRule(_localctx, 136, RULE_importPath);
4734 		try {
4735 			setState(1041);
4736 			_errHandler.sync(this);
4737 			switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
4738 			case 1:
4739 				enterOuterAlt(_localctx, 1);
4740 				{
4741 				setState(1036);
4742 				importPathIdentifier();
4743 				}
4744 				break;
4745 			case 2:
4746 				enterOuterAlt(_localctx, 2);
4747 				{
4748 				setState(1037);
4749 				importPathIdentifier();
4750 				setState(1038);
4751 				match(T__69);
4752 				setState(1039);
4753 				importPath();
4754 				}
4755 				break;
4756 			}
4757 		}
4758 		catch (RecognitionException re) {
4759 			_localctx.exception = re;
4760 			_errHandler.reportError(this, re);
4761 			_errHandler.recover(this, re);
4762 		}
4763 		finally {
4764 			exitRule();
4765 		}
4766 		return _localctx;
4767 	}
4768 
4769 	public static class ImportPathIdentifierContext extends ParserRuleContext {
4770 		public IdentifierContext identifier() {
4771 			return getRuleContext(IdentifierContext.class,0);
4772 		}
4773 		public OperatorContext operator() {
4774 			return getRuleContext(OperatorContext.class,0);
4775 		}
4776 		public ImportPathIdentifierContext(ParserRuleContext parent, int invokingState) {
4777 			super(parent, invokingState);
4778 		}
4779 		@Override public int getRuleIndex() { return RULE_importPathIdentifier; }
4780 		@Override
4781 		public void enterRule(ParseTreeListener listener) {
4782 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterImportPathIdentifier(this);
4783 		}
4784 		@Override
4785 		public void exitRule(ParseTreeListener listener) {
4786 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitImportPathIdentifier(this);
4787 		}
4788 	}
4789 
4790 	public final ImportPathIdentifierContext importPathIdentifier() throws RecognitionException {
4791 		ImportPathIdentifierContext _localctx = new ImportPathIdentifierContext(_ctx, getState());
4792 		enterRule(_localctx, 138, RULE_importPathIdentifier);
4793 		try {
4794 			setState(1045);
4795 			switch (_input.LA(1)) {
4796 			case T__30:
4797 			case T__31:
4798 			case T__32:
4799 			case T__34:
4800 			case T__42:
4801 			case T__43:
4802 			case T__44:
4803 			case T__45:
4804 			case T__46:
4805 			case T__47:
4806 			case T__48:
4807 			case T__49:
4808 			case T__50:
4809 			case T__51:
4810 			case T__52:
4811 			case T__53:
4812 			case T__55:
4813 			case T__58:
4814 			case T__60:
4815 			case T__71:
4816 			case T__72:
4817 			case T__73:
4818 			case T__81:
4819 			case T__88:
4820 			case T__89:
4821 			case T__90:
4822 			case T__91:
4823 			case T__92:
4824 			case T__93:
4825 			case T__116:
4826 			case T__117:
4827 			case T__123:
4828 			case T__124:
4829 			case T__125:
4830 			case T__126:
4831 			case T__127:
4832 			case T__128:
4833 			case T__130:
4834 			case Identifier:
4835 				enterOuterAlt(_localctx, 1);
4836 				{
4837 				setState(1043);
4838 				identifier();
4839 				}
4840 				break;
4841 			case T__29:
4842 			case T__38:
4843 			case T__39:
4844 			case T__40:
4845 			case T__70:
4846 			case T__77:
4847 			case T__83:
4848 			case T__84:
4849 			case T__99:
4850 			case T__101:
4851 			case T__103:
4852 			case T__114:
4853 			case T__115:
4854 			case OperatorHead:
4855 			case DotOperatorHead:
4856 				enterOuterAlt(_localctx, 2);
4857 				{
4858 				setState(1044);
4859 				operator();
4860 				}
4861 				break;
4862 			default:
4863 				throw new NoViableAltException(this);
4864 			}
4865 		}
4866 		catch (RecognitionException re) {
4867 			_localctx.exception = re;
4868 			_errHandler.reportError(this, re);
4869 			_errHandler.recover(this, re);
4870 		}
4871 		finally {
4872 			exitRule();
4873 		}
4874 		return _localctx;
4875 	}
4876 
4877 	public static class ConstantDeclarationContext extends ParserRuleContext {
4878 		public PatternInitializerListContext patternInitializerList() {
4879 			return getRuleContext(PatternInitializerListContext.class,0);
4880 		}
4881 		public AttributesContext attributes() {
4882 			return getRuleContext(AttributesContext.class,0);
4883 		}
4884 		public DeclarationModifiersContext declarationModifiers() {
4885 			return getRuleContext(DeclarationModifiersContext.class,0);
4886 		}
4887 		public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
4888 			super(parent, invokingState);
4889 		}
4890 		@Override public int getRuleIndex() { return RULE_constantDeclaration; }
4891 		@Override
4892 		public void enterRule(ParseTreeListener listener) {
4893 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterConstantDeclaration(this);
4894 		}
4895 		@Override
4896 		public void exitRule(ParseTreeListener listener) {
4897 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitConstantDeclaration(this);
4898 		}
4899 	}
4900 
4901 	public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
4902 		ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
4903 		enterRule(_localctx, 140, RULE_constantDeclaration);
4904 		int _la;
4905 		try {
4906 			enterOuterAlt(_localctx, 1);
4907 			{
4908 			setState(1048);
4909 			_la = _input.LA(1);
4910 			if (_la==T__96) {
4911 				{
4912 				setState(1047);
4913 				attributes();
4914 				}
4915 			}
4916 
4917 			setState(1051);
4918 			_la = _input.LA(1);
4919 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
4920 				{
4921 				setState(1050);
4922 				declarationModifiers();
4923 				}
4924 			}
4925 
4926 			setState(1053);
4927 			match(T__25);
4928 			setState(1054);
4929 			patternInitializerList();
4930 			}
4931 		}
4932 		catch (RecognitionException re) {
4933 			_localctx.exception = re;
4934 			_errHandler.reportError(this, re);
4935 			_errHandler.recover(this, re);
4936 		}
4937 		finally {
4938 			exitRule();
4939 		}
4940 		return _localctx;
4941 	}
4942 
4943 	public static class PatternInitializerListContext extends ParserRuleContext {
4944 		public List<PatternInitializerContext> patternInitializer() {
4945 			return getRuleContexts(PatternInitializerContext.class);
4946 		}
4947 		public PatternInitializerContext patternInitializer(int i) {
4948 			return getRuleContext(PatternInitializerContext.class,i);
4949 		}
4950 		public PatternInitializerListContext(ParserRuleContext parent, int invokingState) {
4951 			super(parent, invokingState);
4952 		}
4953 		@Override public int getRuleIndex() { return RULE_patternInitializerList; }
4954 		@Override
4955 		public void enterRule(ParseTreeListener listener) {
4956 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPatternInitializerList(this);
4957 		}
4958 		@Override
4959 		public void exitRule(ParseTreeListener listener) {
4960 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPatternInitializerList(this);
4961 		}
4962 	}
4963 
4964 	public final PatternInitializerListContext patternInitializerList() throws RecognitionException {
4965 		PatternInitializerListContext _localctx = new PatternInitializerListContext(_ctx, getState());
4966 		enterRule(_localctx, 142, RULE_patternInitializerList);
4967 		int _la;
4968 		try {
4969 			enterOuterAlt(_localctx, 1);
4970 			{
4971 			setState(1056);
4972 			patternInitializer();
4973 			setState(1061);
4974 			_errHandler.sync(this);
4975 			_la = _input.LA(1);
4976 			while (_la==T__15) {
4977 				{
4978 				{
4979 				setState(1057);
4980 				match(T__15);
4981 				setState(1058);
4982 				patternInitializer();
4983 				}
4984 				}
4985 				setState(1063);
4986 				_errHandler.sync(this);
4987 				_la = _input.LA(1);
4988 			}
4989 			}
4990 		}
4991 		catch (RecognitionException re) {
4992 			_localctx.exception = re;
4993 			_errHandler.reportError(this, re);
4994 			_errHandler.recover(this, re);
4995 		}
4996 		finally {
4997 			exitRule();
4998 		}
4999 		return _localctx;
5000 	}
5001 
5002 	public static class PatternInitializerContext extends ParserRuleContext {
5003 		public PatternContext pattern() {
5004 			return getRuleContext(PatternContext.class,0);
5005 		}
5006 		public InitializerContext initializer() {
5007 			return getRuleContext(InitializerContext.class,0);
5008 		}
5009 		public PatternInitializerContext(ParserRuleContext parent, int invokingState) {
5010 			super(parent, invokingState);
5011 		}
5012 		@Override public int getRuleIndex() { return RULE_patternInitializer; }
5013 		@Override
5014 		public void enterRule(ParseTreeListener listener) {
5015 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPatternInitializer(this);
5016 		}
5017 		@Override
5018 		public void exitRule(ParseTreeListener listener) {
5019 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPatternInitializer(this);
5020 		}
5021 	}
5022 
5023 	public final PatternInitializerContext patternInitializer() throws RecognitionException {
5024 		PatternInitializerContext _localctx = new PatternInitializerContext(_ctx, getState());
5025 		enterRule(_localctx, 144, RULE_patternInitializer);
5026 		try {
5027 			enterOuterAlt(_localctx, 1);
5028 			{
5029 			setState(1064);
5030 			pattern(0);
5031 			setState(1066);
5032 			_errHandler.sync(this);
5033 			switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
5034 			case 1:
5035 				{
5036 				setState(1065);
5037 				initializer();
5038 				}
5039 				break;
5040 			}
5041 			}
5042 		}
5043 		catch (RecognitionException re) {
5044 			_localctx.exception = re;
5045 			_errHandler.reportError(this, re);
5046 			_errHandler.recover(this, re);
5047 		}
5048 		finally {
5049 			exitRule();
5050 		}
5051 		return _localctx;
5052 	}
5053 
5054 	public static class InitializerContext extends ParserRuleContext {
5055 		public ExpressionContext expression() {
5056 			return getRuleContext(ExpressionContext.class,0);
5057 		}
5058 		public InitializerContext(ParserRuleContext parent, int invokingState) {
5059 			super(parent, invokingState);
5060 		}
5061 		@Override public int getRuleIndex() { return RULE_initializer; }
5062 		@Override
5063 		public void enterRule(ParseTreeListener listener) {
5064 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInitializer(this);
5065 		}
5066 		@Override
5067 		public void exitRule(ParseTreeListener listener) {
5068 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInitializer(this);
5069 		}
5070 	}
5071 
5072 	public final InitializerContext initializer() throws RecognitionException {
5073 		InitializerContext _localctx = new InitializerContext(_ctx, getState());
5074 		enterRule(_localctx, 146, RULE_initializer);
5075 		try {
5076 			enterOuterAlt(_localctx, 1);
5077 			{
5078 			setState(1068);
5079 			match(T__70);
5080 			setState(1069);
5081 			expression();
5082 			}
5083 		}
5084 		catch (RecognitionException re) {
5085 			_localctx.exception = re;
5086 			_errHandler.reportError(this, re);
5087 			_errHandler.recover(this, re);
5088 		}
5089 		finally {
5090 			exitRule();
5091 		}
5092 		return _localctx;
5093 	}
5094 
5095 	public static class VariableDeclarationContext extends ParserRuleContext {
5096 		public VariableDeclarationHeadContext variableDeclarationHead() {
5097 			return getRuleContext(VariableDeclarationHeadContext.class,0);
5098 		}
5099 		public VariableNameContext variableName() {
5100 			return getRuleContext(VariableNameContext.class,0);
5101 		}
5102 		public TypeAnnotationContext typeAnnotation() {
5103 			return getRuleContext(TypeAnnotationContext.class,0);
5104 		}
5105 		public GetterSetterBlockContext getterSetterBlock() {
5106 			return getRuleContext(GetterSetterBlockContext.class,0);
5107 		}
5108 		public GetterSetterKeywordBlockContext getterSetterKeywordBlock() {
5109 			return getRuleContext(GetterSetterKeywordBlockContext.class,0);
5110 		}
5111 		public InitializerContext initializer() {
5112 			return getRuleContext(InitializerContext.class,0);
5113 		}
5114 		public WillSetDidSetBlockContext willSetDidSetBlock() {
5115 			return getRuleContext(WillSetDidSetBlockContext.class,0);
5116 		}
5117 		public CodeBlockContext codeBlock() {
5118 			return getRuleContext(CodeBlockContext.class,0);
5119 		}
5120 		public PatternInitializerListContext patternInitializerList() {
5121 			return getRuleContext(PatternInitializerListContext.class,0);
5122 		}
5123 		public VariableDeclarationContext(ParserRuleContext parent, int invokingState) {
5124 			super(parent, invokingState);
5125 		}
5126 		@Override public int getRuleIndex() { return RULE_variableDeclaration; }
5127 		@Override
5128 		public void enterRule(ParseTreeListener listener) {
5129 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterVariableDeclaration(this);
5130 		}
5131 		@Override
5132 		public void exitRule(ParseTreeListener listener) {
5133 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitVariableDeclaration(this);
5134 		}
5135 	}
5136 
5137 	public final VariableDeclarationContext variableDeclaration() throws RecognitionException {
5138 		VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState());
5139 		enterRule(_localctx, 148, RULE_variableDeclaration);
5140 		int _la;
5141 		try {
5142 			setState(1102);
5143 			_errHandler.sync(this);
5144 			switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
5145 			case 1:
5146 				enterOuterAlt(_localctx, 1);
5147 				{
5148 				setState(1071);
5149 				variableDeclarationHead();
5150 				setState(1072);
5151 				variableName();
5152 				setState(1073);
5153 				typeAnnotation();
5154 				setState(1074);
5155 				getterSetterBlock();
5156 				}
5157 				break;
5158 			case 2:
5159 				enterOuterAlt(_localctx, 2);
5160 				{
5161 				setState(1076);
5162 				variableDeclarationHead();
5163 				setState(1077);
5164 				variableName();
5165 				setState(1078);
5166 				typeAnnotation();
5167 				setState(1079);
5168 				getterSetterKeywordBlock();
5169 				}
5170 				break;
5171 			case 3:
5172 				enterOuterAlt(_localctx, 3);
5173 				{
5174 				setState(1081);
5175 				variableDeclarationHead();
5176 				setState(1082);
5177 				variableName();
5178 				setState(1083);
5179 				initializer();
5180 				setState(1084);
5181 				willSetDidSetBlock();
5182 				}
5183 				break;
5184 			case 4:
5185 				enterOuterAlt(_localctx, 4);
5186 				{
5187 				setState(1086);
5188 				variableDeclarationHead();
5189 				setState(1087);
5190 				variableName();
5191 				setState(1088);
5192 				typeAnnotation();
5193 				setState(1090);
5194 				_la = _input.LA(1);
5195 				if (_la==T__70) {
5196 					{
5197 					setState(1089);
5198 					initializer();
5199 					}
5200 				}
5201 
5202 				setState(1092);
5203 				willSetDidSetBlock();
5204 				}
5205 				break;
5206 			case 5:
5207 				enterOuterAlt(_localctx, 5);
5208 				{
5209 				setState(1094);
5210 				variableDeclarationHead();
5211 				setState(1095);
5212 				variableName();
5213 				setState(1096);
5214 				typeAnnotation();
5215 				setState(1097);
5216 				codeBlock();
5217 				}
5218 				break;
5219 			case 6:
5220 				enterOuterAlt(_localctx, 6);
5221 				{
5222 				setState(1099);
5223 				variableDeclarationHead();
5224 				setState(1100);
5225 				patternInitializerList();
5226 				}
5227 				break;
5228 			}
5229 		}
5230 		catch (RecognitionException re) {
5231 			_localctx.exception = re;
5232 			_errHandler.reportError(this, re);
5233 			_errHandler.recover(this, re);
5234 		}
5235 		finally {
5236 			exitRule();
5237 		}
5238 		return _localctx;
5239 	}
5240 
5241 	public static class VariableDeclarationHeadContext extends ParserRuleContext {
5242 		public AttributesContext attributes() {
5243 			return getRuleContext(AttributesContext.class,0);
5244 		}
5245 		public DeclarationModifiersContext declarationModifiers() {
5246 			return getRuleContext(DeclarationModifiersContext.class,0);
5247 		}
5248 		public VariableDeclarationHeadContext(ParserRuleContext parent, int invokingState) {
5249 			super(parent, invokingState);
5250 		}
5251 		@Override public int getRuleIndex() { return RULE_variableDeclarationHead; }
5252 		@Override
5253 		public void enterRule(ParseTreeListener listener) {
5254 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterVariableDeclarationHead(this);
5255 		}
5256 		@Override
5257 		public void exitRule(ParseTreeListener listener) {
5258 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitVariableDeclarationHead(this);
5259 		}
5260 	}
5261 
5262 	public final VariableDeclarationHeadContext variableDeclarationHead() throws RecognitionException {
5263 		VariableDeclarationHeadContext _localctx = new VariableDeclarationHeadContext(_ctx, getState());
5264 		enterRule(_localctx, 150, RULE_variableDeclarationHead);
5265 		int _la;
5266 		try {
5267 			enterOuterAlt(_localctx, 1);
5268 			{
5269 			setState(1105);
5270 			_la = _input.LA(1);
5271 			if (_la==T__96) {
5272 				{
5273 				setState(1104);
5274 				attributes();
5275 				}
5276 			}
5277 
5278 			setState(1108);
5279 			_la = _input.LA(1);
5280 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
5281 				{
5282 				setState(1107);
5283 				declarationModifiers();
5284 				}
5285 			}
5286 
5287 			setState(1110);
5288 			match(T__26);
5289 			}
5290 		}
5291 		catch (RecognitionException re) {
5292 			_localctx.exception = re;
5293 			_errHandler.reportError(this, re);
5294 			_errHandler.recover(this, re);
5295 		}
5296 		finally {
5297 			exitRule();
5298 		}
5299 		return _localctx;
5300 	}
5301 
5302 	public static class VariableNameContext extends ParserRuleContext {
5303 		public IdentifierContext identifier() {
5304 			return getRuleContext(IdentifierContext.class,0);
5305 		}
5306 		public VariableNameContext(ParserRuleContext parent, int invokingState) {
5307 			super(parent, invokingState);
5308 		}
5309 		@Override public int getRuleIndex() { return RULE_variableName; }
5310 		@Override
5311 		public void enterRule(ParseTreeListener listener) {
5312 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterVariableName(this);
5313 		}
5314 		@Override
5315 		public void exitRule(ParseTreeListener listener) {
5316 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitVariableName(this);
5317 		}
5318 	}
5319 
5320 	public final VariableNameContext variableName() throws RecognitionException {
5321 		VariableNameContext _localctx = new VariableNameContext(_ctx, getState());
5322 		enterRule(_localctx, 152, RULE_variableName);
5323 		try {
5324 			enterOuterAlt(_localctx, 1);
5325 			{
5326 			setState(1112);
5327 			identifier();
5328 			}
5329 		}
5330 		catch (RecognitionException re) {
5331 			_localctx.exception = re;
5332 			_errHandler.reportError(this, re);
5333 			_errHandler.recover(this, re);
5334 		}
5335 		finally {
5336 			exitRule();
5337 		}
5338 		return _localctx;
5339 	}
5340 
5341 	public static class GetterSetterBlockContext extends ParserRuleContext {
5342 		public GetterClauseContext getterClause() {
5343 			return getRuleContext(GetterClauseContext.class,0);
5344 		}
5345 		public SetterClauseContext setterClause() {
5346 			return getRuleContext(SetterClauseContext.class,0);
5347 		}
5348 		public GetterSetterBlockContext(ParserRuleContext parent, int invokingState) {
5349 			super(parent, invokingState);
5350 		}
5351 		@Override public int getRuleIndex() { return RULE_getterSetterBlock; }
5352 		@Override
5353 		public void enterRule(ParseTreeListener listener) {
5354 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGetterSetterBlock(this);
5355 		}
5356 		@Override
5357 		public void exitRule(ParseTreeListener listener) {
5358 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGetterSetterBlock(this);
5359 		}
5360 	}
5361 
5362 	public final GetterSetterBlockContext getterSetterBlock() throws RecognitionException {
5363 		GetterSetterBlockContext _localctx = new GetterSetterBlockContext(_ctx, getState());
5364 		enterRule(_localctx, 154, RULE_getterSetterBlock);
5365 		int _la;
5366 		try {
5367 			setState(1126);
5368 			_errHandler.sync(this);
5369 			switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) {
5370 			case 1:
5371 				enterOuterAlt(_localctx, 1);
5372 				{
5373 				setState(1114);
5374 				match(T__13);
5375 				setState(1115);
5376 				getterClause();
5377 				setState(1117);
5378 				_la = _input.LA(1);
5379 				if (_la==T__60 || _la==T__96) {
5380 					{
5381 					setState(1116);
5382 					setterClause();
5383 					}
5384 				}
5385 
5386 				setState(1119);
5387 				match(T__14);
5388 				}
5389 				break;
5390 			case 2:
5391 				enterOuterAlt(_localctx, 2);
5392 				{
5393 				setState(1121);
5394 				match(T__13);
5395 				setState(1122);
5396 				setterClause();
5397 				setState(1123);
5398 				getterClause();
5399 				setState(1124);
5400 				match(T__14);
5401 				}
5402 				break;
5403 			}
5404 		}
5405 		catch (RecognitionException re) {
5406 			_localctx.exception = re;
5407 			_errHandler.reportError(this, re);
5408 			_errHandler.recover(this, re);
5409 		}
5410 		finally {
5411 			exitRule();
5412 		}
5413 		return _localctx;
5414 	}
5415 
5416 	public static class GetterClauseContext extends ParserRuleContext {
5417 		public CodeBlockContext codeBlock() {
5418 			return getRuleContext(CodeBlockContext.class,0);
5419 		}
5420 		public AttributesContext attributes() {
5421 			return getRuleContext(AttributesContext.class,0);
5422 		}
5423 		public GetterClauseContext(ParserRuleContext parent, int invokingState) {
5424 			super(parent, invokingState);
5425 		}
5426 		@Override public int getRuleIndex() { return RULE_getterClause; }
5427 		@Override
5428 		public void enterRule(ParseTreeListener listener) {
5429 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGetterClause(this);
5430 		}
5431 		@Override
5432 		public void exitRule(ParseTreeListener listener) {
5433 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGetterClause(this);
5434 		}
5435 	}
5436 
5437 	public final GetterClauseContext getterClause() throws RecognitionException {
5438 		GetterClauseContext _localctx = new GetterClauseContext(_ctx, getState());
5439 		enterRule(_localctx, 156, RULE_getterClause);
5440 		int _la;
5441 		try {
5442 			enterOuterAlt(_localctx, 1);
5443 			{
5444 			setState(1129);
5445 			_la = _input.LA(1);
5446 			if (_la==T__96) {
5447 				{
5448 				setState(1128);
5449 				attributes();
5450 				}
5451 			}
5452 
5453 			setState(1131);
5454 			match(T__71);
5455 			setState(1132);
5456 			codeBlock();
5457 			}
5458 		}
5459 		catch (RecognitionException re) {
5460 			_localctx.exception = re;
5461 			_errHandler.reportError(this, re);
5462 			_errHandler.recover(this, re);
5463 		}
5464 		finally {
5465 			exitRule();
5466 		}
5467 		return _localctx;
5468 	}
5469 
5470 	public static class SetterClauseContext extends ParserRuleContext {
5471 		public CodeBlockContext codeBlock() {
5472 			return getRuleContext(CodeBlockContext.class,0);
5473 		}
5474 		public AttributesContext attributes() {
5475 			return getRuleContext(AttributesContext.class,0);
5476 		}
5477 		public SetterNameContext setterName() {
5478 			return getRuleContext(SetterNameContext.class,0);
5479 		}
5480 		public SetterClauseContext(ParserRuleContext parent, int invokingState) {
5481 			super(parent, invokingState);
5482 		}
5483 		@Override public int getRuleIndex() { return RULE_setterClause; }
5484 		@Override
5485 		public void enterRule(ParseTreeListener listener) {
5486 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSetterClause(this);
5487 		}
5488 		@Override
5489 		public void exitRule(ParseTreeListener listener) {
5490 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSetterClause(this);
5491 		}
5492 	}
5493 
5494 	public final SetterClauseContext setterClause() throws RecognitionException {
5495 		SetterClauseContext _localctx = new SetterClauseContext(_ctx, getState());
5496 		enterRule(_localctx, 158, RULE_setterClause);
5497 		int _la;
5498 		try {
5499 			enterOuterAlt(_localctx, 1);
5500 			{
5501 			setState(1135);
5502 			_la = _input.LA(1);
5503 			if (_la==T__96) {
5504 				{
5505 				setState(1134);
5506 				attributes();
5507 				}
5508 			}
5509 
5510 			setState(1137);
5511 			match(T__60);
5512 			setState(1139);
5513 			_la = _input.LA(1);
5514 			if (_la==T__3) {
5515 				{
5516 				setState(1138);
5517 				setterName();
5518 				}
5519 			}
5520 
5521 			setState(1141);
5522 			codeBlock();
5523 			}
5524 		}
5525 		catch (RecognitionException re) {
5526 			_localctx.exception = re;
5527 			_errHandler.reportError(this, re);
5528 			_errHandler.recover(this, re);
5529 		}
5530 		finally {
5531 			exitRule();
5532 		}
5533 		return _localctx;
5534 	}
5535 
5536 	public static class SetterNameContext extends ParserRuleContext {
5537 		public IdentifierContext identifier() {
5538 			return getRuleContext(IdentifierContext.class,0);
5539 		}
5540 		public SetterNameContext(ParserRuleContext parent, int invokingState) {
5541 			super(parent, invokingState);
5542 		}
5543 		@Override public int getRuleIndex() { return RULE_setterName; }
5544 		@Override
5545 		public void enterRule(ParseTreeListener listener) {
5546 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSetterName(this);
5547 		}
5548 		@Override
5549 		public void exitRule(ParseTreeListener listener) {
5550 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSetterName(this);
5551 		}
5552 	}
5553 
5554 	public final SetterNameContext setterName() throws RecognitionException {
5555 		SetterNameContext _localctx = new SetterNameContext(_ctx, getState());
5556 		enterRule(_localctx, 160, RULE_setterName);
5557 		try {
5558 			enterOuterAlt(_localctx, 1);
5559 			{
5560 			setState(1143);
5561 			match(T__3);
5562 			setState(1144);
5563 			identifier();
5564 			setState(1145);
5565 			match(T__4);
5566 			}
5567 		}
5568 		catch (RecognitionException re) {
5569 			_localctx.exception = re;
5570 			_errHandler.reportError(this, re);
5571 			_errHandler.recover(this, re);
5572 		}
5573 		finally {
5574 			exitRule();
5575 		}
5576 		return _localctx;
5577 	}
5578 
5579 	public static class GetterSetterKeywordBlockContext extends ParserRuleContext {
5580 		public GetterKeywordClauseContext getterKeywordClause() {
5581 			return getRuleContext(GetterKeywordClauseContext.class,0);
5582 		}
5583 		public SetterKeywordClauseContext setterKeywordClause() {
5584 			return getRuleContext(SetterKeywordClauseContext.class,0);
5585 		}
5586 		public GetterSetterKeywordBlockContext(ParserRuleContext parent, int invokingState) {
5587 			super(parent, invokingState);
5588 		}
5589 		@Override public int getRuleIndex() { return RULE_getterSetterKeywordBlock; }
5590 		@Override
5591 		public void enterRule(ParseTreeListener listener) {
5592 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGetterSetterKeywordBlock(this);
5593 		}
5594 		@Override
5595 		public void exitRule(ParseTreeListener listener) {
5596 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGetterSetterKeywordBlock(this);
5597 		}
5598 	}
5599 
5600 	public final GetterSetterKeywordBlockContext getterSetterKeywordBlock() throws RecognitionException {
5601 		GetterSetterKeywordBlockContext _localctx = new GetterSetterKeywordBlockContext(_ctx, getState());
5602 		enterRule(_localctx, 162, RULE_getterSetterKeywordBlock);
5603 		int _la;
5604 		try {
5605 			setState(1159);
5606 			_errHandler.sync(this);
5607 			switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
5608 			case 1:
5609 				enterOuterAlt(_localctx, 1);
5610 				{
5611 				setState(1147);
5612 				match(T__13);
5613 				setState(1148);
5614 				getterKeywordClause();
5615 				setState(1150);
5616 				_la = _input.LA(1);
5617 				if (_la==T__60 || _la==T__96) {
5618 					{
5619 					setState(1149);
5620 					setterKeywordClause();
5621 					}
5622 				}
5623 
5624 				setState(1152);
5625 				match(T__14);
5626 				}
5627 				break;
5628 			case 2:
5629 				enterOuterAlt(_localctx, 2);
5630 				{
5631 				setState(1154);
5632 				match(T__13);
5633 				setState(1155);
5634 				setterKeywordClause();
5635 				setState(1156);
5636 				getterKeywordClause();
5637 				setState(1157);
5638 				match(T__14);
5639 				}
5640 				break;
5641 			}
5642 		}
5643 		catch (RecognitionException re) {
5644 			_localctx.exception = re;
5645 			_errHandler.reportError(this, re);
5646 			_errHandler.recover(this, re);
5647 		}
5648 		finally {
5649 			exitRule();
5650 		}
5651 		return _localctx;
5652 	}
5653 
5654 	public static class GetterKeywordClauseContext extends ParserRuleContext {
5655 		public AttributesContext attributes() {
5656 			return getRuleContext(AttributesContext.class,0);
5657 		}
5658 		public GetterKeywordClauseContext(ParserRuleContext parent, int invokingState) {
5659 			super(parent, invokingState);
5660 		}
5661 		@Override public int getRuleIndex() { return RULE_getterKeywordClause; }
5662 		@Override
5663 		public void enterRule(ParseTreeListener listener) {
5664 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterGetterKeywordClause(this);
5665 		}
5666 		@Override
5667 		public void exitRule(ParseTreeListener listener) {
5668 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitGetterKeywordClause(this);
5669 		}
5670 	}
5671 
5672 	public final GetterKeywordClauseContext getterKeywordClause() throws RecognitionException {
5673 		GetterKeywordClauseContext _localctx = new GetterKeywordClauseContext(_ctx, getState());
5674 		enterRule(_localctx, 164, RULE_getterKeywordClause);
5675 		int _la;
5676 		try {
5677 			enterOuterAlt(_localctx, 1);
5678 			{
5679 			setState(1162);
5680 			_la = _input.LA(1);
5681 			if (_la==T__96) {
5682 				{
5683 				setState(1161);
5684 				attributes();
5685 				}
5686 			}
5687 
5688 			setState(1164);
5689 			match(T__71);
5690 			}
5691 		}
5692 		catch (RecognitionException re) {
5693 			_localctx.exception = re;
5694 			_errHandler.reportError(this, re);
5695 			_errHandler.recover(this, re);
5696 		}
5697 		finally {
5698 			exitRule();
5699 		}
5700 		return _localctx;
5701 	}
5702 
5703 	public static class SetterKeywordClauseContext extends ParserRuleContext {
5704 		public AttributesContext attributes() {
5705 			return getRuleContext(AttributesContext.class,0);
5706 		}
5707 		public SetterKeywordClauseContext(ParserRuleContext parent, int invokingState) {
5708 			super(parent, invokingState);
5709 		}
5710 		@Override public int getRuleIndex() { return RULE_setterKeywordClause; }
5711 		@Override
5712 		public void enterRule(ParseTreeListener listener) {
5713 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSetterKeywordClause(this);
5714 		}
5715 		@Override
5716 		public void exitRule(ParseTreeListener listener) {
5717 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSetterKeywordClause(this);
5718 		}
5719 	}
5720 
5721 	public final SetterKeywordClauseContext setterKeywordClause() throws RecognitionException {
5722 		SetterKeywordClauseContext _localctx = new SetterKeywordClauseContext(_ctx, getState());
5723 		enterRule(_localctx, 166, RULE_setterKeywordClause);
5724 		int _la;
5725 		try {
5726 			enterOuterAlt(_localctx, 1);
5727 			{
5728 			setState(1167);
5729 			_la = _input.LA(1);
5730 			if (_la==T__96) {
5731 				{
5732 				setState(1166);
5733 				attributes();
5734 				}
5735 			}
5736 
5737 			setState(1169);
5738 			match(T__60);
5739 			}
5740 		}
5741 		catch (RecognitionException re) {
5742 			_localctx.exception = re;
5743 			_errHandler.reportError(this, re);
5744 			_errHandler.recover(this, re);
5745 		}
5746 		finally {
5747 			exitRule();
5748 		}
5749 		return _localctx;
5750 	}
5751 
5752 	public static class WillSetDidSetBlockContext extends ParserRuleContext {
5753 		public WillSetClauseContext willSetClause() {
5754 			return getRuleContext(WillSetClauseContext.class,0);
5755 		}
5756 		public DidSetClauseContext didSetClause() {
5757 			return getRuleContext(DidSetClauseContext.class,0);
5758 		}
5759 		public WillSetDidSetBlockContext(ParserRuleContext parent, int invokingState) {
5760 			super(parent, invokingState);
5761 		}
5762 		@Override public int getRuleIndex() { return RULE_willSetDidSetBlock; }
5763 		@Override
5764 		public void enterRule(ParseTreeListener listener) {
5765 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWillSetDidSetBlock(this);
5766 		}
5767 		@Override
5768 		public void exitRule(ParseTreeListener listener) {
5769 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWillSetDidSetBlock(this);
5770 		}
5771 	}
5772 
5773 	public final WillSetDidSetBlockContext willSetDidSetBlock() throws RecognitionException {
5774 		WillSetDidSetBlockContext _localctx = new WillSetDidSetBlockContext(_ctx, getState());
5775 		enterRule(_localctx, 168, RULE_willSetDidSetBlock);
5776 		int _la;
5777 		try {
5778 			setState(1185);
5779 			_errHandler.sync(this);
5780 			switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
5781 			case 1:
5782 				enterOuterAlt(_localctx, 1);
5783 				{
5784 				setState(1171);
5785 				match(T__13);
5786 				setState(1172);
5787 				willSetClause();
5788 				setState(1174);
5789 				_la = _input.LA(1);
5790 				if (_la==T__73 || _la==T__96) {
5791 					{
5792 					setState(1173);
5793 					didSetClause();
5794 					}
5795 				}
5796 
5797 				setState(1176);
5798 				match(T__14);
5799 				}
5800 				break;
5801 			case 2:
5802 				enterOuterAlt(_localctx, 2);
5803 				{
5804 				setState(1178);
5805 				match(T__13);
5806 				setState(1179);
5807 				didSetClause();
5808 				setState(1181);
5809 				_la = _input.LA(1);
5810 				if (_la==T__72 || _la==T__96) {
5811 					{
5812 					setState(1180);
5813 					willSetClause();
5814 					}
5815 				}
5816 
5817 				setState(1183);
5818 				match(T__14);
5819 				}
5820 				break;
5821 			}
5822 		}
5823 		catch (RecognitionException re) {
5824 			_localctx.exception = re;
5825 			_errHandler.reportError(this, re);
5826 			_errHandler.recover(this, re);
5827 		}
5828 		finally {
5829 			exitRule();
5830 		}
5831 		return _localctx;
5832 	}
5833 
5834 	public static class WillSetClauseContext extends ParserRuleContext {
5835 		public CodeBlockContext codeBlock() {
5836 			return getRuleContext(CodeBlockContext.class,0);
5837 		}
5838 		public AttributesContext attributes() {
5839 			return getRuleContext(AttributesContext.class,0);
5840 		}
5841 		public SetterNameContext setterName() {
5842 			return getRuleContext(SetterNameContext.class,0);
5843 		}
5844 		public WillSetClauseContext(ParserRuleContext parent, int invokingState) {
5845 			super(parent, invokingState);
5846 		}
5847 		@Override public int getRuleIndex() { return RULE_willSetClause; }
5848 		@Override
5849 		public void enterRule(ParseTreeListener listener) {
5850 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWillSetClause(this);
5851 		}
5852 		@Override
5853 		public void exitRule(ParseTreeListener listener) {
5854 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWillSetClause(this);
5855 		}
5856 	}
5857 
5858 	public final WillSetClauseContext willSetClause() throws RecognitionException {
5859 		WillSetClauseContext _localctx = new WillSetClauseContext(_ctx, getState());
5860 		enterRule(_localctx, 170, RULE_willSetClause);
5861 		int _la;
5862 		try {
5863 			enterOuterAlt(_localctx, 1);
5864 			{
5865 			setState(1188);
5866 			_la = _input.LA(1);
5867 			if (_la==T__96) {
5868 				{
5869 				setState(1187);
5870 				attributes();
5871 				}
5872 			}
5873 
5874 			setState(1190);
5875 			match(T__72);
5876 			setState(1192);
5877 			_la = _input.LA(1);
5878 			if (_la==T__3) {
5879 				{
5880 				setState(1191);
5881 				setterName();
5882 				}
5883 			}
5884 
5885 			setState(1194);
5886 			codeBlock();
5887 			}
5888 		}
5889 		catch (RecognitionException re) {
5890 			_localctx.exception = re;
5891 			_errHandler.reportError(this, re);
5892 			_errHandler.recover(this, re);
5893 		}
5894 		finally {
5895 			exitRule();
5896 		}
5897 		return _localctx;
5898 	}
5899 
5900 	public static class DidSetClauseContext extends ParserRuleContext {
5901 		public CodeBlockContext codeBlock() {
5902 			return getRuleContext(CodeBlockContext.class,0);
5903 		}
5904 		public AttributesContext attributes() {
5905 			return getRuleContext(AttributesContext.class,0);
5906 		}
5907 		public SetterNameContext setterName() {
5908 			return getRuleContext(SetterNameContext.class,0);
5909 		}
5910 		public DidSetClauseContext(ParserRuleContext parent, int invokingState) {
5911 			super(parent, invokingState);
5912 		}
5913 		@Override public int getRuleIndex() { return RULE_didSetClause; }
5914 		@Override
5915 		public void enterRule(ParseTreeListener listener) {
5916 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDidSetClause(this);
5917 		}
5918 		@Override
5919 		public void exitRule(ParseTreeListener listener) {
5920 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDidSetClause(this);
5921 		}
5922 	}
5923 
5924 	public final DidSetClauseContext didSetClause() throws RecognitionException {
5925 		DidSetClauseContext _localctx = new DidSetClauseContext(_ctx, getState());
5926 		enterRule(_localctx, 172, RULE_didSetClause);
5927 		int _la;
5928 		try {
5929 			enterOuterAlt(_localctx, 1);
5930 			{
5931 			setState(1197);
5932 			_la = _input.LA(1);
5933 			if (_la==T__96) {
5934 				{
5935 				setState(1196);
5936 				attributes();
5937 				}
5938 			}
5939 
5940 			setState(1199);
5941 			match(T__73);
5942 			setState(1201);
5943 			_la = _input.LA(1);
5944 			if (_la==T__3) {
5945 				{
5946 				setState(1200);
5947 				setterName();
5948 				}
5949 			}
5950 
5951 			setState(1203);
5952 			codeBlock();
5953 			}
5954 		}
5955 		catch (RecognitionException re) {
5956 			_localctx.exception = re;
5957 			_errHandler.reportError(this, re);
5958 			_errHandler.recover(this, re);
5959 		}
5960 		finally {
5961 			exitRule();
5962 		}
5963 		return _localctx;
5964 	}
5965 
5966 	public static class TypealiasDeclarationContext extends ParserRuleContext {
5967 		public TypealiasHeadContext typealiasHead() {
5968 			return getRuleContext(TypealiasHeadContext.class,0);
5969 		}
5970 		public TypealiasAssignmentContext typealiasAssignment() {
5971 			return getRuleContext(TypealiasAssignmentContext.class,0);
5972 		}
5973 		public TypealiasDeclarationContext(ParserRuleContext parent, int invokingState) {
5974 			super(parent, invokingState);
5975 		}
5976 		@Override public int getRuleIndex() { return RULE_typealiasDeclaration; }
5977 		@Override
5978 		public void enterRule(ParseTreeListener listener) {
5979 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypealiasDeclaration(this);
5980 		}
5981 		@Override
5982 		public void exitRule(ParseTreeListener listener) {
5983 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypealiasDeclaration(this);
5984 		}
5985 	}
5986 
5987 	public final TypealiasDeclarationContext typealiasDeclaration() throws RecognitionException {
5988 		TypealiasDeclarationContext _localctx = new TypealiasDeclarationContext(_ctx, getState());
5989 		enterRule(_localctx, 174, RULE_typealiasDeclaration);
5990 		try {
5991 			enterOuterAlt(_localctx, 1);
5992 			{
5993 			setState(1205);
5994 			typealiasHead();
5995 			setState(1206);
5996 			typealiasAssignment();
5997 			}
5998 		}
5999 		catch (RecognitionException re) {
6000 			_localctx.exception = re;
6001 			_errHandler.reportError(this, re);
6002 			_errHandler.recover(this, re);
6003 		}
6004 		finally {
6005 			exitRule();
6006 		}
6007 		return _localctx;
6008 	}
6009 
6010 	public static class TypealiasHeadContext extends ParserRuleContext {
6011 		public TypealiasNameContext typealiasName() {
6012 			return getRuleContext(TypealiasNameContext.class,0);
6013 		}
6014 		public AttributesContext attributes() {
6015 			return getRuleContext(AttributesContext.class,0);
6016 		}
6017 		public AccessLevelModifierContext accessLevelModifier() {
6018 			return getRuleContext(AccessLevelModifierContext.class,0);
6019 		}
6020 		public TypealiasHeadContext(ParserRuleContext parent, int invokingState) {
6021 			super(parent, invokingState);
6022 		}
6023 		@Override public int getRuleIndex() { return RULE_typealiasHead; }
6024 		@Override
6025 		public void enterRule(ParseTreeListener listener) {
6026 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypealiasHead(this);
6027 		}
6028 		@Override
6029 		public void exitRule(ParseTreeListener listener) {
6030 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypealiasHead(this);
6031 		}
6032 	}
6033 
6034 	public final TypealiasHeadContext typealiasHead() throws RecognitionException {
6035 		TypealiasHeadContext _localctx = new TypealiasHeadContext(_ctx, getState());
6036 		enterRule(_localctx, 176, RULE_typealiasHead);
6037 		int _la;
6038 		try {
6039 			enterOuterAlt(_localctx, 1);
6040 			{
6041 			setState(1209);
6042 			_la = _input.LA(1);
6043 			if (_la==T__96) {
6044 				{
6045 				setState(1208);
6046 				attributes();
6047 				}
6048 			}
6049 
6050 			setState(1212);
6051 			_la = _input.LA(1);
6052 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
6053 				{
6054 				setState(1211);
6055 				accessLevelModifier();
6056 				}
6057 			}
6058 
6059 			setState(1214);
6060 			match(T__64);
6061 			setState(1215);
6062 			typealiasName();
6063 			}
6064 		}
6065 		catch (RecognitionException re) {
6066 			_localctx.exception = re;
6067 			_errHandler.reportError(this, re);
6068 			_errHandler.recover(this, re);
6069 		}
6070 		finally {
6071 			exitRule();
6072 		}
6073 		return _localctx;
6074 	}
6075 
6076 	public static class TypealiasNameContext extends ParserRuleContext {
6077 		public IdentifierContext identifier() {
6078 			return getRuleContext(IdentifierContext.class,0);
6079 		}
6080 		public TypealiasNameContext(ParserRuleContext parent, int invokingState) {
6081 			super(parent, invokingState);
6082 		}
6083 		@Override public int getRuleIndex() { return RULE_typealiasName; }
6084 		@Override
6085 		public void enterRule(ParseTreeListener listener) {
6086 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypealiasName(this);
6087 		}
6088 		@Override
6089 		public void exitRule(ParseTreeListener listener) {
6090 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypealiasName(this);
6091 		}
6092 	}
6093 
6094 	public final TypealiasNameContext typealiasName() throws RecognitionException {
6095 		TypealiasNameContext _localctx = new TypealiasNameContext(_ctx, getState());
6096 		enterRule(_localctx, 178, RULE_typealiasName);
6097 		try {
6098 			enterOuterAlt(_localctx, 1);
6099 			{
6100 			setState(1217);
6101 			identifier();
6102 			}
6103 		}
6104 		catch (RecognitionException re) {
6105 			_localctx.exception = re;
6106 			_errHandler.reportError(this, re);
6107 			_errHandler.recover(this, re);
6108 		}
6109 		finally {
6110 			exitRule();
6111 		}
6112 		return _localctx;
6113 	}
6114 
6115 	public static class TypealiasAssignmentContext extends ParserRuleContext {
6116 		public STypeContext sType() {
6117 			return getRuleContext(STypeContext.class,0);
6118 		}
6119 		public TypealiasAssignmentContext(ParserRuleContext parent, int invokingState) {
6120 			super(parent, invokingState);
6121 		}
6122 		@Override public int getRuleIndex() { return RULE_typealiasAssignment; }
6123 		@Override
6124 		public void enterRule(ParseTreeListener listener) {
6125 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypealiasAssignment(this);
6126 		}
6127 		@Override
6128 		public void exitRule(ParseTreeListener listener) {
6129 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypealiasAssignment(this);
6130 		}
6131 	}
6132 
6133 	public final TypealiasAssignmentContext typealiasAssignment() throws RecognitionException {
6134 		TypealiasAssignmentContext _localctx = new TypealiasAssignmentContext(_ctx, getState());
6135 		enterRule(_localctx, 180, RULE_typealiasAssignment);
6136 		try {
6137 			enterOuterAlt(_localctx, 1);
6138 			{
6139 			setState(1219);
6140 			match(T__70);
6141 			setState(1220);
6142 			sType(0);
6143 			}
6144 		}
6145 		catch (RecognitionException re) {
6146 			_localctx.exception = re;
6147 			_errHandler.reportError(this, re);
6148 			_errHandler.recover(this, re);
6149 		}
6150 		finally {
6151 			exitRule();
6152 		}
6153 		return _localctx;
6154 	}
6155 
6156 	public static class FunctionDeclarationContext extends ParserRuleContext {
6157 		public FunctionHeadContext functionHead() {
6158 			return getRuleContext(FunctionHeadContext.class,0);
6159 		}
6160 		public FunctionNameContext functionName() {
6161 			return getRuleContext(FunctionNameContext.class,0);
6162 		}
6163 		public FunctionSignatureContext functionSignature() {
6164 			return getRuleContext(FunctionSignatureContext.class,0);
6165 		}
6166 		public FunctionBodyContext functionBody() {
6167 			return getRuleContext(FunctionBodyContext.class,0);
6168 		}
6169 		public GenericParameterClauseContext genericParameterClause() {
6170 			return getRuleContext(GenericParameterClauseContext.class,0);
6171 		}
6172 		public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) {
6173 			super(parent, invokingState);
6174 		}
6175 		@Override public int getRuleIndex() { return RULE_functionDeclaration; }
6176 		@Override
6177 		public void enterRule(ParseTreeListener listener) {
6178 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionDeclaration(this);
6179 		}
6180 		@Override
6181 		public void exitRule(ParseTreeListener listener) {
6182 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionDeclaration(this);
6183 		}
6184 	}
6185 
6186 	public final FunctionDeclarationContext functionDeclaration() throws RecognitionException {
6187 		FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState());
6188 		enterRule(_localctx, 182, RULE_functionDeclaration);
6189 		int _la;
6190 		try {
6191 			setState(1237);
6192 			_errHandler.sync(this);
6193 			switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
6194 			case 1:
6195 				enterOuterAlt(_localctx, 1);
6196 				{
6197 				setState(1222);
6198 				functionHead();
6199 				setState(1223);
6200 				functionName();
6201 				setState(1225);
6202 				_la = _input.LA(1);
6203 				if (_la==T__38) {
6204 					{
6205 					setState(1224);
6206 					genericParameterClause();
6207 					}
6208 				}
6209 
6210 				setState(1227);
6211 				functionSignature();
6212 				setState(1228);
6213 				functionBody();
6214 				}
6215 				break;
6216 			case 2:
6217 				enterOuterAlt(_localctx, 2);
6218 				{
6219 				setState(1230);
6220 				functionHead();
6221 				setState(1231);
6222 				functionName();
6223 				setState(1233);
6224 				_la = _input.LA(1);
6225 				if (_la==T__38) {
6226 					{
6227 					setState(1232);
6228 					genericParameterClause();
6229 					}
6230 				}
6231 
6232 				setState(1235);
6233 				functionSignature();
6234 				}
6235 				break;
6236 			}
6237 		}
6238 		catch (RecognitionException re) {
6239 			_localctx.exception = re;
6240 			_errHandler.reportError(this, re);
6241 			_errHandler.recover(this, re);
6242 		}
6243 		finally {
6244 			exitRule();
6245 		}
6246 		return _localctx;
6247 	}
6248 
6249 	public static class FunctionHeadContext extends ParserRuleContext {
6250 		public AttributesContext attributes() {
6251 			return getRuleContext(AttributesContext.class,0);
6252 		}
6253 		public DeclarationModifiersContext declarationModifiers() {
6254 			return getRuleContext(DeclarationModifiersContext.class,0);
6255 		}
6256 		public FunctionHeadContext(ParserRuleContext parent, int invokingState) {
6257 			super(parent, invokingState);
6258 		}
6259 		@Override public int getRuleIndex() { return RULE_functionHead; }
6260 		@Override
6261 		public void enterRule(ParseTreeListener listener) {
6262 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionHead(this);
6263 		}
6264 		@Override
6265 		public void exitRule(ParseTreeListener listener) {
6266 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionHead(this);
6267 		}
6268 	}
6269 
6270 	public final FunctionHeadContext functionHead() throws RecognitionException {
6271 		FunctionHeadContext _localctx = new FunctionHeadContext(_ctx, getState());
6272 		enterRule(_localctx, 184, RULE_functionHead);
6273 		int _la;
6274 		try {
6275 			enterOuterAlt(_localctx, 1);
6276 			{
6277 			setState(1240);
6278 			_la = _input.LA(1);
6279 			if (_la==T__96) {
6280 				{
6281 				setState(1239);
6282 				attributes();
6283 				}
6284 			}
6285 
6286 			setState(1243);
6287 			_la = _input.LA(1);
6288 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
6289 				{
6290 				setState(1242);
6291 				declarationModifiers();
6292 				}
6293 			}
6294 
6295 			setState(1245);
6296 			match(T__68);
6297 			}
6298 		}
6299 		catch (RecognitionException re) {
6300 			_localctx.exception = re;
6301 			_errHandler.reportError(this, re);
6302 			_errHandler.recover(this, re);
6303 		}
6304 		finally {
6305 			exitRule();
6306 		}
6307 		return _localctx;
6308 	}
6309 
6310 	public static class FunctionNameContext extends ParserRuleContext {
6311 		public IdentifierContext identifier() {
6312 			return getRuleContext(IdentifierContext.class,0);
6313 		}
6314 		public OperatorContext operator() {
6315 			return getRuleContext(OperatorContext.class,0);
6316 		}
6317 		public FunctionNameContext(ParserRuleContext parent, int invokingState) {
6318 			super(parent, invokingState);
6319 		}
6320 		@Override public int getRuleIndex() { return RULE_functionName; }
6321 		@Override
6322 		public void enterRule(ParseTreeListener listener) {
6323 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionName(this);
6324 		}
6325 		@Override
6326 		public void exitRule(ParseTreeListener listener) {
6327 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionName(this);
6328 		}
6329 	}
6330 
6331 	public final FunctionNameContext functionName() throws RecognitionException {
6332 		FunctionNameContext _localctx = new FunctionNameContext(_ctx, getState());
6333 		enterRule(_localctx, 186, RULE_functionName);
6334 		try {
6335 			setState(1249);
6336 			switch (_input.LA(1)) {
6337 			case T__30:
6338 			case T__31:
6339 			case T__32:
6340 			case T__34:
6341 			case T__42:
6342 			case T__43:
6343 			case T__44:
6344 			case T__45:
6345 			case T__46:
6346 			case T__47:
6347 			case T__48:
6348 			case T__49:
6349 			case T__50:
6350 			case T__51:
6351 			case T__52:
6352 			case T__53:
6353 			case T__55:
6354 			case T__58:
6355 			case T__60:
6356 			case T__71:
6357 			case T__72:
6358 			case T__73:
6359 			case T__81:
6360 			case T__88:
6361 			case T__89:
6362 			case T__90:
6363 			case T__91:
6364 			case T__92:
6365 			case T__93:
6366 			case T__116:
6367 			case T__117:
6368 			case T__123:
6369 			case T__124:
6370 			case T__125:
6371 			case T__126:
6372 			case T__127:
6373 			case T__128:
6374 			case T__130:
6375 			case Identifier:
6376 				enterOuterAlt(_localctx, 1);
6377 				{
6378 				setState(1247);
6379 				identifier();
6380 				}
6381 				break;
6382 			case T__29:
6383 			case T__38:
6384 			case T__39:
6385 			case T__40:
6386 			case T__70:
6387 			case T__77:
6388 			case T__83:
6389 			case T__84:
6390 			case T__99:
6391 			case T__101:
6392 			case T__103:
6393 			case T__114:
6394 			case T__115:
6395 			case OperatorHead:
6396 			case DotOperatorHead:
6397 				enterOuterAlt(_localctx, 2);
6398 				{
6399 				setState(1248);
6400 				operator();
6401 				}
6402 				break;
6403 			default:
6404 				throw new NoViableAltException(this);
6405 			}
6406 		}
6407 		catch (RecognitionException re) {
6408 			_localctx.exception = re;
6409 			_errHandler.reportError(this, re);
6410 			_errHandler.recover(this, re);
6411 		}
6412 		finally {
6413 			exitRule();
6414 		}
6415 		return _localctx;
6416 	}
6417 
6418 	public static class FunctionSignatureContext extends ParserRuleContext {
6419 		public ParameterClausesContext parameterClauses() {
6420 			return getRuleContext(ParameterClausesContext.class,0);
6421 		}
6422 		public FunctionResultContext functionResult() {
6423 			return getRuleContext(FunctionResultContext.class,0);
6424 		}
6425 		public FunctionSignatureContext(ParserRuleContext parent, int invokingState) {
6426 			super(parent, invokingState);
6427 		}
6428 		@Override public int getRuleIndex() { return RULE_functionSignature; }
6429 		@Override
6430 		public void enterRule(ParseTreeListener listener) {
6431 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionSignature(this);
6432 		}
6433 		@Override
6434 		public void exitRule(ParseTreeListener listener) {
6435 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionSignature(this);
6436 		}
6437 	}
6438 
6439 	public final FunctionSignatureContext functionSignature() throws RecognitionException {
6440 		FunctionSignatureContext _localctx = new FunctionSignatureContext(_ctx, getState());
6441 		enterRule(_localctx, 188, RULE_functionSignature);
6442 		int _la;
6443 		try {
6444 			enterOuterAlt(_localctx, 1);
6445 			{
6446 			setState(1251);
6447 			parameterClauses();
6448 			setState(1253);
6449 			_la = _input.LA(1);
6450 			if (_la==T__74 || _la==T__75) {
6451 				{
6452 				setState(1252);
6453 				_la = _input.LA(1);
6454 				if ( !(_la==T__74 || _la==T__75) ) {
6455 				_errHandler.recoverInline(this);
6456 				} else {
6457 					consume();
6458 				}
6459 				}
6460 			}
6461 
6462 			setState(1256);
6463 			_la = _input.LA(1);
6464 			if (_la==T__76) {
6465 				{
6466 				setState(1255);
6467 				functionResult();
6468 				}
6469 			}
6470 
6471 			}
6472 		}
6473 		catch (RecognitionException re) {
6474 			_localctx.exception = re;
6475 			_errHandler.reportError(this, re);
6476 			_errHandler.recover(this, re);
6477 		}
6478 		finally {
6479 			exitRule();
6480 		}
6481 		return _localctx;
6482 	}
6483 
6484 	public static class FunctionResultContext extends ParserRuleContext {
6485 		public STypeContext sType() {
6486 			return getRuleContext(STypeContext.class,0);
6487 		}
6488 		public AttributesContext attributes() {
6489 			return getRuleContext(AttributesContext.class,0);
6490 		}
6491 		public FunctionResultContext(ParserRuleContext parent, int invokingState) {
6492 			super(parent, invokingState);
6493 		}
6494 		@Override public int getRuleIndex() { return RULE_functionResult; }
6495 		@Override
6496 		public void enterRule(ParseTreeListener listener) {
6497 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionResult(this);
6498 		}
6499 		@Override
6500 		public void exitRule(ParseTreeListener listener) {
6501 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionResult(this);
6502 		}
6503 	}
6504 
6505 	public final FunctionResultContext functionResult() throws RecognitionException {
6506 		FunctionResultContext _localctx = new FunctionResultContext(_ctx, getState());
6507 		enterRule(_localctx, 190, RULE_functionResult);
6508 		int _la;
6509 		try {
6510 			enterOuterAlt(_localctx, 1);
6511 			{
6512 			setState(1258);
6513 			match(T__76);
6514 			setState(1260);
6515 			_la = _input.LA(1);
6516 			if (_la==T__96) {
6517 				{
6518 				setState(1259);
6519 				attributes();
6520 				}
6521 			}
6522 
6523 			setState(1262);
6524 			sType(0);
6525 			}
6526 		}
6527 		catch (RecognitionException re) {
6528 			_localctx.exception = re;
6529 			_errHandler.reportError(this, re);
6530 			_errHandler.recover(this, re);
6531 		}
6532 		finally {
6533 			exitRule();
6534 		}
6535 		return _localctx;
6536 	}
6537 
6538 	public static class FunctionBodyContext extends ParserRuleContext {
6539 		public CodeBlockContext codeBlock() {
6540 			return getRuleContext(CodeBlockContext.class,0);
6541 		}
6542 		public FunctionBodyContext(ParserRuleContext parent, int invokingState) {
6543 			super(parent, invokingState);
6544 		}
6545 		@Override public int getRuleIndex() { return RULE_functionBody; }
6546 		@Override
6547 		public void enterRule(ParseTreeListener listener) {
6548 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionBody(this);
6549 		}
6550 		@Override
6551 		public void exitRule(ParseTreeListener listener) {
6552 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionBody(this);
6553 		}
6554 	}
6555 
6556 	public final FunctionBodyContext functionBody() throws RecognitionException {
6557 		FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState());
6558 		enterRule(_localctx, 192, RULE_functionBody);
6559 		try {
6560 			enterOuterAlt(_localctx, 1);
6561 			{
6562 			setState(1264);
6563 			codeBlock();
6564 			}
6565 		}
6566 		catch (RecognitionException re) {
6567 			_localctx.exception = re;
6568 			_errHandler.reportError(this, re);
6569 			_errHandler.recover(this, re);
6570 		}
6571 		finally {
6572 			exitRule();
6573 		}
6574 		return _localctx;
6575 	}
6576 
6577 	public static class ParameterClausesContext extends ParserRuleContext {
6578 		public ParameterClauseContext parameterClause() {
6579 			return getRuleContext(ParameterClauseContext.class,0);
6580 		}
6581 		public ParameterClausesContext parameterClauses() {
6582 			return getRuleContext(ParameterClausesContext.class,0);
6583 		}
6584 		public ParameterClausesContext(ParserRuleContext parent, int invokingState) {
6585 			super(parent, invokingState);
6586 		}
6587 		@Override public int getRuleIndex() { return RULE_parameterClauses; }
6588 		@Override
6589 		public void enterRule(ParseTreeListener listener) {
6590 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterParameterClauses(this);
6591 		}
6592 		@Override
6593 		public void exitRule(ParseTreeListener listener) {
6594 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitParameterClauses(this);
6595 		}
6596 	}
6597 
6598 	public final ParameterClausesContext parameterClauses() throws RecognitionException {
6599 		ParameterClausesContext _localctx = new ParameterClausesContext(_ctx, getState());
6600 		enterRule(_localctx, 194, RULE_parameterClauses);
6601 		try {
6602 			enterOuterAlt(_localctx, 1);
6603 			{
6604 			setState(1266);
6605 			parameterClause();
6606 			setState(1268);
6607 			_errHandler.sync(this);
6608 			switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
6609 			case 1:
6610 				{
6611 				setState(1267);
6612 				parameterClauses();
6613 				}
6614 				break;
6615 			}
6616 			}
6617 		}
6618 		catch (RecognitionException re) {
6619 			_localctx.exception = re;
6620 			_errHandler.reportError(this, re);
6621 			_errHandler.recover(this, re);
6622 		}
6623 		finally {
6624 			exitRule();
6625 		}
6626 		return _localctx;
6627 	}
6628 
6629 	public static class ParameterClauseContext extends ParserRuleContext {
6630 		public ParameterListContext parameterList() {
6631 			return getRuleContext(ParameterListContext.class,0);
6632 		}
6633 		public ParameterClauseContext(ParserRuleContext parent, int invokingState) {
6634 			super(parent, invokingState);
6635 		}
6636 		@Override public int getRuleIndex() { return RULE_parameterClause; }
6637 		@Override
6638 		public void enterRule(ParseTreeListener listener) {
6639 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterParameterClause(this);
6640 		}
6641 		@Override
6642 		public void exitRule(ParseTreeListener listener) {
6643 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitParameterClause(this);
6644 		}
6645 	}
6646 
6647 	public final ParameterClauseContext parameterClause() throws RecognitionException {
6648 		ParameterClauseContext _localctx = new ParameterClauseContext(_ctx, getState());
6649 		enterRule(_localctx, 196, RULE_parameterClause);
6650 		int _la;
6651 		try {
6652 			setState(1279);
6653 			_errHandler.sync(this);
6654 			switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
6655 			case 1:
6656 				enterOuterAlt(_localctx, 1);
6657 				{
6658 				setState(1270);
6659 				match(T__3);
6660 				setState(1271);
6661 				match(T__4);
6662 				}
6663 				break;
6664 			case 2:
6665 				enterOuterAlt(_localctx, 2);
6666 				{
6667 				setState(1272);
6668 				match(T__3);
6669 				setState(1273);
6670 				parameterList();
6671 				setState(1275);
6672 				_la = _input.LA(1);
6673 				if (_la==T__77) {
6674 					{
6675 					setState(1274);
6676 					match(T__77);
6677 					}
6678 				}
6679 
6680 				setState(1277);
6681 				match(T__4);
6682 				}
6683 				break;
6684 			}
6685 		}
6686 		catch (RecognitionException re) {
6687 			_localctx.exception = re;
6688 			_errHandler.reportError(this, re);
6689 			_errHandler.recover(this, re);
6690 		}
6691 		finally {
6692 			exitRule();
6693 		}
6694 		return _localctx;
6695 	}
6696 
6697 	public static class ParameterListContext extends ParserRuleContext {
6698 		public List<ParameterContext> parameter() {
6699 			return getRuleContexts(ParameterContext.class);
6700 		}
6701 		public ParameterContext parameter(int i) {
6702 			return getRuleContext(ParameterContext.class,i);
6703 		}
6704 		public ParameterListContext(ParserRuleContext parent, int invokingState) {
6705 			super(parent, invokingState);
6706 		}
6707 		@Override public int getRuleIndex() { return RULE_parameterList; }
6708 		@Override
6709 		public void enterRule(ParseTreeListener listener) {
6710 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterParameterList(this);
6711 		}
6712 		@Override
6713 		public void exitRule(ParseTreeListener listener) {
6714 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitParameterList(this);
6715 		}
6716 	}
6717 
6718 	public final ParameterListContext parameterList() throws RecognitionException {
6719 		ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
6720 		enterRule(_localctx, 198, RULE_parameterList);
6721 		int _la;
6722 		try {
6723 			enterOuterAlt(_localctx, 1);
6724 			{
6725 			setState(1281);
6726 			parameter();
6727 			setState(1286);
6728 			_errHandler.sync(this);
6729 			_la = _input.LA(1);
6730 			while (_la==T__15) {
6731 				{
6732 				{
6733 				setState(1282);
6734 				match(T__15);
6735 				setState(1283);
6736 				parameter();
6737 				}
6738 				}
6739 				setState(1288);
6740 				_errHandler.sync(this);
6741 				_la = _input.LA(1);
6742 			}
6743 			}
6744 		}
6745 		catch (RecognitionException re) {
6746 			_localctx.exception = re;
6747 			_errHandler.reportError(this, re);
6748 			_errHandler.recover(this, re);
6749 		}
6750 		finally {
6751 			exitRule();
6752 		}
6753 		return _localctx;
6754 	}
6755 
6756 	public static class ParameterContext extends ParserRuleContext {
6757 		public LocalParameterNameContext localParameterName() {
6758 			return getRuleContext(LocalParameterNameContext.class,0);
6759 		}
6760 		public AttributesContext attributes() {
6761 			return getRuleContext(AttributesContext.class,0);
6762 		}
6763 		public ExternalParameterNameContext externalParameterName() {
6764 			return getRuleContext(ExternalParameterNameContext.class,0);
6765 		}
6766 		public TypeAnnotationContext typeAnnotation() {
6767 			return getRuleContext(TypeAnnotationContext.class,0);
6768 		}
6769 		public DefaultArgumentClauseContext defaultArgumentClause() {
6770 			return getRuleContext(DefaultArgumentClauseContext.class,0);
6771 		}
6772 		public STypeContext sType() {
6773 			return getRuleContext(STypeContext.class,0);
6774 		}
6775 		public ParameterContext(ParserRuleContext parent, int invokingState) {
6776 			super(parent, invokingState);
6777 		}
6778 		@Override public int getRuleIndex() { return RULE_parameter; }
6779 		@Override
6780 		public void enterRule(ParseTreeListener listener) {
6781 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterParameter(this);
6782 		}
6783 		@Override
6784 		public void exitRule(ParseTreeListener listener) {
6785 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitParameter(this);
6786 		}
6787 	}
6788 
6789 	public final ParameterContext parameter() throws RecognitionException {
6790 		ParameterContext _localctx = new ParameterContext(_ctx, getState());
6791 		enterRule(_localctx, 200, RULE_parameter);
6792 		int _la;
6793 		try {
6794 			setState(1339);
6795 			_errHandler.sync(this);
6796 			switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
6797 			case 1:
6798 				enterOuterAlt(_localctx, 1);
6799 				{
6800 				setState(1290);
6801 				_la = _input.LA(1);
6802 				if (_la==T__96) {
6803 					{
6804 					setState(1289);
6805 					attributes();
6806 					}
6807 				}
6808 
6809 				setState(1293);
6810 				_la = _input.LA(1);
6811 				if (_la==T__78) {
6812 					{
6813 					setState(1292);
6814 					match(T__78);
6815 					}
6816 				}
6817 
6818 				setState(1296);
6819 				_la = _input.LA(1);
6820 				if (_la==T__25) {
6821 					{
6822 					setState(1295);
6823 					match(T__25);
6824 					}
6825 				}
6826 
6827 				setState(1299);
6828 				_la = _input.LA(1);
6829 				if (_la==T__79) {
6830 					{
6831 					setState(1298);
6832 					match(T__79);
6833 					}
6834 				}
6835 
6836 				setState(1302);
6837 				_errHandler.sync(this);
6838 				switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
6839 				case 1:
6840 					{
6841 					setState(1301);
6842 					externalParameterName();
6843 					}
6844 					break;
6845 				}
6846 				setState(1304);
6847 				localParameterName();
6848 				setState(1306);
6849 				_la = _input.LA(1);
6850 				if (_la==T__1) {
6851 					{
6852 					setState(1305);
6853 					typeAnnotation();
6854 					}
6855 				}
6856 
6857 				setState(1309);
6858 				_la = _input.LA(1);
6859 				if (_la==T__70) {
6860 					{
6861 					setState(1308);
6862 					defaultArgumentClause();
6863 					}
6864 				}
6865 
6866 				}
6867 				break;
6868 			case 2:
6869 				enterOuterAlt(_localctx, 2);
6870 				{
6871 				setState(1312);
6872 				_la = _input.LA(1);
6873 				if (_la==T__78) {
6874 					{
6875 					setState(1311);
6876 					match(T__78);
6877 					}
6878 				}
6879 
6880 				setState(1314);
6881 				match(T__26);
6882 				setState(1316);
6883 				_la = _input.LA(1);
6884 				if (_la==T__79) {
6885 					{
6886 					setState(1315);
6887 					match(T__79);
6888 					}
6889 				}
6890 
6891 				setState(1319);
6892 				_errHandler.sync(this);
6893 				switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
6894 				case 1:
6895 					{
6896 					setState(1318);
6897 					externalParameterName();
6898 					}
6899 					break;
6900 				}
6901 				setState(1321);
6902 				localParameterName();
6903 				setState(1323);
6904 				_la = _input.LA(1);
6905 				if (_la==T__1) {
6906 					{
6907 					setState(1322);
6908 					typeAnnotation();
6909 					}
6910 				}
6911 
6912 				setState(1326);
6913 				_la = _input.LA(1);
6914 				if (_la==T__70) {
6915 					{
6916 					setState(1325);
6917 					defaultArgumentClause();
6918 					}
6919 				}
6920 
6921 				}
6922 				break;
6923 			case 3:
6924 				enterOuterAlt(_localctx, 3);
6925 				{
6926 				setState(1329);
6927 				_la = _input.LA(1);
6928 				if (_la==T__96) {
6929 					{
6930 					setState(1328);
6931 					attributes();
6932 					}
6933 				}
6934 
6935 				setState(1331);
6936 				sType(0);
6937 				}
6938 				break;
6939 			case 4:
6940 				enterOuterAlt(_localctx, 4);
6941 				{
6942 				setState(1333);
6943 				_errHandler.sync(this);
6944 				switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
6945 				case 1:
6946 					{
6947 					setState(1332);
6948 					externalParameterName();
6949 					}
6950 					break;
6951 				}
6952 				setState(1335);
6953 				localParameterName();
6954 				setState(1336);
6955 				typeAnnotation();
6956 				setState(1337);
6957 				match(T__77);
6958 				}
6959 				break;
6960 			}
6961 		}
6962 		catch (RecognitionException re) {
6963 			_localctx.exception = re;
6964 			_errHandler.reportError(this, re);
6965 			_errHandler.recover(this, re);
6966 		}
6967 		finally {
6968 			exitRule();
6969 		}
6970 		return _localctx;
6971 	}
6972 
6973 	public static class ExternalParameterNameContext extends ParserRuleContext {
6974 		public IdentifierContext identifier() {
6975 			return getRuleContext(IdentifierContext.class,0);
6976 		}
6977 		public ExternalParameterNameContext(ParserRuleContext parent, int invokingState) {
6978 			super(parent, invokingState);
6979 		}
6980 		@Override public int getRuleIndex() { return RULE_externalParameterName; }
6981 		@Override
6982 		public void enterRule(ParseTreeListener listener) {
6983 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExternalParameterName(this);
6984 		}
6985 		@Override
6986 		public void exitRule(ParseTreeListener listener) {
6987 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExternalParameterName(this);
6988 		}
6989 	}
6990 
6991 	public final ExternalParameterNameContext externalParameterName() throws RecognitionException {
6992 		ExternalParameterNameContext _localctx = new ExternalParameterNameContext(_ctx, getState());
6993 		enterRule(_localctx, 202, RULE_externalParameterName);
6994 		try {
6995 			setState(1343);
6996 			switch (_input.LA(1)) {
6997 			case T__30:
6998 			case T__31:
6999 			case T__32:
7000 			case T__34:
7001 			case T__42:
7002 			case T__43:
7003 			case T__44:
7004 			case T__45:
7005 			case T__46:
7006 			case T__47:
7007 			case T__48:
7008 			case T__49:
7009 			case T__50:
7010 			case T__51:
7011 			case T__52:
7012 			case T__53:
7013 			case T__55:
7014 			case T__58:
7015 			case T__60:
7016 			case T__71:
7017 			case T__72:
7018 			case T__73:
7019 			case T__81:
7020 			case T__88:
7021 			case T__89:
7022 			case T__90:
7023 			case T__91:
7024 			case T__92:
7025 			case T__93:
7026 			case T__116:
7027 			case T__117:
7028 			case T__123:
7029 			case T__124:
7030 			case T__125:
7031 			case T__126:
7032 			case T__127:
7033 			case T__128:
7034 			case T__130:
7035 			case Identifier:
7036 				enterOuterAlt(_localctx, 1);
7037 				{
7038 				setState(1341);
7039 				identifier();
7040 				}
7041 				break;
7042 			case T__80:
7043 				enterOuterAlt(_localctx, 2);
7044 				{
7045 				setState(1342);
7046 				match(T__80);
7047 				}
7048 				break;
7049 			default:
7050 				throw new NoViableAltException(this);
7051 			}
7052 		}
7053 		catch (RecognitionException re) {
7054 			_localctx.exception = re;
7055 			_errHandler.reportError(this, re);
7056 			_errHandler.recover(this, re);
7057 		}
7058 		finally {
7059 			exitRule();
7060 		}
7061 		return _localctx;
7062 	}
7063 
7064 	public static class LocalParameterNameContext extends ParserRuleContext {
7065 		public IdentifierContext identifier() {
7066 			return getRuleContext(IdentifierContext.class,0);
7067 		}
7068 		public LocalParameterNameContext(ParserRuleContext parent, int invokingState) {
7069 			super(parent, invokingState);
7070 		}
7071 		@Override public int getRuleIndex() { return RULE_localParameterName; }
7072 		@Override
7073 		public void enterRule(ParseTreeListener listener) {
7074 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLocalParameterName(this);
7075 		}
7076 		@Override
7077 		public void exitRule(ParseTreeListener listener) {
7078 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLocalParameterName(this);
7079 		}
7080 	}
7081 
7082 	public final LocalParameterNameContext localParameterName() throws RecognitionException {
7083 		LocalParameterNameContext _localctx = new LocalParameterNameContext(_ctx, getState());
7084 		enterRule(_localctx, 204, RULE_localParameterName);
7085 		try {
7086 			setState(1347);
7087 			switch (_input.LA(1)) {
7088 			case T__30:
7089 			case T__31:
7090 			case T__32:
7091 			case T__34:
7092 			case T__42:
7093 			case T__43:
7094 			case T__44:
7095 			case T__45:
7096 			case T__46:
7097 			case T__47:
7098 			case T__48:
7099 			case T__49:
7100 			case T__50:
7101 			case T__51:
7102 			case T__52:
7103 			case T__53:
7104 			case T__55:
7105 			case T__58:
7106 			case T__60:
7107 			case T__71:
7108 			case T__72:
7109 			case T__73:
7110 			case T__81:
7111 			case T__88:
7112 			case T__89:
7113 			case T__90:
7114 			case T__91:
7115 			case T__92:
7116 			case T__93:
7117 			case T__116:
7118 			case T__117:
7119 			case T__123:
7120 			case T__124:
7121 			case T__125:
7122 			case T__126:
7123 			case T__127:
7124 			case T__128:
7125 			case T__130:
7126 			case Identifier:
7127 				enterOuterAlt(_localctx, 1);
7128 				{
7129 				setState(1345);
7130 				identifier();
7131 				}
7132 				break;
7133 			case T__80:
7134 				enterOuterAlt(_localctx, 2);
7135 				{
7136 				setState(1346);
7137 				match(T__80);
7138 				}
7139 				break;
7140 			default:
7141 				throw new NoViableAltException(this);
7142 			}
7143 		}
7144 		catch (RecognitionException re) {
7145 			_localctx.exception = re;
7146 			_errHandler.reportError(this, re);
7147 			_errHandler.recover(this, re);
7148 		}
7149 		finally {
7150 			exitRule();
7151 		}
7152 		return _localctx;
7153 	}
7154 
7155 	public static class DefaultArgumentClauseContext extends ParserRuleContext {
7156 		public ExpressionContext expression() {
7157 			return getRuleContext(ExpressionContext.class,0);
7158 		}
7159 		public DefaultArgumentClauseContext(ParserRuleContext parent, int invokingState) {
7160 			super(parent, invokingState);
7161 		}
7162 		@Override public int getRuleIndex() { return RULE_defaultArgumentClause; }
7163 		@Override
7164 		public void enterRule(ParseTreeListener listener) {
7165 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDefaultArgumentClause(this);
7166 		}
7167 		@Override
7168 		public void exitRule(ParseTreeListener listener) {
7169 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDefaultArgumentClause(this);
7170 		}
7171 	}
7172 
7173 	public final DefaultArgumentClauseContext defaultArgumentClause() throws RecognitionException {
7174 		DefaultArgumentClauseContext _localctx = new DefaultArgumentClauseContext(_ctx, getState());
7175 		enterRule(_localctx, 206, RULE_defaultArgumentClause);
7176 		try {
7177 			enterOuterAlt(_localctx, 1);
7178 			{
7179 			setState(1349);
7180 			match(T__70);
7181 			setState(1350);
7182 			expression();
7183 			}
7184 		}
7185 		catch (RecognitionException re) {
7186 			_localctx.exception = re;
7187 			_errHandler.reportError(this, re);
7188 			_errHandler.recover(this, re);
7189 		}
7190 		finally {
7191 			exitRule();
7192 		}
7193 		return _localctx;
7194 	}
7195 
7196 	public static class EnumDeclarationContext extends ParserRuleContext {
7197 		public EnumDefContext enumDef() {
7198 			return getRuleContext(EnumDefContext.class,0);
7199 		}
7200 		public AttributesContext attributes() {
7201 			return getRuleContext(AttributesContext.class,0);
7202 		}
7203 		public AccessLevelModifierContext accessLevelModifier() {
7204 			return getRuleContext(AccessLevelModifierContext.class,0);
7205 		}
7206 		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
7207 			super(parent, invokingState);
7208 		}
7209 		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
7210 		@Override
7211 		public void enterRule(ParseTreeListener listener) {
7212 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterEnumDeclaration(this);
7213 		}
7214 		@Override
7215 		public void exitRule(ParseTreeListener listener) {
7216 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitEnumDeclaration(this);
7217 		}
7218 	}
7219 
7220 	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
7221 		EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
7222 		enterRule(_localctx, 208, RULE_enumDeclaration);
7223 		int _la;
7224 		try {
7225 			enterOuterAlt(_localctx, 1);
7226 			{
7227 			setState(1353);
7228 			_la = _input.LA(1);
7229 			if (_la==T__96) {
7230 				{
7231 				setState(1352);
7232 				attributes();
7233 				}
7234 			}
7235 
7236 			setState(1356);
7237 			_la = _input.LA(1);
7238 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
7239 				{
7240 				setState(1355);
7241 				accessLevelModifier();
7242 				}
7243 			}
7244 
7245 			setState(1358);
7246 			enumDef();
7247 			}
7248 		}
7249 		catch (RecognitionException re) {
7250 			_localctx.exception = re;
7251 			_errHandler.reportError(this, re);
7252 			_errHandler.recover(this, re);
7253 		}
7254 		finally {
7255 			exitRule();
7256 		}
7257 		return _localctx;
7258 	}
7259 
7260 	public static class EnumDefContext extends ParserRuleContext {
7261 		public UnionStyleEnumContext unionStyleEnum() {
7262 			return getRuleContext(UnionStyleEnumContext.class,0);
7263 		}
7264 		public RawValueStyleEnumContext rawValueStyleEnum() {
7265 			return getRuleContext(RawValueStyleEnumContext.class,0);
7266 		}
7267 		public EnumDefContext(ParserRuleContext parent, int invokingState) {
7268 			super(parent, invokingState);
7269 		}
7270 		@Override public int getRuleIndex() { return RULE_enumDef; }
7271 		@Override
7272 		public void enterRule(ParseTreeListener listener) {
7273 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterEnumDef(this);
7274 		}
7275 		@Override
7276 		public void exitRule(ParseTreeListener listener) {
7277 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitEnumDef(this);
7278 		}
7279 	}
7280 
7281 	public final EnumDefContext enumDef() throws RecognitionException {
7282 		EnumDefContext _localctx = new EnumDefContext(_ctx, getState());
7283 		enterRule(_localctx, 210, RULE_enumDef);
7284 		try {
7285 			setState(1362);
7286 			_errHandler.sync(this);
7287 			switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
7288 			case 1:
7289 				enterOuterAlt(_localctx, 1);
7290 				{
7291 				setState(1360);
7292 				unionStyleEnum();
7293 				}
7294 				break;
7295 			case 2:
7296 				enterOuterAlt(_localctx, 2);
7297 				{
7298 				setState(1361);
7299 				rawValueStyleEnum();
7300 				}
7301 				break;
7302 			}
7303 		}
7304 		catch (RecognitionException re) {
7305 			_localctx.exception = re;
7306 			_errHandler.reportError(this, re);
7307 			_errHandler.recover(this, re);
7308 		}
7309 		finally {
7310 			exitRule();
7311 		}
7312 		return _localctx;
7313 	}
7314 
7315 	public static class UnionStyleEnumContext extends ParserRuleContext {
7316 		public EnumNameContext enumName() {
7317 			return getRuleContext(EnumNameContext.class,0);
7318 		}
7319 		public GenericParameterClauseContext genericParameterClause() {
7320 			return getRuleContext(GenericParameterClauseContext.class,0);
7321 		}
7322 		public TypeInheritanceClauseContext typeInheritanceClause() {
7323 			return getRuleContext(TypeInheritanceClauseContext.class,0);
7324 		}
7325 		public UnionStyleEnumMembersContext unionStyleEnumMembers() {
7326 			return getRuleContext(UnionStyleEnumMembersContext.class,0);
7327 		}
7328 		public UnionStyleEnumContext(ParserRuleContext parent, int invokingState) {
7329 			super(parent, invokingState);
7330 		}
7331 		@Override public int getRuleIndex() { return RULE_unionStyleEnum; }
7332 		@Override
7333 		public void enterRule(ParseTreeListener listener) {
7334 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterUnionStyleEnum(this);
7335 		}
7336 		@Override
7337 		public void exitRule(ParseTreeListener listener) {
7338 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitUnionStyleEnum(this);
7339 		}
7340 	}
7341 
7342 	public final UnionStyleEnumContext unionStyleEnum() throws RecognitionException {
7343 		UnionStyleEnumContext _localctx = new UnionStyleEnumContext(_ctx, getState());
7344 		enterRule(_localctx, 212, RULE_unionStyleEnum);
7345 		int _la;
7346 		try {
7347 			enterOuterAlt(_localctx, 1);
7348 			{
7349 			setState(1365);
7350 			_la = _input.LA(1);
7351 			if (_la==T__81) {
7352 				{
7353 				setState(1364);
7354 				match(T__81);
7355 				}
7356 			}
7357 
7358 			setState(1367);
7359 			match(T__66);
7360 			setState(1368);
7361 			enumName();
7362 			setState(1370);
7363 			_la = _input.LA(1);
7364 			if (_la==T__38) {
7365 				{
7366 				setState(1369);
7367 				genericParameterClause();
7368 				}
7369 			}
7370 
7371 			setState(1373);
7372 			_la = _input.LA(1);
7373 			if (_la==T__1) {
7374 				{
7375 				setState(1372);
7376 				typeInheritanceClause();
7377 				}
7378 			}
7379 
7380 			setState(1375);
7381 			match(T__13);
7382 			setState(1377);
7383 			_la = _input.LA(1);
7384 			if (((((_la - 6)) & ~0x3f) == 0 && ((1L << (_la - 6)) & ((1L << (T__5 - 6)) | (1L << (T__25 - 6)) | (1L << (T__26 - 6)) | (1L << (T__41 - 6)) | (1L << (T__42 - 6)) | (1L << (T__43 - 6)) | (1L << (T__44 - 6)) | (1L << (T__45 - 6)) | (1L << (T__46 - 6)) | (1L << (T__47 - 6)) | (1L << (T__48 - 6)) | (1L << (T__49 - 6)) | (1L << (T__50 - 6)) | (1L << (T__51 - 6)) | (1L << (T__52 - 6)) | (1L << (T__53 - 6)) | (1L << (T__54 - 6)) | (1L << (T__55 - 6)) | (1L << (T__58 - 6)) | (1L << (T__59 - 6)) | (1L << (T__61 - 6)) | (1L << (T__62 - 6)) | (1L << (T__63 - 6)) | (1L << (T__64 - 6)) | (1L << (T__65 - 6)) | (1L << (T__66 - 6)) | (1L << (T__67 - 6)) | (1L << (T__68 - 6)))) != 0) || ((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & ((1L << (T__81 - 82)) | (1L << (T__82 - 82)) | (1L << (T__85 - 82)) | (1L << (T__86 - 82)) | (1L << (T__87 - 82)) | (1L << (T__96 - 82)) | (1L << (T__119 - 82)) | (1L << (T__129 - 82)))) != 0)) {
7385 				{
7386 				setState(1376);
7387 				unionStyleEnumMembers();
7388 				}
7389 			}
7390 
7391 			setState(1379);
7392 			match(T__14);
7393 			}
7394 		}
7395 		catch (RecognitionException re) {
7396 			_localctx.exception = re;
7397 			_errHandler.reportError(this, re);
7398 			_errHandler.recover(this, re);
7399 		}
7400 		finally {
7401 			exitRule();
7402 		}
7403 		return _localctx;
7404 	}
7405 
7406 	public static class UnionStyleEnumMembersContext extends ParserRuleContext {
7407 		public UnionStyleEnumMemberContext unionStyleEnumMember() {
7408 			return getRuleContext(UnionStyleEnumMemberContext.class,0);
7409 		}
7410 		public UnionStyleEnumMembersContext unionStyleEnumMembers() {
7411 			return getRuleContext(UnionStyleEnumMembersContext.class,0);
7412 		}
7413 		public UnionStyleEnumMembersContext(ParserRuleContext parent, int invokingState) {
7414 			super(parent, invokingState);
7415 		}
7416 		@Override public int getRuleIndex() { return RULE_unionStyleEnumMembers; }
7417 		@Override
7418 		public void enterRule(ParseTreeListener listener) {
7419 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterUnionStyleEnumMembers(this);
7420 		}
7421 		@Override
7422 		public void exitRule(ParseTreeListener listener) {
7423 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitUnionStyleEnumMembers(this);
7424 		}
7425 	}
7426 
7427 	public final UnionStyleEnumMembersContext unionStyleEnumMembers() throws RecognitionException {
7428 		UnionStyleEnumMembersContext _localctx = new UnionStyleEnumMembersContext(_ctx, getState());
7429 		enterRule(_localctx, 214, RULE_unionStyleEnumMembers);
7430 		int _la;
7431 		try {
7432 			enterOuterAlt(_localctx, 1);
7433 			{
7434 			setState(1381);
7435 			unionStyleEnumMember();
7436 			setState(1383);
7437 			_la = _input.LA(1);
7438 			if (((((_la - 6)) & ~0x3f) == 0 && ((1L << (_la - 6)) & ((1L << (T__5 - 6)) | (1L << (T__25 - 6)) | (1L << (T__26 - 6)) | (1L << (T__41 - 6)) | (1L << (T__42 - 6)) | (1L << (T__43 - 6)) | (1L << (T__44 - 6)) | (1L << (T__45 - 6)) | (1L << (T__46 - 6)) | (1L << (T__47 - 6)) | (1L << (T__48 - 6)) | (1L << (T__49 - 6)) | (1L << (T__50 - 6)) | (1L << (T__51 - 6)) | (1L << (T__52 - 6)) | (1L << (T__53 - 6)) | (1L << (T__54 - 6)) | (1L << (T__55 - 6)) | (1L << (T__58 - 6)) | (1L << (T__59 - 6)) | (1L << (T__61 - 6)) | (1L << (T__62 - 6)) | (1L << (T__63 - 6)) | (1L << (T__64 - 6)) | (1L << (T__65 - 6)) | (1L << (T__66 - 6)) | (1L << (T__67 - 6)) | (1L << (T__68 - 6)))) != 0) || ((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & ((1L << (T__81 - 82)) | (1L << (T__82 - 82)) | (1L << (T__85 - 82)) | (1L << (T__86 - 82)) | (1L << (T__87 - 82)) | (1L << (T__96 - 82)) | (1L << (T__119 - 82)) | (1L << (T__129 - 82)))) != 0)) {
7439 				{
7440 				setState(1382);
7441 				unionStyleEnumMembers();
7442 				}
7443 			}
7444 
7445 			}
7446 		}
7447 		catch (RecognitionException re) {
7448 			_localctx.exception = re;
7449 			_errHandler.reportError(this, re);
7450 			_errHandler.recover(this, re);
7451 		}
7452 		finally {
7453 			exitRule();
7454 		}
7455 		return _localctx;
7456 	}
7457 
7458 	public static class UnionStyleEnumMemberContext extends ParserRuleContext {
7459 		public DeclarationContext declaration() {
7460 			return getRuleContext(DeclarationContext.class,0);
7461 		}
7462 		public UnionStyleEnumCaseClauseContext unionStyleEnumCaseClause() {
7463 			return getRuleContext(UnionStyleEnumCaseClauseContext.class,0);
7464 		}
7465 		public UnionStyleEnumMemberContext(ParserRuleContext parent, int invokingState) {
7466 			super(parent, invokingState);
7467 		}
7468 		@Override public int getRuleIndex() { return RULE_unionStyleEnumMember; }
7469 		@Override
7470 		public void enterRule(ParseTreeListener listener) {
7471 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterUnionStyleEnumMember(this);
7472 		}
7473 		@Override
7474 		public void exitRule(ParseTreeListener listener) {
7475 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitUnionStyleEnumMember(this);
7476 		}
7477 	}
7478 
7479 	public final UnionStyleEnumMemberContext unionStyleEnumMember() throws RecognitionException {
7480 		UnionStyleEnumMemberContext _localctx = new UnionStyleEnumMemberContext(_ctx, getState());
7481 		enterRule(_localctx, 216, RULE_unionStyleEnumMember);
7482 		int _la;
7483 		try {
7484 			setState(1390);
7485 			_errHandler.sync(this);
7486 			switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
7487 			case 1:
7488 				enterOuterAlt(_localctx, 1);
7489 				{
7490 				setState(1385);
7491 				declaration();
7492 				}
7493 				break;
7494 			case 2:
7495 				enterOuterAlt(_localctx, 2);
7496 				{
7497 				setState(1386);
7498 				unionStyleEnumCaseClause();
7499 				setState(1388);
7500 				_la = _input.LA(1);
7501 				if (_la==T__0) {
7502 					{
7503 					setState(1387);
7504 					match(T__0);
7505 					}
7506 				}
7507 
7508 				}
7509 				break;
7510 			}
7511 		}
7512 		catch (RecognitionException re) {
7513 			_localctx.exception = re;
7514 			_errHandler.reportError(this, re);
7515 			_errHandler.recover(this, re);
7516 		}
7517 		finally {
7518 			exitRule();
7519 		}
7520 		return _localctx;
7521 	}
7522 
7523 	public static class UnionStyleEnumCaseClauseContext extends ParserRuleContext {
7524 		public UnionStyleEnumCaseListContext unionStyleEnumCaseList() {
7525 			return getRuleContext(UnionStyleEnumCaseListContext.class,0);
7526 		}
7527 		public AttributesContext attributes() {
7528 			return getRuleContext(AttributesContext.class,0);
7529 		}
7530 		public UnionStyleEnumCaseClauseContext(ParserRuleContext parent, int invokingState) {
7531 			super(parent, invokingState);
7532 		}
7533 		@Override public int getRuleIndex() { return RULE_unionStyleEnumCaseClause; }
7534 		@Override
7535 		public void enterRule(ParseTreeListener listener) {
7536 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterUnionStyleEnumCaseClause(this);
7537 		}
7538 		@Override
7539 		public void exitRule(ParseTreeListener listener) {
7540 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitUnionStyleEnumCaseClause(this);
7541 		}
7542 	}
7543 
7544 	public final UnionStyleEnumCaseClauseContext unionStyleEnumCaseClause() throws RecognitionException {
7545 		UnionStyleEnumCaseClauseContext _localctx = new UnionStyleEnumCaseClauseContext(_ctx, getState());
7546 		enterRule(_localctx, 218, RULE_unionStyleEnumCaseClause);
7547 		int _la;
7548 		try {
7549 			enterOuterAlt(_localctx, 1);
7550 			{
7551 			setState(1393);
7552 			_la = _input.LA(1);
7553 			if (_la==T__96) {
7554 				{
7555 				setState(1392);
7556 				attributes();
7557 				}
7558 			}
7559 
7560 			setState(1396);
7561 			_la = _input.LA(1);
7562 			if (_la==T__81) {
7563 				{
7564 				setState(1395);
7565 				match(T__81);
7566 				}
7567 			}
7568 
7569 			setState(1398);
7570 			match(T__5);
7571 			setState(1399);
7572 			unionStyleEnumCaseList();
7573 			}
7574 		}
7575 		catch (RecognitionException re) {
7576 			_localctx.exception = re;
7577 			_errHandler.reportError(this, re);
7578 			_errHandler.recover(this, re);
7579 		}
7580 		finally {
7581 			exitRule();
7582 		}
7583 		return _localctx;
7584 	}
7585 
7586 	public static class UnionStyleEnumCaseListContext extends ParserRuleContext {
7587 		public List<UnionStyleEnumCaseContext> unionStyleEnumCase() {
7588 			return getRuleContexts(UnionStyleEnumCaseContext.class);
7589 		}
7590 		public UnionStyleEnumCaseContext unionStyleEnumCase(int i) {
7591 			return getRuleContext(UnionStyleEnumCaseContext.class,i);
7592 		}
7593 		public UnionStyleEnumCaseListContext(ParserRuleContext parent, int invokingState) {
7594 			super(parent, invokingState);
7595 		}
7596 		@Override public int getRuleIndex() { return RULE_unionStyleEnumCaseList; }
7597 		@Override
7598 		public void enterRule(ParseTreeListener listener) {
7599 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterUnionStyleEnumCaseList(this);
7600 		}
7601 		@Override
7602 		public void exitRule(ParseTreeListener listener) {
7603 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitUnionStyleEnumCaseList(this);
7604 		}
7605 	}
7606 
7607 	public final UnionStyleEnumCaseListContext unionStyleEnumCaseList() throws RecognitionException {
7608 		UnionStyleEnumCaseListContext _localctx = new UnionStyleEnumCaseListContext(_ctx, getState());
7609 		enterRule(_localctx, 220, RULE_unionStyleEnumCaseList);
7610 		int _la;
7611 		try {
7612 			enterOuterAlt(_localctx, 1);
7613 			{
7614 			setState(1401);
7615 			unionStyleEnumCase();
7616 			setState(1406);
7617 			_errHandler.sync(this);
7618 			_la = _input.LA(1);
7619 			while (_la==T__15) {
7620 				{
7621 				{
7622 				setState(1402);
7623 				match(T__15);
7624 				setState(1403);
7625 				unionStyleEnumCase();
7626 				}
7627 				}
7628 				setState(1408);
7629 				_errHandler.sync(this);
7630 				_la = _input.LA(1);
7631 			}
7632 			}
7633 		}
7634 		catch (RecognitionException re) {
7635 			_localctx.exception = re;
7636 			_errHandler.reportError(this, re);
7637 			_errHandler.recover(this, re);
7638 		}
7639 		finally {
7640 			exitRule();
7641 		}
7642 		return _localctx;
7643 	}
7644 
7645 	public static class UnionStyleEnumCaseContext extends ParserRuleContext {
7646 		public EnumCaseNameContext enumCaseName() {
7647 			return getRuleContext(EnumCaseNameContext.class,0);
7648 		}
7649 		public TupleTypeContext tupleType() {
7650 			return getRuleContext(TupleTypeContext.class,0);
7651 		}
7652 		public UnionStyleEnumCaseContext(ParserRuleContext parent, int invokingState) {
7653 			super(parent, invokingState);
7654 		}
7655 		@Override public int getRuleIndex() { return RULE_unionStyleEnumCase; }
7656 		@Override
7657 		public void enterRule(ParseTreeListener listener) {
7658 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterUnionStyleEnumCase(this);
7659 		}
7660 		@Override
7661 		public void exitRule(ParseTreeListener listener) {
7662 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitUnionStyleEnumCase(this);
7663 		}
7664 	}
7665 
7666 	public final UnionStyleEnumCaseContext unionStyleEnumCase() throws RecognitionException {
7667 		UnionStyleEnumCaseContext _localctx = new UnionStyleEnumCaseContext(_ctx, getState());
7668 		enterRule(_localctx, 222, RULE_unionStyleEnumCase);
7669 		int _la;
7670 		try {
7671 			enterOuterAlt(_localctx, 1);
7672 			{
7673 			setState(1409);
7674 			enumCaseName();
7675 			setState(1411);
7676 			_la = _input.LA(1);
7677 			if (_la==T__3) {
7678 				{
7679 				setState(1410);
7680 				tupleType();
7681 				}
7682 			}
7683 
7684 			}
7685 		}
7686 		catch (RecognitionException re) {
7687 			_localctx.exception = re;
7688 			_errHandler.reportError(this, re);
7689 			_errHandler.recover(this, re);
7690 		}
7691 		finally {
7692 			exitRule();
7693 		}
7694 		return _localctx;
7695 	}
7696 
7697 	public static class EnumNameContext extends ParserRuleContext {
7698 		public IdentifierContext identifier() {
7699 			return getRuleContext(IdentifierContext.class,0);
7700 		}
7701 		public EnumNameContext(ParserRuleContext parent, int invokingState) {
7702 			super(parent, invokingState);
7703 		}
7704 		@Override public int getRuleIndex() { return RULE_enumName; }
7705 		@Override
7706 		public void enterRule(ParseTreeListener listener) {
7707 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterEnumName(this);
7708 		}
7709 		@Override
7710 		public void exitRule(ParseTreeListener listener) {
7711 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitEnumName(this);
7712 		}
7713 	}
7714 
7715 	public final EnumNameContext enumName() throws RecognitionException {
7716 		EnumNameContext _localctx = new EnumNameContext(_ctx, getState());
7717 		enterRule(_localctx, 224, RULE_enumName);
7718 		try {
7719 			enterOuterAlt(_localctx, 1);
7720 			{
7721 			setState(1413);
7722 			identifier();
7723 			}
7724 		}
7725 		catch (RecognitionException re) {
7726 			_localctx.exception = re;
7727 			_errHandler.reportError(this, re);
7728 			_errHandler.recover(this, re);
7729 		}
7730 		finally {
7731 			exitRule();
7732 		}
7733 		return _localctx;
7734 	}
7735 
7736 	public static class EnumCaseNameContext extends ParserRuleContext {
7737 		public IdentifierContext identifier() {
7738 			return getRuleContext(IdentifierContext.class,0);
7739 		}
7740 		public EnumCaseNameContext(ParserRuleContext parent, int invokingState) {
7741 			super(parent, invokingState);
7742 		}
7743 		@Override public int getRuleIndex() { return RULE_enumCaseName; }
7744 		@Override
7745 		public void enterRule(ParseTreeListener listener) {
7746 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterEnumCaseName(this);
7747 		}
7748 		@Override
7749 		public void exitRule(ParseTreeListener listener) {
7750 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitEnumCaseName(this);
7751 		}
7752 	}
7753 
7754 	public final EnumCaseNameContext enumCaseName() throws RecognitionException {
7755 		EnumCaseNameContext _localctx = new EnumCaseNameContext(_ctx, getState());
7756 		enterRule(_localctx, 226, RULE_enumCaseName);
7757 		try {
7758 			enterOuterAlt(_localctx, 1);
7759 			{
7760 			setState(1415);
7761 			identifier();
7762 			}
7763 		}
7764 		catch (RecognitionException re) {
7765 			_localctx.exception = re;
7766 			_errHandler.reportError(this, re);
7767 			_errHandler.recover(this, re);
7768 		}
7769 		finally {
7770 			exitRule();
7771 		}
7772 		return _localctx;
7773 	}
7774 
7775 	public static class RawValueStyleEnumContext extends ParserRuleContext {
7776 		public EnumNameContext enumName() {
7777 			return getRuleContext(EnumNameContext.class,0);
7778 		}
7779 		public GenericParameterClauseContext genericParameterClause() {
7780 			return getRuleContext(GenericParameterClauseContext.class,0);
7781 		}
7782 		public TypeInheritanceClauseContext typeInheritanceClause() {
7783 			return getRuleContext(TypeInheritanceClauseContext.class,0);
7784 		}
7785 		public RawValueStyleEnumMembersContext rawValueStyleEnumMembers() {
7786 			return getRuleContext(RawValueStyleEnumMembersContext.class,0);
7787 		}
7788 		public RawValueStyleEnumContext(ParserRuleContext parent, int invokingState) {
7789 			super(parent, invokingState);
7790 		}
7791 		@Override public int getRuleIndex() { return RULE_rawValueStyleEnum; }
7792 		@Override
7793 		public void enterRule(ParseTreeListener listener) {
7794 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueStyleEnum(this);
7795 		}
7796 		@Override
7797 		public void exitRule(ParseTreeListener listener) {
7798 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueStyleEnum(this);
7799 		}
7800 	}
7801 
7802 	public final RawValueStyleEnumContext rawValueStyleEnum() throws RecognitionException {
7803 		RawValueStyleEnumContext _localctx = new RawValueStyleEnumContext(_ctx, getState());
7804 		enterRule(_localctx, 228, RULE_rawValueStyleEnum);
7805 		int _la;
7806 		try {
7807 			enterOuterAlt(_localctx, 1);
7808 			{
7809 			setState(1417);
7810 			match(T__66);
7811 			setState(1418);
7812 			enumName();
7813 			setState(1420);
7814 			_la = _input.LA(1);
7815 			if (_la==T__38) {
7816 				{
7817 				setState(1419);
7818 				genericParameterClause();
7819 				}
7820 			}
7821 
7822 			setState(1423);
7823 			_la = _input.LA(1);
7824 			if (_la==T__1) {
7825 				{
7826 				setState(1422);
7827 				typeInheritanceClause();
7828 				}
7829 			}
7830 
7831 			setState(1425);
7832 			match(T__13);
7833 			setState(1427);
7834 			_la = _input.LA(1);
7835 			if (((((_la - 6)) & ~0x3f) == 0 && ((1L << (_la - 6)) & ((1L << (T__5 - 6)) | (1L << (T__25 - 6)) | (1L << (T__26 - 6)) | (1L << (T__41 - 6)) | (1L << (T__42 - 6)) | (1L << (T__43 - 6)) | (1L << (T__44 - 6)) | (1L << (T__45 - 6)) | (1L << (T__46 - 6)) | (1L << (T__47 - 6)) | (1L << (T__48 - 6)) | (1L << (T__49 - 6)) | (1L << (T__50 - 6)) | (1L << (T__51 - 6)) | (1L << (T__52 - 6)) | (1L << (T__53 - 6)) | (1L << (T__54 - 6)) | (1L << (T__55 - 6)) | (1L << (T__58 - 6)) | (1L << (T__59 - 6)) | (1L << (T__61 - 6)) | (1L << (T__62 - 6)) | (1L << (T__63 - 6)) | (1L << (T__64 - 6)) | (1L << (T__65 - 6)) | (1L << (T__66 - 6)) | (1L << (T__67 - 6)) | (1L << (T__68 - 6)))) != 0) || ((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & ((1L << (T__81 - 82)) | (1L << (T__82 - 82)) | (1L << (T__85 - 82)) | (1L << (T__86 - 82)) | (1L << (T__87 - 82)) | (1L << (T__96 - 82)) | (1L << (T__119 - 82)) | (1L << (T__129 - 82)))) != 0)) {
7836 				{
7837 				setState(1426);
7838 				rawValueStyleEnumMembers();
7839 				}
7840 			}
7841 
7842 			setState(1429);
7843 			match(T__14);
7844 			}
7845 		}
7846 		catch (RecognitionException re) {
7847 			_localctx.exception = re;
7848 			_errHandler.reportError(this, re);
7849 			_errHandler.recover(this, re);
7850 		}
7851 		finally {
7852 			exitRule();
7853 		}
7854 		return _localctx;
7855 	}
7856 
7857 	public static class RawValueStyleEnumMembersContext extends ParserRuleContext {
7858 		public RawValueStyleEnumMemberContext rawValueStyleEnumMember() {
7859 			return getRuleContext(RawValueStyleEnumMemberContext.class,0);
7860 		}
7861 		public RawValueStyleEnumMembersContext rawValueStyleEnumMembers() {
7862 			return getRuleContext(RawValueStyleEnumMembersContext.class,0);
7863 		}
7864 		public RawValueStyleEnumMembersContext(ParserRuleContext parent, int invokingState) {
7865 			super(parent, invokingState);
7866 		}
7867 		@Override public int getRuleIndex() { return RULE_rawValueStyleEnumMembers; }
7868 		@Override
7869 		public void enterRule(ParseTreeListener listener) {
7870 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueStyleEnumMembers(this);
7871 		}
7872 		@Override
7873 		public void exitRule(ParseTreeListener listener) {
7874 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueStyleEnumMembers(this);
7875 		}
7876 	}
7877 
7878 	public final RawValueStyleEnumMembersContext rawValueStyleEnumMembers() throws RecognitionException {
7879 		RawValueStyleEnumMembersContext _localctx = new RawValueStyleEnumMembersContext(_ctx, getState());
7880 		enterRule(_localctx, 230, RULE_rawValueStyleEnumMembers);
7881 		int _la;
7882 		try {
7883 			enterOuterAlt(_localctx, 1);
7884 			{
7885 			setState(1431);
7886 			rawValueStyleEnumMember();
7887 			setState(1433);
7888 			_la = _input.LA(1);
7889 			if (((((_la - 6)) & ~0x3f) == 0 && ((1L << (_la - 6)) & ((1L << (T__5 - 6)) | (1L << (T__25 - 6)) | (1L << (T__26 - 6)) | (1L << (T__41 - 6)) | (1L << (T__42 - 6)) | (1L << (T__43 - 6)) | (1L << (T__44 - 6)) | (1L << (T__45 - 6)) | (1L << (T__46 - 6)) | (1L << (T__47 - 6)) | (1L << (T__48 - 6)) | (1L << (T__49 - 6)) | (1L << (T__50 - 6)) | (1L << (T__51 - 6)) | (1L << (T__52 - 6)) | (1L << (T__53 - 6)) | (1L << (T__54 - 6)) | (1L << (T__55 - 6)) | (1L << (T__58 - 6)) | (1L << (T__59 - 6)) | (1L << (T__61 - 6)) | (1L << (T__62 - 6)) | (1L << (T__63 - 6)) | (1L << (T__64 - 6)) | (1L << (T__65 - 6)) | (1L << (T__66 - 6)) | (1L << (T__67 - 6)) | (1L << (T__68 - 6)))) != 0) || ((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & ((1L << (T__81 - 82)) | (1L << (T__82 - 82)) | (1L << (T__85 - 82)) | (1L << (T__86 - 82)) | (1L << (T__87 - 82)) | (1L << (T__96 - 82)) | (1L << (T__119 - 82)) | (1L << (T__129 - 82)))) != 0)) {
7890 				{
7891 				setState(1432);
7892 				rawValueStyleEnumMembers();
7893 				}
7894 			}
7895 
7896 			}
7897 		}
7898 		catch (RecognitionException re) {
7899 			_localctx.exception = re;
7900 			_errHandler.reportError(this, re);
7901 			_errHandler.recover(this, re);
7902 		}
7903 		finally {
7904 			exitRule();
7905 		}
7906 		return _localctx;
7907 	}
7908 
7909 	public static class RawValueStyleEnumMemberContext extends ParserRuleContext {
7910 		public DeclarationContext declaration() {
7911 			return getRuleContext(DeclarationContext.class,0);
7912 		}
7913 		public RawValueStyleEnumCaseClauseContext rawValueStyleEnumCaseClause() {
7914 			return getRuleContext(RawValueStyleEnumCaseClauseContext.class,0);
7915 		}
7916 		public RawValueStyleEnumMemberContext(ParserRuleContext parent, int invokingState) {
7917 			super(parent, invokingState);
7918 		}
7919 		@Override public int getRuleIndex() { return RULE_rawValueStyleEnumMember; }
7920 		@Override
7921 		public void enterRule(ParseTreeListener listener) {
7922 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueStyleEnumMember(this);
7923 		}
7924 		@Override
7925 		public void exitRule(ParseTreeListener listener) {
7926 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueStyleEnumMember(this);
7927 		}
7928 	}
7929 
7930 	public final RawValueStyleEnumMemberContext rawValueStyleEnumMember() throws RecognitionException {
7931 		RawValueStyleEnumMemberContext _localctx = new RawValueStyleEnumMemberContext(_ctx, getState());
7932 		enterRule(_localctx, 232, RULE_rawValueStyleEnumMember);
7933 		try {
7934 			setState(1437);
7935 			_errHandler.sync(this);
7936 			switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
7937 			case 1:
7938 				enterOuterAlt(_localctx, 1);
7939 				{
7940 				setState(1435);
7941 				declaration();
7942 				}
7943 				break;
7944 			case 2:
7945 				enterOuterAlt(_localctx, 2);
7946 				{
7947 				setState(1436);
7948 				rawValueStyleEnumCaseClause();
7949 				}
7950 				break;
7951 			}
7952 		}
7953 		catch (RecognitionException re) {
7954 			_localctx.exception = re;
7955 			_errHandler.reportError(this, re);
7956 			_errHandler.recover(this, re);
7957 		}
7958 		finally {
7959 			exitRule();
7960 		}
7961 		return _localctx;
7962 	}
7963 
7964 	public static class RawValueStyleEnumCaseClauseContext extends ParserRuleContext {
7965 		public RawValueStyleEnumCaseListContext rawValueStyleEnumCaseList() {
7966 			return getRuleContext(RawValueStyleEnumCaseListContext.class,0);
7967 		}
7968 		public AttributesContext attributes() {
7969 			return getRuleContext(AttributesContext.class,0);
7970 		}
7971 		public RawValueStyleEnumCaseClauseContext(ParserRuleContext parent, int invokingState) {
7972 			super(parent, invokingState);
7973 		}
7974 		@Override public int getRuleIndex() { return RULE_rawValueStyleEnumCaseClause; }
7975 		@Override
7976 		public void enterRule(ParseTreeListener listener) {
7977 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueStyleEnumCaseClause(this);
7978 		}
7979 		@Override
7980 		public void exitRule(ParseTreeListener listener) {
7981 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueStyleEnumCaseClause(this);
7982 		}
7983 	}
7984 
7985 	public final RawValueStyleEnumCaseClauseContext rawValueStyleEnumCaseClause() throws RecognitionException {
7986 		RawValueStyleEnumCaseClauseContext _localctx = new RawValueStyleEnumCaseClauseContext(_ctx, getState());
7987 		enterRule(_localctx, 234, RULE_rawValueStyleEnumCaseClause);
7988 		int _la;
7989 		try {
7990 			enterOuterAlt(_localctx, 1);
7991 			{
7992 			setState(1440);
7993 			_la = _input.LA(1);
7994 			if (_la==T__96) {
7995 				{
7996 				setState(1439);
7997 				attributes();
7998 				}
7999 			}
8000 
8001 			setState(1442);
8002 			match(T__5);
8003 			setState(1443);
8004 			rawValueStyleEnumCaseList();
8005 			}
8006 		}
8007 		catch (RecognitionException re) {
8008 			_localctx.exception = re;
8009 			_errHandler.reportError(this, re);
8010 			_errHandler.recover(this, re);
8011 		}
8012 		finally {
8013 			exitRule();
8014 		}
8015 		return _localctx;
8016 	}
8017 
8018 	public static class RawValueStyleEnumCaseListContext extends ParserRuleContext {
8019 		public List<RawValueStyleEnumCaseContext> rawValueStyleEnumCase() {
8020 			return getRuleContexts(RawValueStyleEnumCaseContext.class);
8021 		}
8022 		public RawValueStyleEnumCaseContext rawValueStyleEnumCase(int i) {
8023 			return getRuleContext(RawValueStyleEnumCaseContext.class,i);
8024 		}
8025 		public RawValueStyleEnumCaseListContext(ParserRuleContext parent, int invokingState) {
8026 			super(parent, invokingState);
8027 		}
8028 		@Override public int getRuleIndex() { return RULE_rawValueStyleEnumCaseList; }
8029 		@Override
8030 		public void enterRule(ParseTreeListener listener) {
8031 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueStyleEnumCaseList(this);
8032 		}
8033 		@Override
8034 		public void exitRule(ParseTreeListener listener) {
8035 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueStyleEnumCaseList(this);
8036 		}
8037 	}
8038 
8039 	public final RawValueStyleEnumCaseListContext rawValueStyleEnumCaseList() throws RecognitionException {
8040 		RawValueStyleEnumCaseListContext _localctx = new RawValueStyleEnumCaseListContext(_ctx, getState());
8041 		enterRule(_localctx, 236, RULE_rawValueStyleEnumCaseList);
8042 		int _la;
8043 		try {
8044 			enterOuterAlt(_localctx, 1);
8045 			{
8046 			setState(1445);
8047 			rawValueStyleEnumCase();
8048 			setState(1450);
8049 			_errHandler.sync(this);
8050 			_la = _input.LA(1);
8051 			while (_la==T__15) {
8052 				{
8053 				{
8054 				setState(1446);
8055 				match(T__15);
8056 				setState(1447);
8057 				rawValueStyleEnumCase();
8058 				}
8059 				}
8060 				setState(1452);
8061 				_errHandler.sync(this);
8062 				_la = _input.LA(1);
8063 			}
8064 			}
8065 		}
8066 		catch (RecognitionException re) {
8067 			_localctx.exception = re;
8068 			_errHandler.reportError(this, re);
8069 			_errHandler.recover(this, re);
8070 		}
8071 		finally {
8072 			exitRule();
8073 		}
8074 		return _localctx;
8075 	}
8076 
8077 	public static class RawValueStyleEnumCaseContext extends ParserRuleContext {
8078 		public EnumCaseNameContext enumCaseName() {
8079 			return getRuleContext(EnumCaseNameContext.class,0);
8080 		}
8081 		public RawValueAssignmentContext rawValueAssignment() {
8082 			return getRuleContext(RawValueAssignmentContext.class,0);
8083 		}
8084 		public RawValueStyleEnumCaseContext(ParserRuleContext parent, int invokingState) {
8085 			super(parent, invokingState);
8086 		}
8087 		@Override public int getRuleIndex() { return RULE_rawValueStyleEnumCase; }
8088 		@Override
8089 		public void enterRule(ParseTreeListener listener) {
8090 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueStyleEnumCase(this);
8091 		}
8092 		@Override
8093 		public void exitRule(ParseTreeListener listener) {
8094 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueStyleEnumCase(this);
8095 		}
8096 	}
8097 
8098 	public final RawValueStyleEnumCaseContext rawValueStyleEnumCase() throws RecognitionException {
8099 		RawValueStyleEnumCaseContext _localctx = new RawValueStyleEnumCaseContext(_ctx, getState());
8100 		enterRule(_localctx, 238, RULE_rawValueStyleEnumCase);
8101 		int _la;
8102 		try {
8103 			enterOuterAlt(_localctx, 1);
8104 			{
8105 			setState(1453);
8106 			enumCaseName();
8107 			setState(1455);
8108 			_la = _input.LA(1);
8109 			if (_la==T__70) {
8110 				{
8111 				setState(1454);
8112 				rawValueAssignment();
8113 				}
8114 			}
8115 
8116 			}
8117 		}
8118 		catch (RecognitionException re) {
8119 			_localctx.exception = re;
8120 			_errHandler.reportError(this, re);
8121 			_errHandler.recover(this, re);
8122 		}
8123 		finally {
8124 			exitRule();
8125 		}
8126 		return _localctx;
8127 	}
8128 
8129 	public static class RawValueAssignmentContext extends ParserRuleContext {
8130 		public LiteralContext literal() {
8131 			return getRuleContext(LiteralContext.class,0);
8132 		}
8133 		public RawValueAssignmentContext(ParserRuleContext parent, int invokingState) {
8134 			super(parent, invokingState);
8135 		}
8136 		@Override public int getRuleIndex() { return RULE_rawValueAssignment; }
8137 		@Override
8138 		public void enterRule(ParseTreeListener listener) {
8139 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterRawValueAssignment(this);
8140 		}
8141 		@Override
8142 		public void exitRule(ParseTreeListener listener) {
8143 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitRawValueAssignment(this);
8144 		}
8145 	}
8146 
8147 	public final RawValueAssignmentContext rawValueAssignment() throws RecognitionException {
8148 		RawValueAssignmentContext _localctx = new RawValueAssignmentContext(_ctx, getState());
8149 		enterRule(_localctx, 240, RULE_rawValueAssignment);
8150 		try {
8151 			enterOuterAlt(_localctx, 1);
8152 			{
8153 			setState(1457);
8154 			match(T__70);
8155 			setState(1458);
8156 			literal();
8157 			}
8158 		}
8159 		catch (RecognitionException re) {
8160 			_localctx.exception = re;
8161 			_errHandler.reportError(this, re);
8162 			_errHandler.recover(this, re);
8163 		}
8164 		finally {
8165 			exitRule();
8166 		}
8167 		return _localctx;
8168 	}
8169 
8170 	public static class StructDeclarationContext extends ParserRuleContext {
8171 		public StructNameContext structName() {
8172 			return getRuleContext(StructNameContext.class,0);
8173 		}
8174 		public StructBodyContext structBody() {
8175 			return getRuleContext(StructBodyContext.class,0);
8176 		}
8177 		public AttributesContext attributes() {
8178 			return getRuleContext(AttributesContext.class,0);
8179 		}
8180 		public AccessLevelModifierContext accessLevelModifier() {
8181 			return getRuleContext(AccessLevelModifierContext.class,0);
8182 		}
8183 		public GenericParameterClauseContext genericParameterClause() {
8184 			return getRuleContext(GenericParameterClauseContext.class,0);
8185 		}
8186 		public TypeInheritanceClauseContext typeInheritanceClause() {
8187 			return getRuleContext(TypeInheritanceClauseContext.class,0);
8188 		}
8189 		public StructDeclarationContext(ParserRuleContext parent, int invokingState) {
8190 			super(parent, invokingState);
8191 		}
8192 		@Override public int getRuleIndex() { return RULE_structDeclaration; }
8193 		@Override
8194 		public void enterRule(ParseTreeListener listener) {
8195 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterStructDeclaration(this);
8196 		}
8197 		@Override
8198 		public void exitRule(ParseTreeListener listener) {
8199 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitStructDeclaration(this);
8200 		}
8201 	}
8202 
8203 	public final StructDeclarationContext structDeclaration() throws RecognitionException {
8204 		StructDeclarationContext _localctx = new StructDeclarationContext(_ctx, getState());
8205 		enterRule(_localctx, 242, RULE_structDeclaration);
8206 		int _la;
8207 		try {
8208 			enterOuterAlt(_localctx, 1);
8209 			{
8210 			setState(1461);
8211 			_la = _input.LA(1);
8212 			if (_la==T__96) {
8213 				{
8214 				setState(1460);
8215 				attributes();
8216 				}
8217 			}
8218 
8219 			setState(1464);
8220 			_la = _input.LA(1);
8221 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
8222 				{
8223 				setState(1463);
8224 				accessLevelModifier();
8225 				}
8226 			}
8227 
8228 			setState(1466);
8229 			match(T__65);
8230 			setState(1467);
8231 			structName();
8232 			setState(1469);
8233 			_la = _input.LA(1);
8234 			if (_la==T__38) {
8235 				{
8236 				setState(1468);
8237 				genericParameterClause();
8238 				}
8239 			}
8240 
8241 			setState(1472);
8242 			_la = _input.LA(1);
8243 			if (_la==T__1) {
8244 				{
8245 				setState(1471);
8246 				typeInheritanceClause();
8247 				}
8248 			}
8249 
8250 			setState(1474);
8251 			structBody();
8252 			}
8253 		}
8254 		catch (RecognitionException re) {
8255 			_localctx.exception = re;
8256 			_errHandler.reportError(this, re);
8257 			_errHandler.recover(this, re);
8258 		}
8259 		finally {
8260 			exitRule();
8261 		}
8262 		return _localctx;
8263 	}
8264 
8265 	public static class StructNameContext extends ParserRuleContext {
8266 		public IdentifierContext identifier() {
8267 			return getRuleContext(IdentifierContext.class,0);
8268 		}
8269 		public StructNameContext(ParserRuleContext parent, int invokingState) {
8270 			super(parent, invokingState);
8271 		}
8272 		@Override public int getRuleIndex() { return RULE_structName; }
8273 		@Override
8274 		public void enterRule(ParseTreeListener listener) {
8275 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterStructName(this);
8276 		}
8277 		@Override
8278 		public void exitRule(ParseTreeListener listener) {
8279 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitStructName(this);
8280 		}
8281 	}
8282 
8283 	public final StructNameContext structName() throws RecognitionException {
8284 		StructNameContext _localctx = new StructNameContext(_ctx, getState());
8285 		enterRule(_localctx, 244, RULE_structName);
8286 		try {
8287 			enterOuterAlt(_localctx, 1);
8288 			{
8289 			setState(1476);
8290 			identifier();
8291 			}
8292 		}
8293 		catch (RecognitionException re) {
8294 			_localctx.exception = re;
8295 			_errHandler.reportError(this, re);
8296 			_errHandler.recover(this, re);
8297 		}
8298 		finally {
8299 			exitRule();
8300 		}
8301 		return _localctx;
8302 	}
8303 
8304 	public static class StructBodyContext extends ParserRuleContext {
8305 		public DeclarationsContext declarations() {
8306 			return getRuleContext(DeclarationsContext.class,0);
8307 		}
8308 		public StructBodyContext(ParserRuleContext parent, int invokingState) {
8309 			super(parent, invokingState);
8310 		}
8311 		@Override public int getRuleIndex() { return RULE_structBody; }
8312 		@Override
8313 		public void enterRule(ParseTreeListener listener) {
8314 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterStructBody(this);
8315 		}
8316 		@Override
8317 		public void exitRule(ParseTreeListener listener) {
8318 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitStructBody(this);
8319 		}
8320 	}
8321 
8322 	public final StructBodyContext structBody() throws RecognitionException {
8323 		StructBodyContext _localctx = new StructBodyContext(_ctx, getState());
8324 		enterRule(_localctx, 246, RULE_structBody);
8325 		int _la;
8326 		try {
8327 			enterOuterAlt(_localctx, 1);
8328 			{
8329 			setState(1478);
8330 			match(T__13);
8331 			setState(1480);
8332 			_la = _input.LA(1);
8333 			if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (T__25 - 26)) | (1L << (T__26 - 26)) | (1L << (T__41 - 26)) | (1L << (T__42 - 26)) | (1L << (T__43 - 26)) | (1L << (T__44 - 26)) | (1L << (T__45 - 26)) | (1L << (T__46 - 26)) | (1L << (T__47 - 26)) | (1L << (T__48 - 26)) | (1L << (T__49 - 26)) | (1L << (T__50 - 26)) | (1L << (T__51 - 26)) | (1L << (T__52 - 26)) | (1L << (T__53 - 26)) | (1L << (T__54 - 26)) | (1L << (T__55 - 26)) | (1L << (T__58 - 26)) | (1L << (T__59 - 26)) | (1L << (T__61 - 26)) | (1L << (T__62 - 26)) | (1L << (T__63 - 26)) | (1L << (T__64 - 26)) | (1L << (T__65 - 26)) | (1L << (T__66 - 26)) | (1L << (T__67 - 26)) | (1L << (T__68 - 26)) | (1L << (T__81 - 26)) | (1L << (T__82 - 26)) | (1L << (T__85 - 26)) | (1L << (T__86 - 26)) | (1L << (T__87 - 26)))) != 0) || ((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & ((1L << (T__96 - 97)) | (1L << (T__119 - 97)) | (1L << (T__129 - 97)))) != 0)) {
8334 				{
8335 				setState(1479);
8336 				declarations();
8337 				}
8338 			}
8339 
8340 			setState(1482);
8341 			match(T__14);
8342 			}
8343 		}
8344 		catch (RecognitionException re) {
8345 			_localctx.exception = re;
8346 			_errHandler.reportError(this, re);
8347 			_errHandler.recover(this, re);
8348 		}
8349 		finally {
8350 			exitRule();
8351 		}
8352 		return _localctx;
8353 	}
8354 
8355 	public static class ClassDeclarationContext extends ParserRuleContext {
8356 		public ClassNameContext className() {
8357 			return getRuleContext(ClassNameContext.class,0);
8358 		}
8359 		public ClassBodyContext classBody() {
8360 			return getRuleContext(ClassBodyContext.class,0);
8361 		}
8362 		public AttributesContext attributes() {
8363 			return getRuleContext(AttributesContext.class,0);
8364 		}
8365 		public List<DeclarationModifierContext> declarationModifier() {
8366 			return getRuleContexts(DeclarationModifierContext.class);
8367 		}
8368 		public DeclarationModifierContext declarationModifier(int i) {
8369 			return getRuleContext(DeclarationModifierContext.class,i);
8370 		}
8371 		public GenericParameterClauseContext genericParameterClause() {
8372 			return getRuleContext(GenericParameterClauseContext.class,0);
8373 		}
8374 		public TypeInheritanceClauseContext typeInheritanceClause() {
8375 			return getRuleContext(TypeInheritanceClauseContext.class,0);
8376 		}
8377 		public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
8378 			super(parent, invokingState);
8379 		}
8380 		@Override public int getRuleIndex() { return RULE_classDeclaration; }
8381 		@Override
8382 		public void enterRule(ParseTreeListener listener) {
8383 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterClassDeclaration(this);
8384 		}
8385 		@Override
8386 		public void exitRule(ParseTreeListener listener) {
8387 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitClassDeclaration(this);
8388 		}
8389 	}
8390 
8391 	public final ClassDeclarationContext classDeclaration() throws RecognitionException {
8392 		ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
8393 		enterRule(_localctx, 248, RULE_classDeclaration);
8394 		int _la;
8395 		try {
8396 			int _alt;
8397 			enterOuterAlt(_localctx, 1);
8398 			{
8399 			setState(1485);
8400 			_la = _input.LA(1);
8401 			if (_la==T__96) {
8402 				{
8403 				setState(1484);
8404 				attributes();
8405 				}
8406 			}
8407 
8408 			setState(1490);
8409 			_errHandler.sync(this);
8410 			_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
8411 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8412 				if ( _alt==1 ) {
8413 					{
8414 					{
8415 					setState(1487);
8416 					declarationModifier();
8417 					}
8418 					} 
8419 				}
8420 				setState(1492);
8421 				_errHandler.sync(this);
8422 				_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
8423 			}
8424 			setState(1493);
8425 			match(T__41);
8426 			setState(1494);
8427 			className();
8428 			setState(1496);
8429 			_la = _input.LA(1);
8430 			if (_la==T__38) {
8431 				{
8432 				setState(1495);
8433 				genericParameterClause();
8434 				}
8435 			}
8436 
8437 			setState(1499);
8438 			_la = _input.LA(1);
8439 			if (_la==T__1) {
8440 				{
8441 				setState(1498);
8442 				typeInheritanceClause();
8443 				}
8444 			}
8445 
8446 			setState(1501);
8447 			classBody();
8448 			}
8449 		}
8450 		catch (RecognitionException re) {
8451 			_localctx.exception = re;
8452 			_errHandler.reportError(this, re);
8453 			_errHandler.recover(this, re);
8454 		}
8455 		finally {
8456 			exitRule();
8457 		}
8458 		return _localctx;
8459 	}
8460 
8461 	public static class ClassNameContext extends ParserRuleContext {
8462 		public IdentifierContext identifier() {
8463 			return getRuleContext(IdentifierContext.class,0);
8464 		}
8465 		public ClassNameContext(ParserRuleContext parent, int invokingState) {
8466 			super(parent, invokingState);
8467 		}
8468 		@Override public int getRuleIndex() { return RULE_className; }
8469 		@Override
8470 		public void enterRule(ParseTreeListener listener) {
8471 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterClassName(this);
8472 		}
8473 		@Override
8474 		public void exitRule(ParseTreeListener listener) {
8475 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitClassName(this);
8476 		}
8477 	}
8478 
8479 	public final ClassNameContext className() throws RecognitionException {
8480 		ClassNameContext _localctx = new ClassNameContext(_ctx, getState());
8481 		enterRule(_localctx, 250, RULE_className);
8482 		try {
8483 			enterOuterAlt(_localctx, 1);
8484 			{
8485 			setState(1503);
8486 			identifier();
8487 			}
8488 		}
8489 		catch (RecognitionException re) {
8490 			_localctx.exception = re;
8491 			_errHandler.reportError(this, re);
8492 			_errHandler.recover(this, re);
8493 		}
8494 		finally {
8495 			exitRule();
8496 		}
8497 		return _localctx;
8498 	}
8499 
8500 	public static class ClassBodyContext extends ParserRuleContext {
8501 		public DeclarationsContext declarations() {
8502 			return getRuleContext(DeclarationsContext.class,0);
8503 		}
8504 		public ClassBodyContext(ParserRuleContext parent, int invokingState) {
8505 			super(parent, invokingState);
8506 		}
8507 		@Override public int getRuleIndex() { return RULE_classBody; }
8508 		@Override
8509 		public void enterRule(ParseTreeListener listener) {
8510 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterClassBody(this);
8511 		}
8512 		@Override
8513 		public void exitRule(ParseTreeListener listener) {
8514 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitClassBody(this);
8515 		}
8516 	}
8517 
8518 	public final ClassBodyContext classBody() throws RecognitionException {
8519 		ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
8520 		enterRule(_localctx, 252, RULE_classBody);
8521 		int _la;
8522 		try {
8523 			enterOuterAlt(_localctx, 1);
8524 			{
8525 			setState(1505);
8526 			match(T__13);
8527 			setState(1507);
8528 			_la = _input.LA(1);
8529 			if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (T__25 - 26)) | (1L << (T__26 - 26)) | (1L << (T__41 - 26)) | (1L << (T__42 - 26)) | (1L << (T__43 - 26)) | (1L << (T__44 - 26)) | (1L << (T__45 - 26)) | (1L << (T__46 - 26)) | (1L << (T__47 - 26)) | (1L << (T__48 - 26)) | (1L << (T__49 - 26)) | (1L << (T__50 - 26)) | (1L << (T__51 - 26)) | (1L << (T__52 - 26)) | (1L << (T__53 - 26)) | (1L << (T__54 - 26)) | (1L << (T__55 - 26)) | (1L << (T__58 - 26)) | (1L << (T__59 - 26)) | (1L << (T__61 - 26)) | (1L << (T__62 - 26)) | (1L << (T__63 - 26)) | (1L << (T__64 - 26)) | (1L << (T__65 - 26)) | (1L << (T__66 - 26)) | (1L << (T__67 - 26)) | (1L << (T__68 - 26)) | (1L << (T__81 - 26)) | (1L << (T__82 - 26)) | (1L << (T__85 - 26)) | (1L << (T__86 - 26)) | (1L << (T__87 - 26)))) != 0) || ((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & ((1L << (T__96 - 97)) | (1L << (T__119 - 97)) | (1L << (T__129 - 97)))) != 0)) {
8530 				{
8531 				setState(1506);
8532 				declarations();
8533 				}
8534 			}
8535 
8536 			setState(1509);
8537 			match(T__14);
8538 			}
8539 		}
8540 		catch (RecognitionException re) {
8541 			_localctx.exception = re;
8542 			_errHandler.reportError(this, re);
8543 			_errHandler.recover(this, re);
8544 		}
8545 		finally {
8546 			exitRule();
8547 		}
8548 		return _localctx;
8549 	}
8550 
8551 	public static class ProtocolDeclarationContext extends ParserRuleContext {
8552 		public ProtocolNameContext protocolName() {
8553 			return getRuleContext(ProtocolNameContext.class,0);
8554 		}
8555 		public ProtocolBodyContext protocolBody() {
8556 			return getRuleContext(ProtocolBodyContext.class,0);
8557 		}
8558 		public AttributesContext attributes() {
8559 			return getRuleContext(AttributesContext.class,0);
8560 		}
8561 		public AccessLevelModifierContext accessLevelModifier() {
8562 			return getRuleContext(AccessLevelModifierContext.class,0);
8563 		}
8564 		public TypeInheritanceClauseContext typeInheritanceClause() {
8565 			return getRuleContext(TypeInheritanceClauseContext.class,0);
8566 		}
8567 		public ProtocolDeclarationContext(ParserRuleContext parent, int invokingState) {
8568 			super(parent, invokingState);
8569 		}
8570 		@Override public int getRuleIndex() { return RULE_protocolDeclaration; }
8571 		@Override
8572 		public void enterRule(ParseTreeListener listener) {
8573 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolDeclaration(this);
8574 		}
8575 		@Override
8576 		public void exitRule(ParseTreeListener listener) {
8577 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolDeclaration(this);
8578 		}
8579 	}
8580 
8581 	public final ProtocolDeclarationContext protocolDeclaration() throws RecognitionException {
8582 		ProtocolDeclarationContext _localctx = new ProtocolDeclarationContext(_ctx, getState());
8583 		enterRule(_localctx, 254, RULE_protocolDeclaration);
8584 		int _la;
8585 		try {
8586 			enterOuterAlt(_localctx, 1);
8587 			{
8588 			setState(1512);
8589 			_la = _input.LA(1);
8590 			if (_la==T__96) {
8591 				{
8592 				setState(1511);
8593 				attributes();
8594 				}
8595 			}
8596 
8597 			setState(1515);
8598 			_la = _input.LA(1);
8599 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
8600 				{
8601 				setState(1514);
8602 				accessLevelModifier();
8603 				}
8604 			}
8605 
8606 			setState(1517);
8607 			match(T__67);
8608 			setState(1518);
8609 			protocolName();
8610 			setState(1520);
8611 			_la = _input.LA(1);
8612 			if (_la==T__1) {
8613 				{
8614 				setState(1519);
8615 				typeInheritanceClause();
8616 				}
8617 			}
8618 
8619 			setState(1522);
8620 			protocolBody();
8621 			}
8622 		}
8623 		catch (RecognitionException re) {
8624 			_localctx.exception = re;
8625 			_errHandler.reportError(this, re);
8626 			_errHandler.recover(this, re);
8627 		}
8628 		finally {
8629 			exitRule();
8630 		}
8631 		return _localctx;
8632 	}
8633 
8634 	public static class ProtocolNameContext extends ParserRuleContext {
8635 		public IdentifierContext identifier() {
8636 			return getRuleContext(IdentifierContext.class,0);
8637 		}
8638 		public ProtocolNameContext(ParserRuleContext parent, int invokingState) {
8639 			super(parent, invokingState);
8640 		}
8641 		@Override public int getRuleIndex() { return RULE_protocolName; }
8642 		@Override
8643 		public void enterRule(ParseTreeListener listener) {
8644 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolName(this);
8645 		}
8646 		@Override
8647 		public void exitRule(ParseTreeListener listener) {
8648 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolName(this);
8649 		}
8650 	}
8651 
8652 	public final ProtocolNameContext protocolName() throws RecognitionException {
8653 		ProtocolNameContext _localctx = new ProtocolNameContext(_ctx, getState());
8654 		enterRule(_localctx, 256, RULE_protocolName);
8655 		try {
8656 			enterOuterAlt(_localctx, 1);
8657 			{
8658 			setState(1524);
8659 			identifier();
8660 			}
8661 		}
8662 		catch (RecognitionException re) {
8663 			_localctx.exception = re;
8664 			_errHandler.reportError(this, re);
8665 			_errHandler.recover(this, re);
8666 		}
8667 		finally {
8668 			exitRule();
8669 		}
8670 		return _localctx;
8671 	}
8672 
8673 	public static class ProtocolBodyContext extends ParserRuleContext {
8674 		public ProtocolMemberDeclarationsContext protocolMemberDeclarations() {
8675 			return getRuleContext(ProtocolMemberDeclarationsContext.class,0);
8676 		}
8677 		public ProtocolBodyContext(ParserRuleContext parent, int invokingState) {
8678 			super(parent, invokingState);
8679 		}
8680 		@Override public int getRuleIndex() { return RULE_protocolBody; }
8681 		@Override
8682 		public void enterRule(ParseTreeListener listener) {
8683 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolBody(this);
8684 		}
8685 		@Override
8686 		public void exitRule(ParseTreeListener listener) {
8687 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolBody(this);
8688 		}
8689 	}
8690 
8691 	public final ProtocolBodyContext protocolBody() throws RecognitionException {
8692 		ProtocolBodyContext _localctx = new ProtocolBodyContext(_ctx, getState());
8693 		enterRule(_localctx, 258, RULE_protocolBody);
8694 		int _la;
8695 		try {
8696 			enterOuterAlt(_localctx, 1);
8697 			{
8698 			setState(1526);
8699 			match(T__13);
8700 			setState(1528);
8701 			_la = _input.LA(1);
8702 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__26) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (T__64 - 65)) | (1L << (T__68 - 65)) | (1L << (T__82 - 65)) | (1L << (T__87 - 65)) | (1L << (T__96 - 65)))) != 0)) {
8703 				{
8704 				setState(1527);
8705 				protocolMemberDeclarations();
8706 				}
8707 			}
8708 
8709 			setState(1530);
8710 			match(T__14);
8711 			}
8712 		}
8713 		catch (RecognitionException re) {
8714 			_localctx.exception = re;
8715 			_errHandler.reportError(this, re);
8716 			_errHandler.recover(this, re);
8717 		}
8718 		finally {
8719 			exitRule();
8720 		}
8721 		return _localctx;
8722 	}
8723 
8724 	public static class ProtocolMemberDeclarationContext extends ParserRuleContext {
8725 		public ProtocolPropertyDeclarationContext protocolPropertyDeclaration() {
8726 			return getRuleContext(ProtocolPropertyDeclarationContext.class,0);
8727 		}
8728 		public ProtocolMethodDeclarationContext protocolMethodDeclaration() {
8729 			return getRuleContext(ProtocolMethodDeclarationContext.class,0);
8730 		}
8731 		public ProtocolInitializerDeclarationContext protocolInitializerDeclaration() {
8732 			return getRuleContext(ProtocolInitializerDeclarationContext.class,0);
8733 		}
8734 		public ProtocolSubscriptDeclarationContext protocolSubscriptDeclaration() {
8735 			return getRuleContext(ProtocolSubscriptDeclarationContext.class,0);
8736 		}
8737 		public ProtocolAssociatedTypeDeclarationContext protocolAssociatedTypeDeclaration() {
8738 			return getRuleContext(ProtocolAssociatedTypeDeclarationContext.class,0);
8739 		}
8740 		public ProtocolMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
8741 			super(parent, invokingState);
8742 		}
8743 		@Override public int getRuleIndex() { return RULE_protocolMemberDeclaration; }
8744 		@Override
8745 		public void enterRule(ParseTreeListener listener) {
8746 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolMemberDeclaration(this);
8747 		}
8748 		@Override
8749 		public void exitRule(ParseTreeListener listener) {
8750 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolMemberDeclaration(this);
8751 		}
8752 	}
8753 
8754 	public final ProtocolMemberDeclarationContext protocolMemberDeclaration() throws RecognitionException {
8755 		ProtocolMemberDeclarationContext _localctx = new ProtocolMemberDeclarationContext(_ctx, getState());
8756 		enterRule(_localctx, 260, RULE_protocolMemberDeclaration);
8757 		int _la;
8758 		try {
8759 			setState(1552);
8760 			_errHandler.sync(this);
8761 			switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
8762 			case 1:
8763 				enterOuterAlt(_localctx, 1);
8764 				{
8765 				setState(1532);
8766 				protocolPropertyDeclaration();
8767 				setState(1534);
8768 				_la = _input.LA(1);
8769 				if (_la==T__0) {
8770 					{
8771 					setState(1533);
8772 					match(T__0);
8773 					}
8774 				}
8775 
8776 				}
8777 				break;
8778 			case 2:
8779 				enterOuterAlt(_localctx, 2);
8780 				{
8781 				setState(1536);
8782 				protocolMethodDeclaration();
8783 				setState(1538);
8784 				_la = _input.LA(1);
8785 				if (_la==T__0) {
8786 					{
8787 					setState(1537);
8788 					match(T__0);
8789 					}
8790 				}
8791 
8792 				}
8793 				break;
8794 			case 3:
8795 				enterOuterAlt(_localctx, 3);
8796 				{
8797 				setState(1540);
8798 				protocolInitializerDeclaration();
8799 				setState(1542);
8800 				_la = _input.LA(1);
8801 				if (_la==T__0) {
8802 					{
8803 					setState(1541);
8804 					match(T__0);
8805 					}
8806 				}
8807 
8808 				}
8809 				break;
8810 			case 4:
8811 				enterOuterAlt(_localctx, 4);
8812 				{
8813 				setState(1544);
8814 				protocolSubscriptDeclaration();
8815 				setState(1546);
8816 				_la = _input.LA(1);
8817 				if (_la==T__0) {
8818 					{
8819 					setState(1545);
8820 					match(T__0);
8821 					}
8822 				}
8823 
8824 				}
8825 				break;
8826 			case 5:
8827 				enterOuterAlt(_localctx, 5);
8828 				{
8829 				setState(1548);
8830 				protocolAssociatedTypeDeclaration();
8831 				setState(1550);
8832 				_la = _input.LA(1);
8833 				if (_la==T__0) {
8834 					{
8835 					setState(1549);
8836 					match(T__0);
8837 					}
8838 				}
8839 
8840 				}
8841 				break;
8842 			}
8843 		}
8844 		catch (RecognitionException re) {
8845 			_localctx.exception = re;
8846 			_errHandler.reportError(this, re);
8847 			_errHandler.recover(this, re);
8848 		}
8849 		finally {
8850 			exitRule();
8851 		}
8852 		return _localctx;
8853 	}
8854 
8855 	public static class ProtocolMemberDeclarationsContext extends ParserRuleContext {
8856 		public ProtocolMemberDeclarationContext protocolMemberDeclaration() {
8857 			return getRuleContext(ProtocolMemberDeclarationContext.class,0);
8858 		}
8859 		public ProtocolMemberDeclarationsContext protocolMemberDeclarations() {
8860 			return getRuleContext(ProtocolMemberDeclarationsContext.class,0);
8861 		}
8862 		public ProtocolMemberDeclarationsContext(ParserRuleContext parent, int invokingState) {
8863 			super(parent, invokingState);
8864 		}
8865 		@Override public int getRuleIndex() { return RULE_protocolMemberDeclarations; }
8866 		@Override
8867 		public void enterRule(ParseTreeListener listener) {
8868 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolMemberDeclarations(this);
8869 		}
8870 		@Override
8871 		public void exitRule(ParseTreeListener listener) {
8872 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolMemberDeclarations(this);
8873 		}
8874 	}
8875 
8876 	public final ProtocolMemberDeclarationsContext protocolMemberDeclarations() throws RecognitionException {
8877 		ProtocolMemberDeclarationsContext _localctx = new ProtocolMemberDeclarationsContext(_ctx, getState());
8878 		enterRule(_localctx, 262, RULE_protocolMemberDeclarations);
8879 		int _la;
8880 		try {
8881 			enterOuterAlt(_localctx, 1);
8882 			{
8883 			setState(1554);
8884 			protocolMemberDeclaration();
8885 			setState(1556);
8886 			_la = _input.LA(1);
8887 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__26) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (T__64 - 65)) | (1L << (T__68 - 65)) | (1L << (T__82 - 65)) | (1L << (T__87 - 65)) | (1L << (T__96 - 65)))) != 0)) {
8888 				{
8889 				setState(1555);
8890 				protocolMemberDeclarations();
8891 				}
8892 			}
8893 
8894 			}
8895 		}
8896 		catch (RecognitionException re) {
8897 			_localctx.exception = re;
8898 			_errHandler.reportError(this, re);
8899 			_errHandler.recover(this, re);
8900 		}
8901 		finally {
8902 			exitRule();
8903 		}
8904 		return _localctx;
8905 	}
8906 
8907 	public static class ProtocolPropertyDeclarationContext extends ParserRuleContext {
8908 		public VariableDeclarationHeadContext variableDeclarationHead() {
8909 			return getRuleContext(VariableDeclarationHeadContext.class,0);
8910 		}
8911 		public VariableNameContext variableName() {
8912 			return getRuleContext(VariableNameContext.class,0);
8913 		}
8914 		public TypeAnnotationContext typeAnnotation() {
8915 			return getRuleContext(TypeAnnotationContext.class,0);
8916 		}
8917 		public GetterSetterKeywordBlockContext getterSetterKeywordBlock() {
8918 			return getRuleContext(GetterSetterKeywordBlockContext.class,0);
8919 		}
8920 		public ProtocolPropertyDeclarationContext(ParserRuleContext parent, int invokingState) {
8921 			super(parent, invokingState);
8922 		}
8923 		@Override public int getRuleIndex() { return RULE_protocolPropertyDeclaration; }
8924 		@Override
8925 		public void enterRule(ParseTreeListener listener) {
8926 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolPropertyDeclaration(this);
8927 		}
8928 		@Override
8929 		public void exitRule(ParseTreeListener listener) {
8930 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolPropertyDeclaration(this);
8931 		}
8932 	}
8933 
8934 	public final ProtocolPropertyDeclarationContext protocolPropertyDeclaration() throws RecognitionException {
8935 		ProtocolPropertyDeclarationContext _localctx = new ProtocolPropertyDeclarationContext(_ctx, getState());
8936 		enterRule(_localctx, 264, RULE_protocolPropertyDeclaration);
8937 		try {
8938 			enterOuterAlt(_localctx, 1);
8939 			{
8940 			setState(1558);
8941 			variableDeclarationHead();
8942 			setState(1559);
8943 			variableName();
8944 			setState(1560);
8945 			typeAnnotation();
8946 			setState(1561);
8947 			getterSetterKeywordBlock();
8948 			}
8949 		}
8950 		catch (RecognitionException re) {
8951 			_localctx.exception = re;
8952 			_errHandler.reportError(this, re);
8953 			_errHandler.recover(this, re);
8954 		}
8955 		finally {
8956 			exitRule();
8957 		}
8958 		return _localctx;
8959 	}
8960 
8961 	public static class ProtocolMethodDeclarationContext extends ParserRuleContext {
8962 		public FunctionHeadContext functionHead() {
8963 			return getRuleContext(FunctionHeadContext.class,0);
8964 		}
8965 		public FunctionNameContext functionName() {
8966 			return getRuleContext(FunctionNameContext.class,0);
8967 		}
8968 		public FunctionSignatureContext functionSignature() {
8969 			return getRuleContext(FunctionSignatureContext.class,0);
8970 		}
8971 		public GenericParameterClauseContext genericParameterClause() {
8972 			return getRuleContext(GenericParameterClauseContext.class,0);
8973 		}
8974 		public ProtocolMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
8975 			super(parent, invokingState);
8976 		}
8977 		@Override public int getRuleIndex() { return RULE_protocolMethodDeclaration; }
8978 		@Override
8979 		public void enterRule(ParseTreeListener listener) {
8980 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolMethodDeclaration(this);
8981 		}
8982 		@Override
8983 		public void exitRule(ParseTreeListener listener) {
8984 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolMethodDeclaration(this);
8985 		}
8986 	}
8987 
8988 	public final ProtocolMethodDeclarationContext protocolMethodDeclaration() throws RecognitionException {
8989 		ProtocolMethodDeclarationContext _localctx = new ProtocolMethodDeclarationContext(_ctx, getState());
8990 		enterRule(_localctx, 266, RULE_protocolMethodDeclaration);
8991 		int _la;
8992 		try {
8993 			enterOuterAlt(_localctx, 1);
8994 			{
8995 			setState(1563);
8996 			functionHead();
8997 			setState(1564);
8998 			functionName();
8999 			setState(1566);
9000 			_la = _input.LA(1);
9001 			if (_la==T__38) {
9002 				{
9003 				setState(1565);
9004 				genericParameterClause();
9005 				}
9006 			}
9007 
9008 			setState(1568);
9009 			functionSignature();
9010 			}
9011 		}
9012 		catch (RecognitionException re) {
9013 			_localctx.exception = re;
9014 			_errHandler.reportError(this, re);
9015 			_errHandler.recover(this, re);
9016 		}
9017 		finally {
9018 			exitRule();
9019 		}
9020 		return _localctx;
9021 	}
9022 
9023 	public static class ProtocolInitializerDeclarationContext extends ParserRuleContext {
9024 		public InitializerHeadContext initializerHead() {
9025 			return getRuleContext(InitializerHeadContext.class,0);
9026 		}
9027 		public ParameterClauseContext parameterClause() {
9028 			return getRuleContext(ParameterClauseContext.class,0);
9029 		}
9030 		public GenericParameterClauseContext genericParameterClause() {
9031 			return getRuleContext(GenericParameterClauseContext.class,0);
9032 		}
9033 		public ProtocolInitializerDeclarationContext(ParserRuleContext parent, int invokingState) {
9034 			super(parent, invokingState);
9035 		}
9036 		@Override public int getRuleIndex() { return RULE_protocolInitializerDeclaration; }
9037 		@Override
9038 		public void enterRule(ParseTreeListener listener) {
9039 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolInitializerDeclaration(this);
9040 		}
9041 		@Override
9042 		public void exitRule(ParseTreeListener listener) {
9043 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolInitializerDeclaration(this);
9044 		}
9045 	}
9046 
9047 	public final ProtocolInitializerDeclarationContext protocolInitializerDeclaration() throws RecognitionException {
9048 		ProtocolInitializerDeclarationContext _localctx = new ProtocolInitializerDeclarationContext(_ctx, getState());
9049 		enterRule(_localctx, 268, RULE_protocolInitializerDeclaration);
9050 		int _la;
9051 		try {
9052 			enterOuterAlt(_localctx, 1);
9053 			{
9054 			setState(1570);
9055 			initializerHead();
9056 			setState(1572);
9057 			_la = _input.LA(1);
9058 			if (_la==T__38) {
9059 				{
9060 				setState(1571);
9061 				genericParameterClause();
9062 				}
9063 			}
9064 
9065 			setState(1574);
9066 			parameterClause();
9067 			setState(1576);
9068 			_la = _input.LA(1);
9069 			if (_la==T__74 || _la==T__75) {
9070 				{
9071 				setState(1575);
9072 				_la = _input.LA(1);
9073 				if ( !(_la==T__74 || _la==T__75) ) {
9074 				_errHandler.recoverInline(this);
9075 				} else {
9076 					consume();
9077 				}
9078 				}
9079 			}
9080 
9081 			}
9082 		}
9083 		catch (RecognitionException re) {
9084 			_localctx.exception = re;
9085 			_errHandler.reportError(this, re);
9086 			_errHandler.recover(this, re);
9087 		}
9088 		finally {
9089 			exitRule();
9090 		}
9091 		return _localctx;
9092 	}
9093 
9094 	public static class ProtocolSubscriptDeclarationContext extends ParserRuleContext {
9095 		public SubscriptHeadContext subscriptHead() {
9096 			return getRuleContext(SubscriptHeadContext.class,0);
9097 		}
9098 		public SubscriptResultContext subscriptResult() {
9099 			return getRuleContext(SubscriptResultContext.class,0);
9100 		}
9101 		public GetterSetterKeywordBlockContext getterSetterKeywordBlock() {
9102 			return getRuleContext(GetterSetterKeywordBlockContext.class,0);
9103 		}
9104 		public ProtocolSubscriptDeclarationContext(ParserRuleContext parent, int invokingState) {
9105 			super(parent, invokingState);
9106 		}
9107 		@Override public int getRuleIndex() { return RULE_protocolSubscriptDeclaration; }
9108 		@Override
9109 		public void enterRule(ParseTreeListener listener) {
9110 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolSubscriptDeclaration(this);
9111 		}
9112 		@Override
9113 		public void exitRule(ParseTreeListener listener) {
9114 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolSubscriptDeclaration(this);
9115 		}
9116 	}
9117 
9118 	public final ProtocolSubscriptDeclarationContext protocolSubscriptDeclaration() throws RecognitionException {
9119 		ProtocolSubscriptDeclarationContext _localctx = new ProtocolSubscriptDeclarationContext(_ctx, getState());
9120 		enterRule(_localctx, 270, RULE_protocolSubscriptDeclaration);
9121 		try {
9122 			enterOuterAlt(_localctx, 1);
9123 			{
9124 			setState(1578);
9125 			subscriptHead();
9126 			setState(1579);
9127 			subscriptResult();
9128 			setState(1580);
9129 			getterSetterKeywordBlock();
9130 			}
9131 		}
9132 		catch (RecognitionException re) {
9133 			_localctx.exception = re;
9134 			_errHandler.reportError(this, re);
9135 			_errHandler.recover(this, re);
9136 		}
9137 		finally {
9138 			exitRule();
9139 		}
9140 		return _localctx;
9141 	}
9142 
9143 	public static class ProtocolAssociatedTypeDeclarationContext extends ParserRuleContext {
9144 		public TypealiasHeadContext typealiasHead() {
9145 			return getRuleContext(TypealiasHeadContext.class,0);
9146 		}
9147 		public TypeInheritanceClauseContext typeInheritanceClause() {
9148 			return getRuleContext(TypeInheritanceClauseContext.class,0);
9149 		}
9150 		public TypealiasAssignmentContext typealiasAssignment() {
9151 			return getRuleContext(TypealiasAssignmentContext.class,0);
9152 		}
9153 		public ProtocolAssociatedTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
9154 			super(parent, invokingState);
9155 		}
9156 		@Override public int getRuleIndex() { return RULE_protocolAssociatedTypeDeclaration; }
9157 		@Override
9158 		public void enterRule(ParseTreeListener listener) {
9159 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolAssociatedTypeDeclaration(this);
9160 		}
9161 		@Override
9162 		public void exitRule(ParseTreeListener listener) {
9163 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolAssociatedTypeDeclaration(this);
9164 		}
9165 	}
9166 
9167 	public final ProtocolAssociatedTypeDeclarationContext protocolAssociatedTypeDeclaration() throws RecognitionException {
9168 		ProtocolAssociatedTypeDeclarationContext _localctx = new ProtocolAssociatedTypeDeclarationContext(_ctx, getState());
9169 		enterRule(_localctx, 272, RULE_protocolAssociatedTypeDeclaration);
9170 		int _la;
9171 		try {
9172 			enterOuterAlt(_localctx, 1);
9173 			{
9174 			setState(1582);
9175 			typealiasHead();
9176 			setState(1584);
9177 			_la = _input.LA(1);
9178 			if (_la==T__1) {
9179 				{
9180 				setState(1583);
9181 				typeInheritanceClause();
9182 				}
9183 			}
9184 
9185 			setState(1587);
9186 			_la = _input.LA(1);
9187 			if (_la==T__70) {
9188 				{
9189 				setState(1586);
9190 				typealiasAssignment();
9191 				}
9192 			}
9193 
9194 			}
9195 		}
9196 		catch (RecognitionException re) {
9197 			_localctx.exception = re;
9198 			_errHandler.reportError(this, re);
9199 			_errHandler.recover(this, re);
9200 		}
9201 		finally {
9202 			exitRule();
9203 		}
9204 		return _localctx;
9205 	}
9206 
9207 	public static class InitializerDeclarationContext extends ParserRuleContext {
9208 		public InitializerHeadContext initializerHead() {
9209 			return getRuleContext(InitializerHeadContext.class,0);
9210 		}
9211 		public ParameterClauseContext parameterClause() {
9212 			return getRuleContext(ParameterClauseContext.class,0);
9213 		}
9214 		public InitializerBodyContext initializerBody() {
9215 			return getRuleContext(InitializerBodyContext.class,0);
9216 		}
9217 		public GenericParameterClauseContext genericParameterClause() {
9218 			return getRuleContext(GenericParameterClauseContext.class,0);
9219 		}
9220 		public InitializerDeclarationContext(ParserRuleContext parent, int invokingState) {
9221 			super(parent, invokingState);
9222 		}
9223 		@Override public int getRuleIndex() { return RULE_initializerDeclaration; }
9224 		@Override
9225 		public void enterRule(ParseTreeListener listener) {
9226 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInitializerDeclaration(this);
9227 		}
9228 		@Override
9229 		public void exitRule(ParseTreeListener listener) {
9230 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInitializerDeclaration(this);
9231 		}
9232 	}
9233 
9234 	public final InitializerDeclarationContext initializerDeclaration() throws RecognitionException {
9235 		InitializerDeclarationContext _localctx = new InitializerDeclarationContext(_ctx, getState());
9236 		enterRule(_localctx, 274, RULE_initializerDeclaration);
9237 		int _la;
9238 		try {
9239 			enterOuterAlt(_localctx, 1);
9240 			{
9241 			setState(1589);
9242 			initializerHead();
9243 			setState(1591);
9244 			_la = _input.LA(1);
9245 			if (_la==T__38) {
9246 				{
9247 				setState(1590);
9248 				genericParameterClause();
9249 				}
9250 			}
9251 
9252 			setState(1593);
9253 			parameterClause();
9254 			setState(1595);
9255 			_la = _input.LA(1);
9256 			if (_la==T__74 || _la==T__75) {
9257 				{
9258 				setState(1594);
9259 				_la = _input.LA(1);
9260 				if ( !(_la==T__74 || _la==T__75) ) {
9261 				_errHandler.recoverInline(this);
9262 				} else {
9263 					consume();
9264 				}
9265 				}
9266 			}
9267 
9268 			setState(1597);
9269 			initializerBody();
9270 			}
9271 		}
9272 		catch (RecognitionException re) {
9273 			_localctx.exception = re;
9274 			_errHandler.reportError(this, re);
9275 			_errHandler.recover(this, re);
9276 		}
9277 		finally {
9278 			exitRule();
9279 		}
9280 		return _localctx;
9281 	}
9282 
9283 	public static class InitializerHeadContext extends ParserRuleContext {
9284 		public AttributesContext attributes() {
9285 			return getRuleContext(AttributesContext.class,0);
9286 		}
9287 		public DeclarationModifiersContext declarationModifiers() {
9288 			return getRuleContext(DeclarationModifiersContext.class,0);
9289 		}
9290 		public InitializerHeadContext(ParserRuleContext parent, int invokingState) {
9291 			super(parent, invokingState);
9292 		}
9293 		@Override public int getRuleIndex() { return RULE_initializerHead; }
9294 		@Override
9295 		public void enterRule(ParseTreeListener listener) {
9296 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInitializerHead(this);
9297 		}
9298 		@Override
9299 		public void exitRule(ParseTreeListener listener) {
9300 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInitializerHead(this);
9301 		}
9302 	}
9303 
9304 	public final InitializerHeadContext initializerHead() throws RecognitionException {
9305 		InitializerHeadContext _localctx = new InitializerHeadContext(_ctx, getState());
9306 		enterRule(_localctx, 276, RULE_initializerHead);
9307 		int _la;
9308 		try {
9309 			enterOuterAlt(_localctx, 1);
9310 			{
9311 			setState(1600);
9312 			_la = _input.LA(1);
9313 			if (_la==T__96) {
9314 				{
9315 				setState(1599);
9316 				attributes();
9317 				}
9318 			}
9319 
9320 			setState(1603);
9321 			_la = _input.LA(1);
9322 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
9323 				{
9324 				setState(1602);
9325 				declarationModifiers();
9326 				}
9327 			}
9328 
9329 			setState(1605);
9330 			match(T__82);
9331 			setState(1607);
9332 			_la = _input.LA(1);
9333 			if (_la==T__83 || _la==T__84) {
9334 				{
9335 				setState(1606);
9336 				_la = _input.LA(1);
9337 				if ( !(_la==T__83 || _la==T__84) ) {
9338 				_errHandler.recoverInline(this);
9339 				} else {
9340 					consume();
9341 				}
9342 				}
9343 			}
9344 
9345 			}
9346 		}
9347 		catch (RecognitionException re) {
9348 			_localctx.exception = re;
9349 			_errHandler.reportError(this, re);
9350 			_errHandler.recover(this, re);
9351 		}
9352 		finally {
9353 			exitRule();
9354 		}
9355 		return _localctx;
9356 	}
9357 
9358 	public static class InitializerBodyContext extends ParserRuleContext {
9359 		public CodeBlockContext codeBlock() {
9360 			return getRuleContext(CodeBlockContext.class,0);
9361 		}
9362 		public InitializerBodyContext(ParserRuleContext parent, int invokingState) {
9363 			super(parent, invokingState);
9364 		}
9365 		@Override public int getRuleIndex() { return RULE_initializerBody; }
9366 		@Override
9367 		public void enterRule(ParseTreeListener listener) {
9368 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInitializerBody(this);
9369 		}
9370 		@Override
9371 		public void exitRule(ParseTreeListener listener) {
9372 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInitializerBody(this);
9373 		}
9374 	}
9375 
9376 	public final InitializerBodyContext initializerBody() throws RecognitionException {
9377 		InitializerBodyContext _localctx = new InitializerBodyContext(_ctx, getState());
9378 		enterRule(_localctx, 278, RULE_initializerBody);
9379 		try {
9380 			enterOuterAlt(_localctx, 1);
9381 			{
9382 			setState(1609);
9383 			codeBlock();
9384 			}
9385 		}
9386 		catch (RecognitionException re) {
9387 			_localctx.exception = re;
9388 			_errHandler.reportError(this, re);
9389 			_errHandler.recover(this, re);
9390 		}
9391 		finally {
9392 			exitRule();
9393 		}
9394 		return _localctx;
9395 	}
9396 
9397 	public static class DeinitializerDeclarationContext extends ParserRuleContext {
9398 		public CodeBlockContext codeBlock() {
9399 			return getRuleContext(CodeBlockContext.class,0);
9400 		}
9401 		public AttributesContext attributes() {
9402 			return getRuleContext(AttributesContext.class,0);
9403 		}
9404 		public DeinitializerDeclarationContext(ParserRuleContext parent, int invokingState) {
9405 			super(parent, invokingState);
9406 		}
9407 		@Override public int getRuleIndex() { return RULE_deinitializerDeclaration; }
9408 		@Override
9409 		public void enterRule(ParseTreeListener listener) {
9410 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDeinitializerDeclaration(this);
9411 		}
9412 		@Override
9413 		public void exitRule(ParseTreeListener listener) {
9414 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDeinitializerDeclaration(this);
9415 		}
9416 	}
9417 
9418 	public final DeinitializerDeclarationContext deinitializerDeclaration() throws RecognitionException {
9419 		DeinitializerDeclarationContext _localctx = new DeinitializerDeclarationContext(_ctx, getState());
9420 		enterRule(_localctx, 280, RULE_deinitializerDeclaration);
9421 		int _la;
9422 		try {
9423 			enterOuterAlt(_localctx, 1);
9424 			{
9425 			setState(1612);
9426 			_la = _input.LA(1);
9427 			if (_la==T__96) {
9428 				{
9429 				setState(1611);
9430 				attributes();
9431 				}
9432 			}
9433 
9434 			setState(1614);
9435 			match(T__85);
9436 			setState(1615);
9437 			codeBlock();
9438 			}
9439 		}
9440 		catch (RecognitionException re) {
9441 			_localctx.exception = re;
9442 			_errHandler.reportError(this, re);
9443 			_errHandler.recover(this, re);
9444 		}
9445 		finally {
9446 			exitRule();
9447 		}
9448 		return _localctx;
9449 	}
9450 
9451 	public static class ExtensionDeclarationContext extends ParserRuleContext {
9452 		public TypeIdentifierContext typeIdentifier() {
9453 			return getRuleContext(TypeIdentifierContext.class,0);
9454 		}
9455 		public ExtensionBodyContext extensionBody() {
9456 			return getRuleContext(ExtensionBodyContext.class,0);
9457 		}
9458 		public AttributesContext attributes() {
9459 			return getRuleContext(AttributesContext.class,0);
9460 		}
9461 		public AccessLevelModifierContext accessLevelModifier() {
9462 			return getRuleContext(AccessLevelModifierContext.class,0);
9463 		}
9464 		public RequirementClauseContext requirementClause() {
9465 			return getRuleContext(RequirementClauseContext.class,0);
9466 		}
9467 		public TypeInheritanceClauseContext typeInheritanceClause() {
9468 			return getRuleContext(TypeInheritanceClauseContext.class,0);
9469 		}
9470 		public ExtensionDeclarationContext(ParserRuleContext parent, int invokingState) {
9471 			super(parent, invokingState);
9472 		}
9473 		@Override public int getRuleIndex() { return RULE_extensionDeclaration; }
9474 		@Override
9475 		public void enterRule(ParseTreeListener listener) {
9476 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExtensionDeclaration(this);
9477 		}
9478 		@Override
9479 		public void exitRule(ParseTreeListener listener) {
9480 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExtensionDeclaration(this);
9481 		}
9482 	}
9483 
9484 	public final ExtensionDeclarationContext extensionDeclaration() throws RecognitionException {
9485 		ExtensionDeclarationContext _localctx = new ExtensionDeclarationContext(_ctx, getState());
9486 		enterRule(_localctx, 282, RULE_extensionDeclaration);
9487 		int _la;
9488 		try {
9489 			enterOuterAlt(_localctx, 1);
9490 			{
9491 			setState(1618);
9492 			_la = _input.LA(1);
9493 			if (_la==T__96) {
9494 				{
9495 				setState(1617);
9496 				attributes();
9497 				}
9498 			}
9499 
9500 			setState(1621);
9501 			_la = _input.LA(1);
9502 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
9503 				{
9504 				setState(1620);
9505 				accessLevelModifier();
9506 				}
9507 			}
9508 
9509 			setState(1623);
9510 			match(T__86);
9511 			setState(1624);
9512 			typeIdentifier();
9513 			setState(1626);
9514 			_la = _input.LA(1);
9515 			if (_la==T__27) {
9516 				{
9517 				setState(1625);
9518 				requirementClause();
9519 				}
9520 			}
9521 
9522 			setState(1629);
9523 			_la = _input.LA(1);
9524 			if (_la==T__1) {
9525 				{
9526 				setState(1628);
9527 				typeInheritanceClause();
9528 				}
9529 			}
9530 
9531 			setState(1631);
9532 			extensionBody();
9533 			}
9534 		}
9535 		catch (RecognitionException re) {
9536 			_localctx.exception = re;
9537 			_errHandler.reportError(this, re);
9538 			_errHandler.recover(this, re);
9539 		}
9540 		finally {
9541 			exitRule();
9542 		}
9543 		return _localctx;
9544 	}
9545 
9546 	public static class ExtensionBodyContext extends ParserRuleContext {
9547 		public DeclarationsContext declarations() {
9548 			return getRuleContext(DeclarationsContext.class,0);
9549 		}
9550 		public ExtensionBodyContext(ParserRuleContext parent, int invokingState) {
9551 			super(parent, invokingState);
9552 		}
9553 		@Override public int getRuleIndex() { return RULE_extensionBody; }
9554 		@Override
9555 		public void enterRule(ParseTreeListener listener) {
9556 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExtensionBody(this);
9557 		}
9558 		@Override
9559 		public void exitRule(ParseTreeListener listener) {
9560 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExtensionBody(this);
9561 		}
9562 	}
9563 
9564 	public final ExtensionBodyContext extensionBody() throws RecognitionException {
9565 		ExtensionBodyContext _localctx = new ExtensionBodyContext(_ctx, getState());
9566 		enterRule(_localctx, 284, RULE_extensionBody);
9567 		int _la;
9568 		try {
9569 			enterOuterAlt(_localctx, 1);
9570 			{
9571 			setState(1633);
9572 			match(T__13);
9573 			setState(1635);
9574 			_la = _input.LA(1);
9575 			if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (T__25 - 26)) | (1L << (T__26 - 26)) | (1L << (T__41 - 26)) | (1L << (T__42 - 26)) | (1L << (T__43 - 26)) | (1L << (T__44 - 26)) | (1L << (T__45 - 26)) | (1L << (T__46 - 26)) | (1L << (T__47 - 26)) | (1L << (T__48 - 26)) | (1L << (T__49 - 26)) | (1L << (T__50 - 26)) | (1L << (T__51 - 26)) | (1L << (T__52 - 26)) | (1L << (T__53 - 26)) | (1L << (T__54 - 26)) | (1L << (T__55 - 26)) | (1L << (T__58 - 26)) | (1L << (T__59 - 26)) | (1L << (T__61 - 26)) | (1L << (T__62 - 26)) | (1L << (T__63 - 26)) | (1L << (T__64 - 26)) | (1L << (T__65 - 26)) | (1L << (T__66 - 26)) | (1L << (T__67 - 26)) | (1L << (T__68 - 26)) | (1L << (T__81 - 26)) | (1L << (T__82 - 26)) | (1L << (T__85 - 26)) | (1L << (T__86 - 26)) | (1L << (T__87 - 26)))) != 0) || ((((_la - 97)) & ~0x3f) == 0 && ((1L << (_la - 97)) & ((1L << (T__96 - 97)) | (1L << (T__119 - 97)) | (1L << (T__129 - 97)))) != 0)) {
9576 				{
9577 				setState(1634);
9578 				declarations();
9579 				}
9580 			}
9581 
9582 			setState(1637);
9583 			match(T__14);
9584 			}
9585 		}
9586 		catch (RecognitionException re) {
9587 			_localctx.exception = re;
9588 			_errHandler.reportError(this, re);
9589 			_errHandler.recover(this, re);
9590 		}
9591 		finally {
9592 			exitRule();
9593 		}
9594 		return _localctx;
9595 	}
9596 
9597 	public static class SubscriptDeclarationContext extends ParserRuleContext {
9598 		public SubscriptHeadContext subscriptHead() {
9599 			return getRuleContext(SubscriptHeadContext.class,0);
9600 		}
9601 		public SubscriptResultContext subscriptResult() {
9602 			return getRuleContext(SubscriptResultContext.class,0);
9603 		}
9604 		public GetterSetterBlockContext getterSetterBlock() {
9605 			return getRuleContext(GetterSetterBlockContext.class,0);
9606 		}
9607 		public GetterSetterKeywordBlockContext getterSetterKeywordBlock() {
9608 			return getRuleContext(GetterSetterKeywordBlockContext.class,0);
9609 		}
9610 		public CodeBlockContext codeBlock() {
9611 			return getRuleContext(CodeBlockContext.class,0);
9612 		}
9613 		public SubscriptDeclarationContext(ParserRuleContext parent, int invokingState) {
9614 			super(parent, invokingState);
9615 		}
9616 		@Override public int getRuleIndex() { return RULE_subscriptDeclaration; }
9617 		@Override
9618 		public void enterRule(ParseTreeListener listener) {
9619 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSubscriptDeclaration(this);
9620 		}
9621 		@Override
9622 		public void exitRule(ParseTreeListener listener) {
9623 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSubscriptDeclaration(this);
9624 		}
9625 	}
9626 
9627 	public final SubscriptDeclarationContext subscriptDeclaration() throws RecognitionException {
9628 		SubscriptDeclarationContext _localctx = new SubscriptDeclarationContext(_ctx, getState());
9629 		enterRule(_localctx, 286, RULE_subscriptDeclaration);
9630 		try {
9631 			setState(1651);
9632 			_errHandler.sync(this);
9633 			switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
9634 			case 1:
9635 				enterOuterAlt(_localctx, 1);
9636 				{
9637 				setState(1639);
9638 				subscriptHead();
9639 				setState(1640);
9640 				subscriptResult();
9641 				setState(1641);
9642 				getterSetterBlock();
9643 				}
9644 				break;
9645 			case 2:
9646 				enterOuterAlt(_localctx, 2);
9647 				{
9648 				setState(1643);
9649 				subscriptHead();
9650 				setState(1644);
9651 				subscriptResult();
9652 				setState(1645);
9653 				getterSetterKeywordBlock();
9654 				}
9655 				break;
9656 			case 3:
9657 				enterOuterAlt(_localctx, 3);
9658 				{
9659 				setState(1647);
9660 				subscriptHead();
9661 				setState(1648);
9662 				subscriptResult();
9663 				setState(1649);
9664 				codeBlock();
9665 				}
9666 				break;
9667 			}
9668 		}
9669 		catch (RecognitionException re) {
9670 			_localctx.exception = re;
9671 			_errHandler.reportError(this, re);
9672 			_errHandler.recover(this, re);
9673 		}
9674 		finally {
9675 			exitRule();
9676 		}
9677 		return _localctx;
9678 	}
9679 
9680 	public static class SubscriptHeadContext extends ParserRuleContext {
9681 		public ParameterClauseContext parameterClause() {
9682 			return getRuleContext(ParameterClauseContext.class,0);
9683 		}
9684 		public AttributesContext attributes() {
9685 			return getRuleContext(AttributesContext.class,0);
9686 		}
9687 		public DeclarationModifiersContext declarationModifiers() {
9688 			return getRuleContext(DeclarationModifiersContext.class,0);
9689 		}
9690 		public SubscriptHeadContext(ParserRuleContext parent, int invokingState) {
9691 			super(parent, invokingState);
9692 		}
9693 		@Override public int getRuleIndex() { return RULE_subscriptHead; }
9694 		@Override
9695 		public void enterRule(ParseTreeListener listener) {
9696 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSubscriptHead(this);
9697 		}
9698 		@Override
9699 		public void exitRule(ParseTreeListener listener) {
9700 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSubscriptHead(this);
9701 		}
9702 	}
9703 
9704 	public final SubscriptHeadContext subscriptHead() throws RecognitionException {
9705 		SubscriptHeadContext _localctx = new SubscriptHeadContext(_ctx, getState());
9706 		enterRule(_localctx, 288, RULE_subscriptHead);
9707 		int _la;
9708 		try {
9709 			enterOuterAlt(_localctx, 1);
9710 			{
9711 			setState(1654);
9712 			_la = _input.LA(1);
9713 			if (_la==T__96) {
9714 				{
9715 				setState(1653);
9716 				attributes();
9717 				}
9718 			}
9719 
9720 			setState(1657);
9721 			_la = _input.LA(1);
9722 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__61) | (1L << T__62))) != 0)) {
9723 				{
9724 				setState(1656);
9725 				declarationModifiers();
9726 				}
9727 			}
9728 
9729 			setState(1659);
9730 			match(T__87);
9731 			setState(1660);
9732 			parameterClause();
9733 			}
9734 		}
9735 		catch (RecognitionException re) {
9736 			_localctx.exception = re;
9737 			_errHandler.reportError(this, re);
9738 			_errHandler.recover(this, re);
9739 		}
9740 		finally {
9741 			exitRule();
9742 		}
9743 		return _localctx;
9744 	}
9745 
9746 	public static class SubscriptResultContext extends ParserRuleContext {
9747 		public STypeContext sType() {
9748 			return getRuleContext(STypeContext.class,0);
9749 		}
9750 		public AttributesContext attributes() {
9751 			return getRuleContext(AttributesContext.class,0);
9752 		}
9753 		public SubscriptResultContext(ParserRuleContext parent, int invokingState) {
9754 			super(parent, invokingState);
9755 		}
9756 		@Override public int getRuleIndex() { return RULE_subscriptResult; }
9757 		@Override
9758 		public void enterRule(ParseTreeListener listener) {
9759 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSubscriptResult(this);
9760 		}
9761 		@Override
9762 		public void exitRule(ParseTreeListener listener) {
9763 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSubscriptResult(this);
9764 		}
9765 	}
9766 
9767 	public final SubscriptResultContext subscriptResult() throws RecognitionException {
9768 		SubscriptResultContext _localctx = new SubscriptResultContext(_ctx, getState());
9769 		enterRule(_localctx, 290, RULE_subscriptResult);
9770 		int _la;
9771 		try {
9772 			enterOuterAlt(_localctx, 1);
9773 			{
9774 			setState(1662);
9775 			match(T__76);
9776 			setState(1664);
9777 			_la = _input.LA(1);
9778 			if (_la==T__96) {
9779 				{
9780 				setState(1663);
9781 				attributes();
9782 				}
9783 			}
9784 
9785 			setState(1666);
9786 			sType(0);
9787 			}
9788 		}
9789 		catch (RecognitionException re) {
9790 			_localctx.exception = re;
9791 			_errHandler.reportError(this, re);
9792 			_errHandler.recover(this, re);
9793 		}
9794 		finally {
9795 			exitRule();
9796 		}
9797 		return _localctx;
9798 	}
9799 
9800 	public static class OperatorDeclarationContext extends ParserRuleContext {
9801 		public PrefixOperatorDeclarationContext prefixOperatorDeclaration() {
9802 			return getRuleContext(PrefixOperatorDeclarationContext.class,0);
9803 		}
9804 		public PostfixOperatorDeclarationContext postfixOperatorDeclaration() {
9805 			return getRuleContext(PostfixOperatorDeclarationContext.class,0);
9806 		}
9807 		public InfixOperatorDeclarationContext infixOperatorDeclaration() {
9808 			return getRuleContext(InfixOperatorDeclarationContext.class,0);
9809 		}
9810 		public OperatorDeclarationContext(ParserRuleContext parent, int invokingState) {
9811 			super(parent, invokingState);
9812 		}
9813 		@Override public int getRuleIndex() { return RULE_operatorDeclaration; }
9814 		@Override
9815 		public void enterRule(ParseTreeListener listener) {
9816 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOperatorDeclaration(this);
9817 		}
9818 		@Override
9819 		public void exitRule(ParseTreeListener listener) {
9820 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOperatorDeclaration(this);
9821 		}
9822 	}
9823 
9824 	public final OperatorDeclarationContext operatorDeclaration() throws RecognitionException {
9825 		OperatorDeclarationContext _localctx = new OperatorDeclarationContext(_ctx, getState());
9826 		enterRule(_localctx, 292, RULE_operatorDeclaration);
9827 		try {
9828 			setState(1671);
9829 			switch (_input.LA(1)) {
9830 			case T__52:
9831 				enterOuterAlt(_localctx, 1);
9832 				{
9833 				setState(1668);
9834 				prefixOperatorDeclaration();
9835 				}
9836 				break;
9837 			case T__51:
9838 				enterOuterAlt(_localctx, 2);
9839 				{
9840 				setState(1669);
9841 				postfixOperatorDeclaration();
9842 				}
9843 				break;
9844 			case T__45:
9845 				enterOuterAlt(_localctx, 3);
9846 				{
9847 				setState(1670);
9848 				infixOperatorDeclaration();
9849 				}
9850 				break;
9851 			default:
9852 				throw new NoViableAltException(this);
9853 			}
9854 		}
9855 		catch (RecognitionException re) {
9856 			_localctx.exception = re;
9857 			_errHandler.reportError(this, re);
9858 			_errHandler.recover(this, re);
9859 		}
9860 		finally {
9861 			exitRule();
9862 		}
9863 		return _localctx;
9864 	}
9865 
9866 	public static class PrefixOperatorDeclarationContext extends ParserRuleContext {
9867 		public OperatorContext operator() {
9868 			return getRuleContext(OperatorContext.class,0);
9869 		}
9870 		public PrefixOperatorDeclarationContext(ParserRuleContext parent, int invokingState) {
9871 			super(parent, invokingState);
9872 		}
9873 		@Override public int getRuleIndex() { return RULE_prefixOperatorDeclaration; }
9874 		@Override
9875 		public void enterRule(ParseTreeListener listener) {
9876 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrefixOperatorDeclaration(this);
9877 		}
9878 		@Override
9879 		public void exitRule(ParseTreeListener listener) {
9880 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrefixOperatorDeclaration(this);
9881 		}
9882 	}
9883 
9884 	public final PrefixOperatorDeclarationContext prefixOperatorDeclaration() throws RecognitionException {
9885 		PrefixOperatorDeclarationContext _localctx = new PrefixOperatorDeclarationContext(_ctx, getState());
9886 		enterRule(_localctx, 294, RULE_prefixOperatorDeclaration);
9887 		try {
9888 			enterOuterAlt(_localctx, 1);
9889 			{
9890 			setState(1673);
9891 			match(T__52);
9892 			setState(1674);
9893 			match(T__88);
9894 			setState(1675);
9895 			operator();
9896 			setState(1676);
9897 			match(T__13);
9898 			setState(1677);
9899 			match(T__14);
9900 			}
9901 		}
9902 		catch (RecognitionException re) {
9903 			_localctx.exception = re;
9904 			_errHandler.reportError(this, re);
9905 			_errHandler.recover(this, re);
9906 		}
9907 		finally {
9908 			exitRule();
9909 		}
9910 		return _localctx;
9911 	}
9912 
9913 	public static class PostfixOperatorDeclarationContext extends ParserRuleContext {
9914 		public OperatorContext operator() {
9915 			return getRuleContext(OperatorContext.class,0);
9916 		}
9917 		public PostfixOperatorDeclarationContext(ParserRuleContext parent, int invokingState) {
9918 			super(parent, invokingState);
9919 		}
9920 		@Override public int getRuleIndex() { return RULE_postfixOperatorDeclaration; }
9921 		@Override
9922 		public void enterRule(ParseTreeListener listener) {
9923 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPostfixOperatorDeclaration(this);
9924 		}
9925 		@Override
9926 		public void exitRule(ParseTreeListener listener) {
9927 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPostfixOperatorDeclaration(this);
9928 		}
9929 	}
9930 
9931 	public final PostfixOperatorDeclarationContext postfixOperatorDeclaration() throws RecognitionException {
9932 		PostfixOperatorDeclarationContext _localctx = new PostfixOperatorDeclarationContext(_ctx, getState());
9933 		enterRule(_localctx, 296, RULE_postfixOperatorDeclaration);
9934 		try {
9935 			enterOuterAlt(_localctx, 1);
9936 			{
9937 			setState(1679);
9938 			match(T__51);
9939 			setState(1680);
9940 			match(T__88);
9941 			setState(1681);
9942 			operator();
9943 			setState(1682);
9944 			match(T__13);
9945 			setState(1683);
9946 			match(T__14);
9947 			}
9948 		}
9949 		catch (RecognitionException re) {
9950 			_localctx.exception = re;
9951 			_errHandler.reportError(this, re);
9952 			_errHandler.recover(this, re);
9953 		}
9954 		finally {
9955 			exitRule();
9956 		}
9957 		return _localctx;
9958 	}
9959 
9960 	public static class InfixOperatorDeclarationContext extends ParserRuleContext {
9961 		public OperatorContext operator() {
9962 			return getRuleContext(OperatorContext.class,0);
9963 		}
9964 		public InfixOperatorAttributesContext infixOperatorAttributes() {
9965 			return getRuleContext(InfixOperatorAttributesContext.class,0);
9966 		}
9967 		public InfixOperatorDeclarationContext(ParserRuleContext parent, int invokingState) {
9968 			super(parent, invokingState);
9969 		}
9970 		@Override public int getRuleIndex() { return RULE_infixOperatorDeclaration; }
9971 		@Override
9972 		public void enterRule(ParseTreeListener listener) {
9973 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInfixOperatorDeclaration(this);
9974 		}
9975 		@Override
9976 		public void exitRule(ParseTreeListener listener) {
9977 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInfixOperatorDeclaration(this);
9978 		}
9979 	}
9980 
9981 	public final InfixOperatorDeclarationContext infixOperatorDeclaration() throws RecognitionException {
9982 		InfixOperatorDeclarationContext _localctx = new InfixOperatorDeclarationContext(_ctx, getState());
9983 		enterRule(_localctx, 298, RULE_infixOperatorDeclaration);
9984 		try {
9985 			enterOuterAlt(_localctx, 1);
9986 			{
9987 			setState(1685);
9988 			match(T__45);
9989 			setState(1686);
9990 			match(T__88);
9991 			setState(1687);
9992 			operator();
9993 			setState(1688);
9994 			match(T__13);
9995 			setState(1689);
9996 			infixOperatorAttributes();
9997 			setState(1690);
9998 			match(T__14);
9999 			}
10000 		}
10001 		catch (RecognitionException re) {
10002 			_localctx.exception = re;
10003 			_errHandler.reportError(this, re);
10004 			_errHandler.recover(this, re);
10005 		}
10006 		finally {
10007 			exitRule();
10008 		}
10009 		return _localctx;
10010 	}
10011 
10012 	public static class InfixOperatorAttributesContext extends ParserRuleContext {
10013 		public PrecedenceClauseContext precedenceClause() {
10014 			return getRuleContext(PrecedenceClauseContext.class,0);
10015 		}
10016 		public AssociativityClauseContext associativityClause() {
10017 			return getRuleContext(AssociativityClauseContext.class,0);
10018 		}
10019 		public InfixOperatorAttributesContext(ParserRuleContext parent, int invokingState) {
10020 			super(parent, invokingState);
10021 		}
10022 		@Override public int getRuleIndex() { return RULE_infixOperatorAttributes; }
10023 		@Override
10024 		public void enterRule(ParseTreeListener listener) {
10025 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInfixOperatorAttributes(this);
10026 		}
10027 		@Override
10028 		public void exitRule(ParseTreeListener listener) {
10029 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInfixOperatorAttributes(this);
10030 		}
10031 	}
10032 
10033 	public final InfixOperatorAttributesContext infixOperatorAttributes() throws RecognitionException {
10034 		InfixOperatorAttributesContext _localctx = new InfixOperatorAttributesContext(_ctx, getState());
10035 		enterRule(_localctx, 300, RULE_infixOperatorAttributes);
10036 		int _la;
10037 		try {
10038 			setState(1704);
10039 			_errHandler.sync(this);
10040 			switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
10041 			case 1:
10042 				enterOuterAlt(_localctx, 1);
10043 				{
10044 				setState(1693);
10045 				_la = _input.LA(1);
10046 				if (_la==T__89) {
10047 					{
10048 					setState(1692);
10049 					precedenceClause();
10050 					}
10051 				}
10052 
10053 				setState(1696);
10054 				_la = _input.LA(1);
10055 				if (_la==T__90) {
10056 					{
10057 					setState(1695);
10058 					associativityClause();
10059 					}
10060 				}
10061 
10062 				}
10063 				break;
10064 			case 2:
10065 				enterOuterAlt(_localctx, 2);
10066 				{
10067 				setState(1699);
10068 				_la = _input.LA(1);
10069 				if (_la==T__90) {
10070 					{
10071 					setState(1698);
10072 					associativityClause();
10073 					}
10074 				}
10075 
10076 				setState(1702);
10077 				_la = _input.LA(1);
10078 				if (_la==T__89) {
10079 					{
10080 					setState(1701);
10081 					precedenceClause();
10082 					}
10083 				}
10084 
10085 				}
10086 				break;
10087 			}
10088 		}
10089 		catch (RecognitionException re) {
10090 			_localctx.exception = re;
10091 			_errHandler.reportError(this, re);
10092 			_errHandler.recover(this, re);
10093 		}
10094 		finally {
10095 			exitRule();
10096 		}
10097 		return _localctx;
10098 	}
10099 
10100 	public static class PrecedenceClauseContext extends ParserRuleContext {
10101 		public PrecedenceLevelContext precedenceLevel() {
10102 			return getRuleContext(PrecedenceLevelContext.class,0);
10103 		}
10104 		public PrecedenceClauseContext(ParserRuleContext parent, int invokingState) {
10105 			super(parent, invokingState);
10106 		}
10107 		@Override public int getRuleIndex() { return RULE_precedenceClause; }
10108 		@Override
10109 		public void enterRule(ParseTreeListener listener) {
10110 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrecedenceClause(this);
10111 		}
10112 		@Override
10113 		public void exitRule(ParseTreeListener listener) {
10114 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrecedenceClause(this);
10115 		}
10116 	}
10117 
10118 	public final PrecedenceClauseContext precedenceClause() throws RecognitionException {
10119 		PrecedenceClauseContext _localctx = new PrecedenceClauseContext(_ctx, getState());
10120 		enterRule(_localctx, 302, RULE_precedenceClause);
10121 		try {
10122 			enterOuterAlt(_localctx, 1);
10123 			{
10124 			setState(1706);
10125 			match(T__89);
10126 			setState(1707);
10127 			precedenceLevel();
10128 			}
10129 		}
10130 		catch (RecognitionException re) {
10131 			_localctx.exception = re;
10132 			_errHandler.reportError(this, re);
10133 			_errHandler.recover(this, re);
10134 		}
10135 		finally {
10136 			exitRule();
10137 		}
10138 		return _localctx;
10139 	}
10140 
10141 	public static class PrecedenceLevelContext extends ParserRuleContext {
10142 		public IntegerLiteralContext integerLiteral() {
10143 			return getRuleContext(IntegerLiteralContext.class,0);
10144 		}
10145 		public PrecedenceLevelContext(ParserRuleContext parent, int invokingState) {
10146 			super(parent, invokingState);
10147 		}
10148 		@Override public int getRuleIndex() { return RULE_precedenceLevel; }
10149 		@Override
10150 		public void enterRule(ParseTreeListener listener) {
10151 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrecedenceLevel(this);
10152 		}
10153 		@Override
10154 		public void exitRule(ParseTreeListener listener) {
10155 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrecedenceLevel(this);
10156 		}
10157 	}
10158 
10159 	public final PrecedenceLevelContext precedenceLevel() throws RecognitionException {
10160 		PrecedenceLevelContext _localctx = new PrecedenceLevelContext(_ctx, getState());
10161 		enterRule(_localctx, 304, RULE_precedenceLevel);
10162 		try {
10163 			enterOuterAlt(_localctx, 1);
10164 			{
10165 			setState(1709);
10166 			integerLiteral();
10167 			}
10168 		}
10169 		catch (RecognitionException re) {
10170 			_localctx.exception = re;
10171 			_errHandler.reportError(this, re);
10172 			_errHandler.recover(this, re);
10173 		}
10174 		finally {
10175 			exitRule();
10176 		}
10177 		return _localctx;
10178 	}
10179 
10180 	public static class AssociativityClauseContext extends ParserRuleContext {
10181 		public AssociativityContext associativity() {
10182 			return getRuleContext(AssociativityContext.class,0);
10183 		}
10184 		public AssociativityClauseContext(ParserRuleContext parent, int invokingState) {
10185 			super(parent, invokingState);
10186 		}
10187 		@Override public int getRuleIndex() { return RULE_associativityClause; }
10188 		@Override
10189 		public void enterRule(ParseTreeListener listener) {
10190 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAssociativityClause(this);
10191 		}
10192 		@Override
10193 		public void exitRule(ParseTreeListener listener) {
10194 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAssociativityClause(this);
10195 		}
10196 	}
10197 
10198 	public final AssociativityClauseContext associativityClause() throws RecognitionException {
10199 		AssociativityClauseContext _localctx = new AssociativityClauseContext(_ctx, getState());
10200 		enterRule(_localctx, 306, RULE_associativityClause);
10201 		try {
10202 			enterOuterAlt(_localctx, 1);
10203 			{
10204 			setState(1711);
10205 			match(T__90);
10206 			setState(1712);
10207 			associativity();
10208 			}
10209 		}
10210 		catch (RecognitionException re) {
10211 			_localctx.exception = re;
10212 			_errHandler.reportError(this, re);
10213 			_errHandler.recover(this, re);
10214 		}
10215 		finally {
10216 			exitRule();
10217 		}
10218 		return _localctx;
10219 	}
10220 
10221 	public static class AssociativityContext extends ParserRuleContext {
10222 		public AssociativityContext(ParserRuleContext parent, int invokingState) {
10223 			super(parent, invokingState);
10224 		}
10225 		@Override public int getRuleIndex() { return RULE_associativity; }
10226 		@Override
10227 		public void enterRule(ParseTreeListener listener) {
10228 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAssociativity(this);
10229 		}
10230 		@Override
10231 		public void exitRule(ParseTreeListener listener) {
10232 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAssociativity(this);
10233 		}
10234 	}
10235 
10236 	public final AssociativityContext associativity() throws RecognitionException {
10237 		AssociativityContext _localctx = new AssociativityContext(_ctx, getState());
10238 		enterRule(_localctx, 308, RULE_associativity);
10239 		int _la;
10240 		try {
10241 			enterOuterAlt(_localctx, 1);
10242 			{
10243 			setState(1714);
10244 			_la = _input.LA(1);
10245 			if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (T__91 - 92)) | (1L << (T__92 - 92)) | (1L << (T__93 - 92)))) != 0)) ) {
10246 			_errHandler.recoverInline(this);
10247 			} else {
10248 				consume();
10249 			}
10250 			}
10251 		}
10252 		catch (RecognitionException re) {
10253 			_localctx.exception = re;
10254 			_errHandler.reportError(this, re);
10255 			_errHandler.recover(this, re);
10256 		}
10257 		finally {
10258 			exitRule();
10259 		}
10260 		return _localctx;
10261 	}
10262 
10263 	public static class PatternContext extends ParserRuleContext {
10264 		public WildcardPatternContext wildcardPattern() {
10265 			return getRuleContext(WildcardPatternContext.class,0);
10266 		}
10267 		public TypeAnnotationContext typeAnnotation() {
10268 			return getRuleContext(TypeAnnotationContext.class,0);
10269 		}
10270 		public IdentifierPatternContext identifierPattern() {
10271 			return getRuleContext(IdentifierPatternContext.class,0);
10272 		}
10273 		public ValueBindingPatternContext valueBindingPattern() {
10274 			return getRuleContext(ValueBindingPatternContext.class,0);
10275 		}
10276 		public TuplePatternContext tuplePattern() {
10277 			return getRuleContext(TuplePatternContext.class,0);
10278 		}
10279 		public EnumCasePatternContext enumCasePattern() {
10280 			return getRuleContext(EnumCasePatternContext.class,0);
10281 		}
10282 		public STypeContext sType() {
10283 			return getRuleContext(STypeContext.class,0);
10284 		}
10285 		public ExpressionPatternContext expressionPattern() {
10286 			return getRuleContext(ExpressionPatternContext.class,0);
10287 		}
10288 		public PatternContext pattern() {
10289 			return getRuleContext(PatternContext.class,0);
10290 		}
10291 		public PatternContext(ParserRuleContext parent, int invokingState) {
10292 			super(parent, invokingState);
10293 		}
10294 		@Override public int getRuleIndex() { return RULE_pattern; }
10295 		@Override
10296 		public void enterRule(ParseTreeListener listener) {
10297 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPattern(this);
10298 		}
10299 		@Override
10300 		public void exitRule(ParseTreeListener listener) {
10301 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPattern(this);
10302 		}
10303 	}
10304 
10305 	public final PatternContext pattern() throws RecognitionException {
10306 		return pattern(0);
10307 	}
10308 
10309 	private PatternContext pattern(int _p) throws RecognitionException {
10310 		ParserRuleContext _parentctx = _ctx;
10311 		int _parentState = getState();
10312 		PatternContext _localctx = new PatternContext(_ctx, _parentState);
10313 		PatternContext _prevctx = _localctx;
10314 		int _startState = 310;
10315 		enterRecursionRule(_localctx, 310, RULE_pattern, _p);
10316 		try {
10317 			int _alt;
10318 			enterOuterAlt(_localctx, 1);
10319 			{
10320 			setState(1734);
10321 			_errHandler.sync(this);
10322 			switch ( getInterpreter().adaptivePredict(_input,212,_ctx) ) {
10323 			case 1:
10324 				{
10325 				setState(1717);
10326 				wildcardPattern();
10327 				setState(1719);
10328 				_errHandler.sync(this);
10329 				switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
10330 				case 1:
10331 					{
10332 					setState(1718);
10333 					typeAnnotation();
10334 					}
10335 					break;
10336 				}
10337 				}
10338 				break;
10339 			case 2:
10340 				{
10341 				setState(1721);
10342 				identifierPattern();
10343 				setState(1723);
10344 				_errHandler.sync(this);
10345 				switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
10346 				case 1:
10347 					{
10348 					setState(1722);
10349 					typeAnnotation();
10350 					}
10351 					break;
10352 				}
10353 				}
10354 				break;
10355 			case 3:
10356 				{
10357 				setState(1725);
10358 				valueBindingPattern();
10359 				}
10360 				break;
10361 			case 4:
10362 				{
10363 				setState(1726);
10364 				tuplePattern();
10365 				setState(1728);
10366 				_errHandler.sync(this);
10367 				switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
10368 				case 1:
10369 					{
10370 					setState(1727);
10371 					typeAnnotation();
10372 					}
10373 					break;
10374 				}
10375 				}
10376 				break;
10377 			case 5:
10378 				{
10379 				setState(1730);
10380 				enumCasePattern();
10381 				}
10382 				break;
10383 			case 6:
10384 				{
10385 				setState(1731);
10386 				match(T__94);
10387 				setState(1732);
10388 				sType(0);
10389 				}
10390 				break;
10391 			case 7:
10392 				{
10393 				setState(1733);
10394 				expressionPattern();
10395 				}
10396 				break;
10397 			}
10398 			_ctx.stop = _input.LT(-1);
10399 			setState(1741);
10400 			_errHandler.sync(this);
10401 			_alt = getInterpreter().adaptivePredict(_input,213,_ctx);
10402 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10403 				if ( _alt==1 ) {
10404 					if ( _parseListeners!=null ) triggerExitRuleEvent();
10405 					_prevctx = _localctx;
10406 					{
10407 					{
10408 					_localctx = new PatternContext(_parentctx, _parentState);
10409 					pushNewRecursionContext(_localctx, _startState, RULE_pattern);
10410 					setState(1736);
10411 					if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
10412 					setState(1737);
10413 					match(T__95);
10414 					setState(1738);
10415 					sType(0);
10416 					}
10417 					} 
10418 				}
10419 				setState(1743);
10420 				_errHandler.sync(this);
10421 				_alt = getInterpreter().adaptivePredict(_input,213,_ctx);
10422 			}
10423 			}
10424 		}
10425 		catch (RecognitionException re) {
10426 			_localctx.exception = re;
10427 			_errHandler.reportError(this, re);
10428 			_errHandler.recover(this, re);
10429 		}
10430 		finally {
10431 			unrollRecursionContexts(_parentctx);
10432 		}
10433 		return _localctx;
10434 	}
10435 
10436 	public static class WildcardPatternContext extends ParserRuleContext {
10437 		public WildcardPatternContext(ParserRuleContext parent, int invokingState) {
10438 			super(parent, invokingState);
10439 		}
10440 		@Override public int getRuleIndex() { return RULE_wildcardPattern; }
10441 		@Override
10442 		public void enterRule(ParseTreeListener listener) {
10443 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWildcardPattern(this);
10444 		}
10445 		@Override
10446 		public void exitRule(ParseTreeListener listener) {
10447 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWildcardPattern(this);
10448 		}
10449 	}
10450 
10451 	public final WildcardPatternContext wildcardPattern() throws RecognitionException {
10452 		WildcardPatternContext _localctx = new WildcardPatternContext(_ctx, getState());
10453 		enterRule(_localctx, 312, RULE_wildcardPattern);
10454 		try {
10455 			enterOuterAlt(_localctx, 1);
10456 			{
10457 			setState(1744);
10458 			match(T__80);
10459 			}
10460 		}
10461 		catch (RecognitionException re) {
10462 			_localctx.exception = re;
10463 			_errHandler.reportError(this, re);
10464 			_errHandler.recover(this, re);
10465 		}
10466 		finally {
10467 			exitRule();
10468 		}
10469 		return _localctx;
10470 	}
10471 
10472 	public static class IdentifierPatternContext extends ParserRuleContext {
10473 		public IdentifierContext identifier() {
10474 			return getRuleContext(IdentifierContext.class,0);
10475 		}
10476 		public IdentifierPatternContext(ParserRuleContext parent, int invokingState) {
10477 			super(parent, invokingState);
10478 		}
10479 		@Override public int getRuleIndex() { return RULE_identifierPattern; }
10480 		@Override
10481 		public void enterRule(ParseTreeListener listener) {
10482 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterIdentifierPattern(this);
10483 		}
10484 		@Override
10485 		public void exitRule(ParseTreeListener listener) {
10486 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitIdentifierPattern(this);
10487 		}
10488 	}
10489 
10490 	public final IdentifierPatternContext identifierPattern() throws RecognitionException {
10491 		IdentifierPatternContext _localctx = new IdentifierPatternContext(_ctx, getState());
10492 		enterRule(_localctx, 314, RULE_identifierPattern);
10493 		try {
10494 			enterOuterAlt(_localctx, 1);
10495 			{
10496 			setState(1746);
10497 			identifier();
10498 			}
10499 		}
10500 		catch (RecognitionException re) {
10501 			_localctx.exception = re;
10502 			_errHandler.reportError(this, re);
10503 			_errHandler.recover(this, re);
10504 		}
10505 		finally {
10506 			exitRule();
10507 		}
10508 		return _localctx;
10509 	}
10510 
10511 	public static class ValueBindingPatternContext extends ParserRuleContext {
10512 		public PatternContext pattern() {
10513 			return getRuleContext(PatternContext.class,0);
10514 		}
10515 		public ValueBindingPatternContext(ParserRuleContext parent, int invokingState) {
10516 			super(parent, invokingState);
10517 		}
10518 		@Override public int getRuleIndex() { return RULE_valueBindingPattern; }
10519 		@Override
10520 		public void enterRule(ParseTreeListener listener) {
10521 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterValueBindingPattern(this);
10522 		}
10523 		@Override
10524 		public void exitRule(ParseTreeListener listener) {
10525 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitValueBindingPattern(this);
10526 		}
10527 	}
10528 
10529 	public final ValueBindingPatternContext valueBindingPattern() throws RecognitionException {
10530 		ValueBindingPatternContext _localctx = new ValueBindingPatternContext(_ctx, getState());
10531 		enterRule(_localctx, 316, RULE_valueBindingPattern);
10532 		try {
10533 			setState(1752);
10534 			switch (_input.LA(1)) {
10535 			case T__26:
10536 				enterOuterAlt(_localctx, 1);
10537 				{
10538 				setState(1748);
10539 				match(T__26);
10540 				setState(1749);
10541 				pattern(0);
10542 				}
10543 				break;
10544 			case T__25:
10545 				enterOuterAlt(_localctx, 2);
10546 				{
10547 				setState(1750);
10548 				match(T__25);
10549 				setState(1751);
10550 				pattern(0);
10551 				}
10552 				break;
10553 			default:
10554 				throw new NoViableAltException(this);
10555 			}
10556 		}
10557 		catch (RecognitionException re) {
10558 			_localctx.exception = re;
10559 			_errHandler.reportError(this, re);
10560 			_errHandler.recover(this, re);
10561 		}
10562 		finally {
10563 			exitRule();
10564 		}
10565 		return _localctx;
10566 	}
10567 
10568 	public static class TuplePatternContext extends ParserRuleContext {
10569 		public TuplePatternElementListContext tuplePatternElementList() {
10570 			return getRuleContext(TuplePatternElementListContext.class,0);
10571 		}
10572 		public TuplePatternContext(ParserRuleContext parent, int invokingState) {
10573 			super(parent, invokingState);
10574 		}
10575 		@Override public int getRuleIndex() { return RULE_tuplePattern; }
10576 		@Override
10577 		public void enterRule(ParseTreeListener listener) {
10578 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTuplePattern(this);
10579 		}
10580 		@Override
10581 		public void exitRule(ParseTreeListener listener) {
10582 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTuplePattern(this);
10583 		}
10584 	}
10585 
10586 	public final TuplePatternContext tuplePattern() throws RecognitionException {
10587 		TuplePatternContext _localctx = new TuplePatternContext(_ctx, getState());
10588 		enterRule(_localctx, 318, RULE_tuplePattern);
10589 		int _la;
10590 		try {
10591 			enterOuterAlt(_localctx, 1);
10592 			{
10593 			setState(1754);
10594 			match(T__3);
10595 			setState(1756);
10596 			_la = _input.LA(1);
10597 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__94 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__118 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
10598 				{
10599 				setState(1755);
10600 				tuplePatternElementList();
10601 				}
10602 			}
10603 
10604 			setState(1758);
10605 			match(T__4);
10606 			}
10607 		}
10608 		catch (RecognitionException re) {
10609 			_localctx.exception = re;
10610 			_errHandler.reportError(this, re);
10611 			_errHandler.recover(this, re);
10612 		}
10613 		finally {
10614 			exitRule();
10615 		}
10616 		return _localctx;
10617 	}
10618 
10619 	public static class TuplePatternElementListContext extends ParserRuleContext {
10620 		public List<TuplePatternElementContext> tuplePatternElement() {
10621 			return getRuleContexts(TuplePatternElementContext.class);
10622 		}
10623 		public TuplePatternElementContext tuplePatternElement(int i) {
10624 			return getRuleContext(TuplePatternElementContext.class,i);
10625 		}
10626 		public TuplePatternElementListContext(ParserRuleContext parent, int invokingState) {
10627 			super(parent, invokingState);
10628 		}
10629 		@Override public int getRuleIndex() { return RULE_tuplePatternElementList; }
10630 		@Override
10631 		public void enterRule(ParseTreeListener listener) {
10632 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTuplePatternElementList(this);
10633 		}
10634 		@Override
10635 		public void exitRule(ParseTreeListener listener) {
10636 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTuplePatternElementList(this);
10637 		}
10638 	}
10639 
10640 	public final TuplePatternElementListContext tuplePatternElementList() throws RecognitionException {
10641 		TuplePatternElementListContext _localctx = new TuplePatternElementListContext(_ctx, getState());
10642 		enterRule(_localctx, 320, RULE_tuplePatternElementList);
10643 		int _la;
10644 		try {
10645 			enterOuterAlt(_localctx, 1);
10646 			{
10647 			setState(1760);
10648 			tuplePatternElement();
10649 			setState(1765);
10650 			_errHandler.sync(this);
10651 			_la = _input.LA(1);
10652 			while (_la==T__15) {
10653 				{
10654 				{
10655 				setState(1761);
10656 				match(T__15);
10657 				setState(1762);
10658 				tuplePatternElement();
10659 				}
10660 				}
10661 				setState(1767);
10662 				_errHandler.sync(this);
10663 				_la = _input.LA(1);
10664 			}
10665 			}
10666 		}
10667 		catch (RecognitionException re) {
10668 			_localctx.exception = re;
10669 			_errHandler.reportError(this, re);
10670 			_errHandler.recover(this, re);
10671 		}
10672 		finally {
10673 			exitRule();
10674 		}
10675 		return _localctx;
10676 	}
10677 
10678 	public static class TuplePatternElementContext extends ParserRuleContext {
10679 		public PatternContext pattern() {
10680 			return getRuleContext(PatternContext.class,0);
10681 		}
10682 		public TuplePatternElementContext(ParserRuleContext parent, int invokingState) {
10683 			super(parent, invokingState);
10684 		}
10685 		@Override public int getRuleIndex() { return RULE_tuplePatternElement; }
10686 		@Override
10687 		public void enterRule(ParseTreeListener listener) {
10688 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTuplePatternElement(this);
10689 		}
10690 		@Override
10691 		public void exitRule(ParseTreeListener listener) {
10692 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTuplePatternElement(this);
10693 		}
10694 	}
10695 
10696 	public final TuplePatternElementContext tuplePatternElement() throws RecognitionException {
10697 		TuplePatternElementContext _localctx = new TuplePatternElementContext(_ctx, getState());
10698 		enterRule(_localctx, 322, RULE_tuplePatternElement);
10699 		try {
10700 			enterOuterAlt(_localctx, 1);
10701 			{
10702 			setState(1768);
10703 			pattern(0);
10704 			}
10705 		}
10706 		catch (RecognitionException re) {
10707 			_localctx.exception = re;
10708 			_errHandler.reportError(this, re);
10709 			_errHandler.recover(this, re);
10710 		}
10711 		finally {
10712 			exitRule();
10713 		}
10714 		return _localctx;
10715 	}
10716 
10717 	public static class EnumCasePatternContext extends ParserRuleContext {
10718 		public EnumCaseNameContext enumCaseName() {
10719 			return getRuleContext(EnumCaseNameContext.class,0);
10720 		}
10721 		public TypeIdentifierContext typeIdentifier() {
10722 			return getRuleContext(TypeIdentifierContext.class,0);
10723 		}
10724 		public TuplePatternContext tuplePattern() {
10725 			return getRuleContext(TuplePatternContext.class,0);
10726 		}
10727 		public EnumCasePatternContext(ParserRuleContext parent, int invokingState) {
10728 			super(parent, invokingState);
10729 		}
10730 		@Override public int getRuleIndex() { return RULE_enumCasePattern; }
10731 		@Override
10732 		public void enterRule(ParseTreeListener listener) {
10733 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterEnumCasePattern(this);
10734 		}
10735 		@Override
10736 		public void exitRule(ParseTreeListener listener) {
10737 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitEnumCasePattern(this);
10738 		}
10739 	}
10740 
10741 	public final EnumCasePatternContext enumCasePattern() throws RecognitionException {
10742 		EnumCasePatternContext _localctx = new EnumCasePatternContext(_ctx, getState());
10743 		enterRule(_localctx, 324, RULE_enumCasePattern);
10744 		int _la;
10745 		try {
10746 			enterOuterAlt(_localctx, 1);
10747 			{
10748 			setState(1771);
10749 			_errHandler.sync(this);
10750 			switch ( getInterpreter().adaptivePredict(_input,217,_ctx) ) {
10751 			case 1:
10752 				{
10753 				setState(1770);
10754 				typeIdentifier();
10755 				}
10756 				break;
10757 			}
10758 			setState(1774);
10759 			_la = _input.LA(1);
10760 			if (_la==T__69) {
10761 				{
10762 				setState(1773);
10763 				match(T__69);
10764 				}
10765 			}
10766 
10767 			setState(1776);
10768 			enumCaseName();
10769 			setState(1778);
10770 			_errHandler.sync(this);
10771 			switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
10772 			case 1:
10773 				{
10774 				setState(1777);
10775 				tuplePattern();
10776 				}
10777 				break;
10778 			}
10779 			}
10780 		}
10781 		catch (RecognitionException re) {
10782 			_localctx.exception = re;
10783 			_errHandler.reportError(this, re);
10784 			_errHandler.recover(this, re);
10785 		}
10786 		finally {
10787 			exitRule();
10788 		}
10789 		return _localctx;
10790 	}
10791 
10792 	public static class TypeCastingPatternContext extends ParserRuleContext {
10793 		public IsPatternContext isPattern() {
10794 			return getRuleContext(IsPatternContext.class,0);
10795 		}
10796 		public AsPatternContext asPattern() {
10797 			return getRuleContext(AsPatternContext.class,0);
10798 		}
10799 		public TypeCastingPatternContext(ParserRuleContext parent, int invokingState) {
10800 			super(parent, invokingState);
10801 		}
10802 		@Override public int getRuleIndex() { return RULE_typeCastingPattern; }
10803 		@Override
10804 		public void enterRule(ParseTreeListener listener) {
10805 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeCastingPattern(this);
10806 		}
10807 		@Override
10808 		public void exitRule(ParseTreeListener listener) {
10809 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeCastingPattern(this);
10810 		}
10811 	}
10812 
10813 	public final TypeCastingPatternContext typeCastingPattern() throws RecognitionException {
10814 		TypeCastingPatternContext _localctx = new TypeCastingPatternContext(_ctx, getState());
10815 		enterRule(_localctx, 326, RULE_typeCastingPattern);
10816 		try {
10817 			setState(1782);
10818 			_errHandler.sync(this);
10819 			switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) {
10820 			case 1:
10821 				enterOuterAlt(_localctx, 1);
10822 				{
10823 				setState(1780);
10824 				isPattern();
10825 				}
10826 				break;
10827 			case 2:
10828 				enterOuterAlt(_localctx, 2);
10829 				{
10830 				setState(1781);
10831 				asPattern();
10832 				}
10833 				break;
10834 			}
10835 		}
10836 		catch (RecognitionException re) {
10837 			_localctx.exception = re;
10838 			_errHandler.reportError(this, re);
10839 			_errHandler.recover(this, re);
10840 		}
10841 		finally {
10842 			exitRule();
10843 		}
10844 		return _localctx;
10845 	}
10846 
10847 	public static class IsPatternContext extends ParserRuleContext {
10848 		public STypeContext sType() {
10849 			return getRuleContext(STypeContext.class,0);
10850 		}
10851 		public IsPatternContext(ParserRuleContext parent, int invokingState) {
10852 			super(parent, invokingState);
10853 		}
10854 		@Override public int getRuleIndex() { return RULE_isPattern; }
10855 		@Override
10856 		public void enterRule(ParseTreeListener listener) {
10857 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterIsPattern(this);
10858 		}
10859 		@Override
10860 		public void exitRule(ParseTreeListener listener) {
10861 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitIsPattern(this);
10862 		}
10863 	}
10864 
10865 	public final IsPatternContext isPattern() throws RecognitionException {
10866 		IsPatternContext _localctx = new IsPatternContext(_ctx, getState());
10867 		enterRule(_localctx, 328, RULE_isPattern);
10868 		try {
10869 			enterOuterAlt(_localctx, 1);
10870 			{
10871 			setState(1784);
10872 			match(T__94);
10873 			setState(1785);
10874 			sType(0);
10875 			}
10876 		}
10877 		catch (RecognitionException re) {
10878 			_localctx.exception = re;
10879 			_errHandler.reportError(this, re);
10880 			_errHandler.recover(this, re);
10881 		}
10882 		finally {
10883 			exitRule();
10884 		}
10885 		return _localctx;
10886 	}
10887 
10888 	public static class AsPatternContext extends ParserRuleContext {
10889 		public PatternContext pattern() {
10890 			return getRuleContext(PatternContext.class,0);
10891 		}
10892 		public STypeContext sType() {
10893 			return getRuleContext(STypeContext.class,0);
10894 		}
10895 		public AsPatternContext(ParserRuleContext parent, int invokingState) {
10896 			super(parent, invokingState);
10897 		}
10898 		@Override public int getRuleIndex() { return RULE_asPattern; }
10899 		@Override
10900 		public void enterRule(ParseTreeListener listener) {
10901 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAsPattern(this);
10902 		}
10903 		@Override
10904 		public void exitRule(ParseTreeListener listener) {
10905 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAsPattern(this);
10906 		}
10907 	}
10908 
10909 	public final AsPatternContext asPattern() throws RecognitionException {
10910 		AsPatternContext _localctx = new AsPatternContext(_ctx, getState());
10911 		enterRule(_localctx, 330, RULE_asPattern);
10912 		try {
10913 			enterOuterAlt(_localctx, 1);
10914 			{
10915 			setState(1787);
10916 			pattern(0);
10917 			setState(1788);
10918 			match(T__95);
10919 			setState(1789);
10920 			sType(0);
10921 			}
10922 		}
10923 		catch (RecognitionException re) {
10924 			_localctx.exception = re;
10925 			_errHandler.reportError(this, re);
10926 			_errHandler.recover(this, re);
10927 		}
10928 		finally {
10929 			exitRule();
10930 		}
10931 		return _localctx;
10932 	}
10933 
10934 	public static class ExpressionPatternContext extends ParserRuleContext {
10935 		public ExpressionContext expression() {
10936 			return getRuleContext(ExpressionContext.class,0);
10937 		}
10938 		public ExpressionPatternContext(ParserRuleContext parent, int invokingState) {
10939 			super(parent, invokingState);
10940 		}
10941 		@Override public int getRuleIndex() { return RULE_expressionPattern; }
10942 		@Override
10943 		public void enterRule(ParseTreeListener listener) {
10944 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExpressionPattern(this);
10945 		}
10946 		@Override
10947 		public void exitRule(ParseTreeListener listener) {
10948 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExpressionPattern(this);
10949 		}
10950 	}
10951 
10952 	public final ExpressionPatternContext expressionPattern() throws RecognitionException {
10953 		ExpressionPatternContext _localctx = new ExpressionPatternContext(_ctx, getState());
10954 		enterRule(_localctx, 332, RULE_expressionPattern);
10955 		try {
10956 			enterOuterAlt(_localctx, 1);
10957 			{
10958 			setState(1791);
10959 			expression();
10960 			}
10961 		}
10962 		catch (RecognitionException re) {
10963 			_localctx.exception = re;
10964 			_errHandler.reportError(this, re);
10965 			_errHandler.recover(this, re);
10966 		}
10967 		finally {
10968 			exitRule();
10969 		}
10970 		return _localctx;
10971 	}
10972 
10973 	public static class AttributeContext extends ParserRuleContext {
10974 		public AttributeNameContext attributeName() {
10975 			return getRuleContext(AttributeNameContext.class,0);
10976 		}
10977 		public AttributeArgumentClauseContext attributeArgumentClause() {
10978 			return getRuleContext(AttributeArgumentClauseContext.class,0);
10979 		}
10980 		public AttributeContext(ParserRuleContext parent, int invokingState) {
10981 			super(parent, invokingState);
10982 		}
10983 		@Override public int getRuleIndex() { return RULE_attribute; }
10984 		@Override
10985 		public void enterRule(ParseTreeListener listener) {
10986 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAttribute(this);
10987 		}
10988 		@Override
10989 		public void exitRule(ParseTreeListener listener) {
10990 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAttribute(this);
10991 		}
10992 	}
10993 
10994 	public final AttributeContext attribute() throws RecognitionException {
10995 		AttributeContext _localctx = new AttributeContext(_ctx, getState());
10996 		enterRule(_localctx, 334, RULE_attribute);
10997 		try {
10998 			enterOuterAlt(_localctx, 1);
10999 			{
11000 			setState(1793);
11001 			match(T__96);
11002 			setState(1794);
11003 			attributeName();
11004 			setState(1796);
11005 			_errHandler.sync(this);
11006 			switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) {
11007 			case 1:
11008 				{
11009 				setState(1795);
11010 				attributeArgumentClause();
11011 				}
11012 				break;
11013 			}
11014 			}
11015 		}
11016 		catch (RecognitionException re) {
11017 			_localctx.exception = re;
11018 			_errHandler.reportError(this, re);
11019 			_errHandler.recover(this, re);
11020 		}
11021 		finally {
11022 			exitRule();
11023 		}
11024 		return _localctx;
11025 	}
11026 
11027 	public static class AttributeNameContext extends ParserRuleContext {
11028 		public IdentifierContext identifier() {
11029 			return getRuleContext(IdentifierContext.class,0);
11030 		}
11031 		public AttributeNameContext(ParserRuleContext parent, int invokingState) {
11032 			super(parent, invokingState);
11033 		}
11034 		@Override public int getRuleIndex() { return RULE_attributeName; }
11035 		@Override
11036 		public void enterRule(ParseTreeListener listener) {
11037 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAttributeName(this);
11038 		}
11039 		@Override
11040 		public void exitRule(ParseTreeListener listener) {
11041 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAttributeName(this);
11042 		}
11043 	}
11044 
11045 	public final AttributeNameContext attributeName() throws RecognitionException {
11046 		AttributeNameContext _localctx = new AttributeNameContext(_ctx, getState());
11047 		enterRule(_localctx, 336, RULE_attributeName);
11048 		try {
11049 			enterOuterAlt(_localctx, 1);
11050 			{
11051 			setState(1798);
11052 			identifier();
11053 			}
11054 		}
11055 		catch (RecognitionException re) {
11056 			_localctx.exception = re;
11057 			_errHandler.reportError(this, re);
11058 			_errHandler.recover(this, re);
11059 		}
11060 		finally {
11061 			exitRule();
11062 		}
11063 		return _localctx;
11064 	}
11065 
11066 	public static class AttributeArgumentClauseContext extends ParserRuleContext {
11067 		public BalancedTokensContext balancedTokens() {
11068 			return getRuleContext(BalancedTokensContext.class,0);
11069 		}
11070 		public AttributeArgumentClauseContext(ParserRuleContext parent, int invokingState) {
11071 			super(parent, invokingState);
11072 		}
11073 		@Override public int getRuleIndex() { return RULE_attributeArgumentClause; }
11074 		@Override
11075 		public void enterRule(ParseTreeListener listener) {
11076 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAttributeArgumentClause(this);
11077 		}
11078 		@Override
11079 		public void exitRule(ParseTreeListener listener) {
11080 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAttributeArgumentClause(this);
11081 		}
11082 	}
11083 
11084 	public final AttributeArgumentClauseContext attributeArgumentClause() throws RecognitionException {
11085 		AttributeArgumentClauseContext _localctx = new AttributeArgumentClauseContext(_ctx, getState());
11086 		enterRule(_localctx, 338, RULE_attributeArgumentClause);
11087 		int _la;
11088 		try {
11089 			enterOuterAlt(_localctx, 1);
11090 			{
11091 			setState(1800);
11092 			match(T__3);
11093 			setState(1802);
11094 			_la = _input.LA(1);
11095 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__3) | (1L << T__13) | (1L << T__15) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__100 - 70)) | (1L << (T__101 - 70)) | (1L << (T__102 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
11096 				{
11097 				setState(1801);
11098 				balancedTokens();
11099 				}
11100 			}
11101 
11102 			setState(1804);
11103 			match(T__4);
11104 			}
11105 		}
11106 		catch (RecognitionException re) {
11107 			_localctx.exception = re;
11108 			_errHandler.reportError(this, re);
11109 			_errHandler.recover(this, re);
11110 		}
11111 		finally {
11112 			exitRule();
11113 		}
11114 		return _localctx;
11115 	}
11116 
11117 	public static class AttributesContext extends ParserRuleContext {
11118 		public List<AttributeContext> attribute() {
11119 			return getRuleContexts(AttributeContext.class);
11120 		}
11121 		public AttributeContext attribute(int i) {
11122 			return getRuleContext(AttributeContext.class,i);
11123 		}
11124 		public AttributesContext(ParserRuleContext parent, int invokingState) {
11125 			super(parent, invokingState);
11126 		}
11127 		@Override public int getRuleIndex() { return RULE_attributes; }
11128 		@Override
11129 		public void enterRule(ParseTreeListener listener) {
11130 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAttributes(this);
11131 		}
11132 		@Override
11133 		public void exitRule(ParseTreeListener listener) {
11134 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAttributes(this);
11135 		}
11136 	}
11137 
11138 	public final AttributesContext attributes() throws RecognitionException {
11139 		AttributesContext _localctx = new AttributesContext(_ctx, getState());
11140 		enterRule(_localctx, 340, RULE_attributes);
11141 		int _la;
11142 		try {
11143 			enterOuterAlt(_localctx, 1);
11144 			{
11145 			setState(1807); 
11146 			_errHandler.sync(this);
11147 			_la = _input.LA(1);
11148 			do {
11149 				{
11150 				{
11151 				setState(1806);
11152 				attribute();
11153 				}
11154 				}
11155 				setState(1809); 
11156 				_errHandler.sync(this);
11157 				_la = _input.LA(1);
11158 			} while ( _la==T__96 );
11159 			}
11160 		}
11161 		catch (RecognitionException re) {
11162 			_localctx.exception = re;
11163 			_errHandler.reportError(this, re);
11164 			_errHandler.recover(this, re);
11165 		}
11166 		finally {
11167 			exitRule();
11168 		}
11169 		return _localctx;
11170 	}
11171 
11172 	public static class BalancedTokensContext extends ParserRuleContext {
11173 		public BalancedTokenContext balancedToken() {
11174 			return getRuleContext(BalancedTokenContext.class,0);
11175 		}
11176 		public BalancedTokensContext balancedTokens() {
11177 			return getRuleContext(BalancedTokensContext.class,0);
11178 		}
11179 		public BalancedTokensContext(ParserRuleContext parent, int invokingState) {
11180 			super(parent, invokingState);
11181 		}
11182 		@Override public int getRuleIndex() { return RULE_balancedTokens; }
11183 		@Override
11184 		public void enterRule(ParseTreeListener listener) {
11185 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBalancedTokens(this);
11186 		}
11187 		@Override
11188 		public void exitRule(ParseTreeListener listener) {
11189 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBalancedTokens(this);
11190 		}
11191 	}
11192 
11193 	public final BalancedTokensContext balancedTokens() throws RecognitionException {
11194 		BalancedTokensContext _localctx = new BalancedTokensContext(_ctx, getState());
11195 		enterRule(_localctx, 342, RULE_balancedTokens);
11196 		int _la;
11197 		try {
11198 			enterOuterAlt(_localctx, 1);
11199 			{
11200 			setState(1811);
11201 			balancedToken();
11202 			setState(1813);
11203 			_la = _input.LA(1);
11204 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__3) | (1L << T__13) | (1L << T__15) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__100 - 70)) | (1L << (T__101 - 70)) | (1L << (T__102 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
11205 				{
11206 				setState(1812);
11207 				balancedTokens();
11208 				}
11209 			}
11210 
11211 			}
11212 		}
11213 		catch (RecognitionException re) {
11214 			_localctx.exception = re;
11215 			_errHandler.reportError(this, re);
11216 			_errHandler.recover(this, re);
11217 		}
11218 		finally {
11219 			exitRule();
11220 		}
11221 		return _localctx;
11222 	}
11223 
11224 	public static class BalancedTokenContext extends ParserRuleContext {
11225 		public BalancedTokensContext balancedTokens() {
11226 			return getRuleContext(BalancedTokensContext.class,0);
11227 		}
11228 		public IdentifierContext identifier() {
11229 			return getRuleContext(IdentifierContext.class,0);
11230 		}
11231 		public ExpressionContext expression() {
11232 			return getRuleContext(ExpressionContext.class,0);
11233 		}
11234 		public ContextSensitiveKeywordContext contextSensitiveKeyword() {
11235 			return getRuleContext(ContextSensitiveKeywordContext.class,0);
11236 		}
11237 		public LiteralContext literal() {
11238 			return getRuleContext(LiteralContext.class,0);
11239 		}
11240 		public OperatorContext operator() {
11241 			return getRuleContext(OperatorContext.class,0);
11242 		}
11243 		public BalancedTokenContext(ParserRuleContext parent, int invokingState) {
11244 			super(parent, invokingState);
11245 		}
11246 		@Override public int getRuleIndex() { return RULE_balancedToken; }
11247 		@Override
11248 		public void enterRule(ParseTreeListener listener) {
11249 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBalancedToken(this);
11250 		}
11251 		@Override
11252 		public void exitRule(ParseTreeListener listener) {
11253 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBalancedToken(this);
11254 		}
11255 	}
11256 
11257 	public final BalancedTokenContext balancedToken() throws RecognitionException {
11258 		BalancedTokenContext _localctx = new BalancedTokenContext(_ctx, getState());
11259 		enterRule(_localctx, 344, RULE_balancedToken);
11260 		int _la;
11261 		try {
11262 			setState(1846);
11263 			_errHandler.sync(this);
11264 			switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
11265 			case 1:
11266 				enterOuterAlt(_localctx, 1);
11267 				{
11268 				setState(1815);
11269 				match(T__3);
11270 				setState(1817);
11271 				_la = _input.LA(1);
11272 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__3) | (1L << T__13) | (1L << T__15) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__100 - 70)) | (1L << (T__101 - 70)) | (1L << (T__102 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
11273 					{
11274 					setState(1816);
11275 					balancedTokens();
11276 					}
11277 				}
11278 
11279 				setState(1819);
11280 				match(T__4);
11281 				}
11282 				break;
11283 			case 2:
11284 				enterOuterAlt(_localctx, 2);
11285 				{
11286 				setState(1820);
11287 				match(T__97);
11288 				setState(1822);
11289 				_la = _input.LA(1);
11290 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__3) | (1L << T__13) | (1L << T__15) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__100 - 70)) | (1L << (T__101 - 70)) | (1L << (T__102 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
11291 					{
11292 					setState(1821);
11293 					balancedTokens();
11294 					}
11295 				}
11296 
11297 				setState(1824);
11298 				match(T__98);
11299 				}
11300 				break;
11301 			case 3:
11302 				enterOuterAlt(_localctx, 3);
11303 				{
11304 				setState(1825);
11305 				match(T__13);
11306 				setState(1827);
11307 				_la = _input.LA(1);
11308 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__3) | (1L << T__13) | (1L << T__15) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__100 - 70)) | (1L << (T__101 - 70)) | (1L << (T__102 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
11309 					{
11310 					setState(1826);
11311 					balancedTokens();
11312 					}
11313 				}
11314 
11315 				setState(1829);
11316 				match(T__14);
11317 				}
11318 				break;
11319 			case 4:
11320 				enterOuterAlt(_localctx, 4);
11321 				{
11322 				setState(1830);
11323 				identifier();
11324 				}
11325 				break;
11326 			case 5:
11327 				enterOuterAlt(_localctx, 5);
11328 				{
11329 				setState(1831);
11330 				expression();
11331 				}
11332 				break;
11333 			case 6:
11334 				enterOuterAlt(_localctx, 6);
11335 				{
11336 				setState(1832);
11337 				contextSensitiveKeyword();
11338 				}
11339 				break;
11340 			case 7:
11341 				enterOuterAlt(_localctx, 7);
11342 				{
11343 				setState(1833);
11344 				literal();
11345 				}
11346 				break;
11347 			case 8:
11348 				enterOuterAlt(_localctx, 8);
11349 				{
11350 				setState(1834);
11351 				operator();
11352 				}
11353 				break;
11354 			case 9:
11355 				enterOuterAlt(_localctx, 9);
11356 				{
11357 				setState(1835);
11358 				match(T__1);
11359 				}
11360 				break;
11361 			case 10:
11362 				enterOuterAlt(_localctx, 10);
11363 				{
11364 				setState(1836);
11365 				match(T__0);
11366 				}
11367 				break;
11368 			case 11:
11369 				enterOuterAlt(_localctx, 11);
11370 				{
11371 				setState(1837);
11372 				match(T__15);
11373 				}
11374 				break;
11375 			case 12:
11376 				enterOuterAlt(_localctx, 12);
11377 				{
11378 				setState(1838);
11379 				match(T__84);
11380 				}
11381 				break;
11382 			case 13:
11383 				enterOuterAlt(_localctx, 13);
11384 				{
11385 				setState(1839);
11386 				match(T__38);
11387 				}
11388 				break;
11389 			case 14:
11390 				enterOuterAlt(_localctx, 14);
11391 				{
11392 				setState(1840);
11393 				match(T__39);
11394 				}
11395 				break;
11396 			case 15:
11397 				enterOuterAlt(_localctx, 15);
11398 				{
11399 				setState(1841);
11400 				match(T__99);
11401 				}
11402 				break;
11403 			case 16:
11404 				enterOuterAlt(_localctx, 16);
11405 				{
11406 				setState(1842);
11407 				match(T__100);
11408 				}
11409 				break;
11410 			case 17:
11411 				enterOuterAlt(_localctx, 17);
11412 				{
11413 				setState(1843);
11414 				match(T__101);
11415 				}
11416 				break;
11417 			case 18:
11418 				enterOuterAlt(_localctx, 18);
11419 				{
11420 				setState(1844);
11421 				match(T__77);
11422 				}
11423 				break;
11424 			case 19:
11425 				enterOuterAlt(_localctx, 19);
11426 				{
11427 				setState(1845);
11428 				match(T__102);
11429 				}
11430 				break;
11431 			}
11432 		}
11433 		catch (RecognitionException re) {
11434 			_localctx.exception = re;
11435 			_errHandler.reportError(this, re);
11436 			_errHandler.recover(this, re);
11437 		}
11438 		finally {
11439 			exitRule();
11440 		}
11441 		return _localctx;
11442 	}
11443 
11444 	public static class ExpressionListContext extends ParserRuleContext {
11445 		public List<ExpressionContext> expression() {
11446 			return getRuleContexts(ExpressionContext.class);
11447 		}
11448 		public ExpressionContext expression(int i) {
11449 			return getRuleContext(ExpressionContext.class,i);
11450 		}
11451 		public ExpressionListContext(ParserRuleContext parent, int invokingState) {
11452 			super(parent, invokingState);
11453 		}
11454 		@Override public int getRuleIndex() { return RULE_expressionList; }
11455 		@Override
11456 		public void enterRule(ParseTreeListener listener) {
11457 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExpressionList(this);
11458 		}
11459 		@Override
11460 		public void exitRule(ParseTreeListener listener) {
11461 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExpressionList(this);
11462 		}
11463 	}
11464 
11465 	public final ExpressionListContext expressionList() throws RecognitionException {
11466 		ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
11467 		enterRule(_localctx, 346, RULE_expressionList);
11468 		int _la;
11469 		try {
11470 			enterOuterAlt(_localctx, 1);
11471 			{
11472 			setState(1848);
11473 			expression();
11474 			setState(1853);
11475 			_errHandler.sync(this);
11476 			_la = _input.LA(1);
11477 			while (_la==T__15) {
11478 				{
11479 				{
11480 				setState(1849);
11481 				match(T__15);
11482 				setState(1850);
11483 				expression();
11484 				}
11485 				}
11486 				setState(1855);
11487 				_errHandler.sync(this);
11488 				_la = _input.LA(1);
11489 			}
11490 			}
11491 		}
11492 		catch (RecognitionException re) {
11493 			_localctx.exception = re;
11494 			_errHandler.reportError(this, re);
11495 			_errHandler.recover(this, re);
11496 		}
11497 		finally {
11498 			exitRule();
11499 		}
11500 		return _localctx;
11501 	}
11502 
11503 	public static class ExpressionContext extends ParserRuleContext {
11504 		public PrefixExpressionContext prefixExpression() {
11505 			return getRuleContext(PrefixExpressionContext.class,0);
11506 		}
11507 		public TryOperatorContext tryOperator() {
11508 			return getRuleContext(TryOperatorContext.class,0);
11509 		}
11510 		public List<BinaryExpressionContext> binaryExpression() {
11511 			return getRuleContexts(BinaryExpressionContext.class);
11512 		}
11513 		public BinaryExpressionContext binaryExpression(int i) {
11514 			return getRuleContext(BinaryExpressionContext.class,i);
11515 		}
11516 		public ExpressionContext(ParserRuleContext parent, int invokingState) {
11517 			super(parent, invokingState);
11518 		}
11519 		@Override public int getRuleIndex() { return RULE_expression; }
11520 		@Override
11521 		public void enterRule(ParseTreeListener listener) {
11522 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExpression(this);
11523 		}
11524 		@Override
11525 		public void exitRule(ParseTreeListener listener) {
11526 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExpression(this);
11527 		}
11528 	}
11529 
11530 	public final ExpressionContext expression() throws RecognitionException {
11531 		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
11532 		enterRule(_localctx, 348, RULE_expression);
11533 		int _la;
11534 		try {
11535 			int _alt;
11536 			enterOuterAlt(_localctx, 1);
11537 			{
11538 			setState(1857);
11539 			_la = _input.LA(1);
11540 			if (_la==T__104) {
11541 				{
11542 				setState(1856);
11543 				tryOperator();
11544 				}
11545 			}
11546 
11547 			setState(1859);
11548 			prefixExpression();
11549 			setState(1863);
11550 			_errHandler.sync(this);
11551 			_alt = getInterpreter().adaptivePredict(_input,231,_ctx);
11552 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
11553 				if ( _alt==1 ) {
11554 					{
11555 					{
11556 					setState(1860);
11557 					binaryExpression();
11558 					}
11559 					} 
11560 				}
11561 				setState(1865);
11562 				_errHandler.sync(this);
11563 				_alt = getInterpreter().adaptivePredict(_input,231,_ctx);
11564 			}
11565 			}
11566 		}
11567 		catch (RecognitionException re) {
11568 			_localctx.exception = re;
11569 			_errHandler.reportError(this, re);
11570 			_errHandler.recover(this, re);
11571 		}
11572 		finally {
11573 			exitRule();
11574 		}
11575 		return _localctx;
11576 	}
11577 
11578 	public static class PrefixExpressionContext extends ParserRuleContext {
11579 		public PostfixExpressionContext postfixExpression() {
11580 			return getRuleContext(PostfixExpressionContext.class,0);
11581 		}
11582 		public PrefixOperatorContext prefixOperator() {
11583 			return getRuleContext(PrefixOperatorContext.class,0);
11584 		}
11585 		public InOutExpressionContext inOutExpression() {
11586 			return getRuleContext(InOutExpressionContext.class,0);
11587 		}
11588 		public PrefixExpressionContext(ParserRuleContext parent, int invokingState) {
11589 			super(parent, invokingState);
11590 		}
11591 		@Override public int getRuleIndex() { return RULE_prefixExpression; }
11592 		@Override
11593 		public void enterRule(ParseTreeListener listener) {
11594 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrefixExpression(this);
11595 		}
11596 		@Override
11597 		public void exitRule(ParseTreeListener listener) {
11598 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrefixExpression(this);
11599 		}
11600 	}
11601 
11602 	public final PrefixExpressionContext prefixExpression() throws RecognitionException {
11603 		PrefixExpressionContext _localctx = new PrefixExpressionContext(_ctx, getState());
11604 		enterRule(_localctx, 350, RULE_prefixExpression);
11605 		try {
11606 			setState(1874);
11607 			_errHandler.sync(this);
11608 			switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) {
11609 			case 1:
11610 				enterOuterAlt(_localctx, 1);
11611 				{
11612 				setState(1867);
11613 				_errHandler.sync(this);
11614 				switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
11615 				case 1:
11616 					{
11617 					setState(1866);
11618 					prefixOperator();
11619 					}
11620 					break;
11621 				}
11622 				setState(1869);
11623 				postfixExpression(0);
11624 				setState(1871);
11625 				_errHandler.sync(this);
11626 				switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
11627 				case 1:
11628 					{
11629 					setState(1870);
11630 					match(T__0);
11631 					}
11632 					break;
11633 				}
11634 				}
11635 				break;
11636 			case 2:
11637 				enterOuterAlt(_localctx, 2);
11638 				{
11639 				setState(1873);
11640 				inOutExpression();
11641 				}
11642 				break;
11643 			}
11644 		}
11645 		catch (RecognitionException re) {
11646 			_localctx.exception = re;
11647 			_errHandler.reportError(this, re);
11648 			_errHandler.recover(this, re);
11649 		}
11650 		finally {
11651 			exitRule();
11652 		}
11653 		return _localctx;
11654 	}
11655 
11656 	public static class InOutExpressionContext extends ParserRuleContext {
11657 		public IdentifierContext identifier() {
11658 			return getRuleContext(IdentifierContext.class,0);
11659 		}
11660 		public InOutExpressionContext(ParserRuleContext parent, int invokingState) {
11661 			super(parent, invokingState);
11662 		}
11663 		@Override public int getRuleIndex() { return RULE_inOutExpression; }
11664 		@Override
11665 		public void enterRule(ParseTreeListener listener) {
11666 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInOutExpression(this);
11667 		}
11668 		@Override
11669 		public void exitRule(ParseTreeListener listener) {
11670 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInOutExpression(this);
11671 		}
11672 	}
11673 
11674 	public final InOutExpressionContext inOutExpression() throws RecognitionException {
11675 		InOutExpressionContext _localctx = new InOutExpressionContext(_ctx, getState());
11676 		enterRule(_localctx, 352, RULE_inOutExpression);
11677 		try {
11678 			enterOuterAlt(_localctx, 1);
11679 			{
11680 			setState(1876);
11681 			match(T__103);
11682 			setState(1877);
11683 			identifier();
11684 			}
11685 		}
11686 		catch (RecognitionException re) {
11687 			_localctx.exception = re;
11688 			_errHandler.reportError(this, re);
11689 			_errHandler.recover(this, re);
11690 		}
11691 		finally {
11692 			exitRule();
11693 		}
11694 		return _localctx;
11695 	}
11696 
11697 	public static class TryOperatorContext extends ParserRuleContext {
11698 		public TryOperatorContext(ParserRuleContext parent, int invokingState) {
11699 			super(parent, invokingState);
11700 		}
11701 		@Override public int getRuleIndex() { return RULE_tryOperator; }
11702 		@Override
11703 		public void enterRule(ParseTreeListener listener) {
11704 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTryOperator(this);
11705 		}
11706 		@Override
11707 		public void exitRule(ParseTreeListener listener) {
11708 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTryOperator(this);
11709 		}
11710 	}
11711 
11712 	public final TryOperatorContext tryOperator() throws RecognitionException {
11713 		TryOperatorContext _localctx = new TryOperatorContext(_ctx, getState());
11714 		enterRule(_localctx, 354, RULE_tryOperator);
11715 		int _la;
11716 		try {
11717 			enterOuterAlt(_localctx, 1);
11718 			{
11719 			setState(1879);
11720 			match(T__104);
11721 			setState(1881);
11722 			_errHandler.sync(this);
11723 			switch ( getInterpreter().adaptivePredict(_input,235,_ctx) ) {
11724 			case 1:
11725 				{
11726 				setState(1880);
11727 				_la = _input.LA(1);
11728 				if ( !(_la==T__83 || _la==T__84) ) {
11729 				_errHandler.recoverInline(this);
11730 				} else {
11731 					consume();
11732 				}
11733 				}
11734 				break;
11735 			}
11736 			}
11737 		}
11738 		catch (RecognitionException re) {
11739 			_localctx.exception = re;
11740 			_errHandler.reportError(this, re);
11741 			_errHandler.recover(this, re);
11742 		}
11743 		finally {
11744 			exitRule();
11745 		}
11746 		return _localctx;
11747 	}
11748 
11749 	public static class BinaryExpressionContext extends ParserRuleContext {
11750 		public BinaryOperatorContext binaryOperator() {
11751 			return getRuleContext(BinaryOperatorContext.class,0);
11752 		}
11753 		public PrefixExpressionContext prefixExpression() {
11754 			return getRuleContext(PrefixExpressionContext.class,0);
11755 		}
11756 		public AssignmentOperatorContext assignmentOperator() {
11757 			return getRuleContext(AssignmentOperatorContext.class,0);
11758 		}
11759 		public TryOperatorContext tryOperator() {
11760 			return getRuleContext(TryOperatorContext.class,0);
11761 		}
11762 		public ConditionalOperatorContext conditionalOperator() {
11763 			return getRuleContext(ConditionalOperatorContext.class,0);
11764 		}
11765 		public TypeCastingOperatorContext typeCastingOperator() {
11766 			return getRuleContext(TypeCastingOperatorContext.class,0);
11767 		}
11768 		public BinaryExpressionContext(ParserRuleContext parent, int invokingState) {
11769 			super(parent, invokingState);
11770 		}
11771 		@Override public int getRuleIndex() { return RULE_binaryExpression; }
11772 		@Override
11773 		public void enterRule(ParseTreeListener listener) {
11774 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBinaryExpression(this);
11775 		}
11776 		@Override
11777 		public void exitRule(ParseTreeListener listener) {
11778 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBinaryExpression(this);
11779 		}
11780 	}
11781 
11782 	public final BinaryExpressionContext binaryExpression() throws RecognitionException {
11783 		BinaryExpressionContext _localctx = new BinaryExpressionContext(_ctx, getState());
11784 		enterRule(_localctx, 356, RULE_binaryExpression);
11785 		int _la;
11786 		try {
11787 			setState(1899);
11788 			_errHandler.sync(this);
11789 			switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
11790 			case 1:
11791 				enterOuterAlt(_localctx, 1);
11792 				{
11793 				setState(1883);
11794 				binaryOperator();
11795 				setState(1884);
11796 				prefixExpression();
11797 				}
11798 				break;
11799 			case 2:
11800 				enterOuterAlt(_localctx, 2);
11801 				{
11802 				setState(1886);
11803 				assignmentOperator();
11804 				setState(1888);
11805 				_la = _input.LA(1);
11806 				if (_la==T__104) {
11807 					{
11808 					setState(1887);
11809 					tryOperator();
11810 					}
11811 				}
11812 
11813 				setState(1890);
11814 				prefixExpression();
11815 				}
11816 				break;
11817 			case 3:
11818 				enterOuterAlt(_localctx, 3);
11819 				{
11820 				setState(1892);
11821 				conditionalOperator();
11822 				setState(1894);
11823 				_la = _input.LA(1);
11824 				if (_la==T__104) {
11825 					{
11826 					setState(1893);
11827 					tryOperator();
11828 					}
11829 				}
11830 
11831 				setState(1896);
11832 				prefixExpression();
11833 				}
11834 				break;
11835 			case 4:
11836 				enterOuterAlt(_localctx, 4);
11837 				{
11838 				setState(1898);
11839 				typeCastingOperator();
11840 				}
11841 				break;
11842 			}
11843 		}
11844 		catch (RecognitionException re) {
11845 			_localctx.exception = re;
11846 			_errHandler.reportError(this, re);
11847 			_errHandler.recover(this, re);
11848 		}
11849 		finally {
11850 			exitRule();
11851 		}
11852 		return _localctx;
11853 	}
11854 
11855 	public static class AssignmentOperatorContext extends ParserRuleContext {
11856 		public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) {
11857 			super(parent, invokingState);
11858 		}
11859 		@Override public int getRuleIndex() { return RULE_assignmentOperator; }
11860 		@Override
11861 		public void enterRule(ParseTreeListener listener) {
11862 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterAssignmentOperator(this);
11863 		}
11864 		@Override
11865 		public void exitRule(ParseTreeListener listener) {
11866 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitAssignmentOperator(this);
11867 		}
11868 	}
11869 
11870 	public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
11871 		AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
11872 		enterRule(_localctx, 358, RULE_assignmentOperator);
11873 		try {
11874 			enterOuterAlt(_localctx, 1);
11875 			{
11876 			setState(1901);
11877 			match(T__70);
11878 			}
11879 		}
11880 		catch (RecognitionException re) {
11881 			_localctx.exception = re;
11882 			_errHandler.reportError(this, re);
11883 			_errHandler.recover(this, re);
11884 		}
11885 		finally {
11886 			exitRule();
11887 		}
11888 		return _localctx;
11889 	}
11890 
11891 	public static class ConditionalOperatorContext extends ParserRuleContext {
11892 		public ExpressionContext expression() {
11893 			return getRuleContext(ExpressionContext.class,0);
11894 		}
11895 		public TryOperatorContext tryOperator() {
11896 			return getRuleContext(TryOperatorContext.class,0);
11897 		}
11898 		public ConditionalOperatorContext(ParserRuleContext parent, int invokingState) {
11899 			super(parent, invokingState);
11900 		}
11901 		@Override public int getRuleIndex() { return RULE_conditionalOperator; }
11902 		@Override
11903 		public void enterRule(ParseTreeListener listener) {
11904 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterConditionalOperator(this);
11905 		}
11906 		@Override
11907 		public void exitRule(ParseTreeListener listener) {
11908 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitConditionalOperator(this);
11909 		}
11910 	}
11911 
11912 	public final ConditionalOperatorContext conditionalOperator() throws RecognitionException {
11913 		ConditionalOperatorContext _localctx = new ConditionalOperatorContext(_ctx, getState());
11914 		enterRule(_localctx, 360, RULE_conditionalOperator);
11915 		try {
11916 			enterOuterAlt(_localctx, 1);
11917 			{
11918 			setState(1903);
11919 			match(T__83);
11920 			setState(1905);
11921 			_errHandler.sync(this);
11922 			switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) {
11923 			case 1:
11924 				{
11925 				setState(1904);
11926 				tryOperator();
11927 				}
11928 				break;
11929 			}
11930 			setState(1907);
11931 			expression();
11932 			setState(1908);
11933 			match(T__1);
11934 			}
11935 		}
11936 		catch (RecognitionException re) {
11937 			_localctx.exception = re;
11938 			_errHandler.reportError(this, re);
11939 			_errHandler.recover(this, re);
11940 		}
11941 		finally {
11942 			exitRule();
11943 		}
11944 		return _localctx;
11945 	}
11946 
11947 	public static class TypeCastingOperatorContext extends ParserRuleContext {
11948 		public STypeContext sType() {
11949 			return getRuleContext(STypeContext.class,0);
11950 		}
11951 		public TypeCastingOperatorContext(ParserRuleContext parent, int invokingState) {
11952 			super(parent, invokingState);
11953 		}
11954 		@Override public int getRuleIndex() { return RULE_typeCastingOperator; }
11955 		@Override
11956 		public void enterRule(ParseTreeListener listener) {
11957 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeCastingOperator(this);
11958 		}
11959 		@Override
11960 		public void exitRule(ParseTreeListener listener) {
11961 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeCastingOperator(this);
11962 		}
11963 	}
11964 
11965 	public final TypeCastingOperatorContext typeCastingOperator() throws RecognitionException {
11966 		TypeCastingOperatorContext _localctx = new TypeCastingOperatorContext(_ctx, getState());
11967 		enterRule(_localctx, 362, RULE_typeCastingOperator);
11968 		try {
11969 			setState(1920);
11970 			_errHandler.sync(this);
11971 			switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) {
11972 			case 1:
11973 				enterOuterAlt(_localctx, 1);
11974 				{
11975 				setState(1910);
11976 				match(T__94);
11977 				setState(1911);
11978 				sType(0);
11979 				}
11980 				break;
11981 			case 2:
11982 				enterOuterAlt(_localctx, 2);
11983 				{
11984 				setState(1912);
11985 				match(T__95);
11986 				setState(1913);
11987 				match(T__83);
11988 				setState(1914);
11989 				sType(0);
11990 				}
11991 				break;
11992 			case 3:
11993 				enterOuterAlt(_localctx, 3);
11994 				{
11995 				setState(1915);
11996 				match(T__95);
11997 				setState(1916);
11998 				sType(0);
11999 				}
12000 				break;
12001 			case 4:
12002 				enterOuterAlt(_localctx, 4);
12003 				{
12004 				setState(1917);
12005 				match(T__95);
12006 				setState(1918);
12007 				match(T__84);
12008 				setState(1919);
12009 				sType(0);
12010 				}
12011 				break;
12012 			}
12013 		}
12014 		catch (RecognitionException re) {
12015 			_localctx.exception = re;
12016 			_errHandler.reportError(this, re);
12017 			_errHandler.recover(this, re);
12018 		}
12019 		finally {
12020 			exitRule();
12021 		}
12022 		return _localctx;
12023 	}
12024 
12025 	public static class PrimaryExpressionContext extends ParserRuleContext {
12026 		public IdentifierContext identifier() {
12027 			return getRuleContext(IdentifierContext.class,0);
12028 		}
12029 		public OperatorContext operator() {
12030 			return getRuleContext(OperatorContext.class,0);
12031 		}
12032 		public GenericArgumentClauseContext genericArgumentClause() {
12033 			return getRuleContext(GenericArgumentClauseContext.class,0);
12034 		}
12035 		public LiteralExpressionContext literalExpression() {
12036 			return getRuleContext(LiteralExpressionContext.class,0);
12037 		}
12038 		public SelfExpressionContext selfExpression() {
12039 			return getRuleContext(SelfExpressionContext.class,0);
12040 		}
12041 		public SuperclassExpressionContext superclassExpression() {
12042 			return getRuleContext(SuperclassExpressionContext.class,0);
12043 		}
12044 		public ClosureExpressionContext closureExpression() {
12045 			return getRuleContext(ClosureExpressionContext.class,0);
12046 		}
12047 		public ParenthesizedExpressionContext parenthesizedExpression() {
12048 			return getRuleContext(ParenthesizedExpressionContext.class,0);
12049 		}
12050 		public ImplicitMemberExpressionContext implicitMemberExpression() {
12051 			return getRuleContext(ImplicitMemberExpressionContext.class,0);
12052 		}
12053 		public WildcardExpressionContext wildcardExpression() {
12054 			return getRuleContext(WildcardExpressionContext.class,0);
12055 		}
12056 		public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
12057 			super(parent, invokingState);
12058 		}
12059 		@Override public int getRuleIndex() { return RULE_primaryExpression; }
12060 		@Override
12061 		public void enterRule(ParseTreeListener listener) {
12062 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrimaryExpression(this);
12063 		}
12064 		@Override
12065 		public void exitRule(ParseTreeListener listener) {
12066 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrimaryExpression(this);
12067 		}
12068 	}
12069 
12070 	public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
12071 		PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
12072 		enterRule(_localctx, 364, RULE_primaryExpression);
12073 		try {
12074 			setState(1936);
12075 			_errHandler.sync(this);
12076 			switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) {
12077 			case 1:
12078 				enterOuterAlt(_localctx, 1);
12079 				{
12080 				setState(1924);
12081 				switch (_input.LA(1)) {
12082 				case T__30:
12083 				case T__31:
12084 				case T__32:
12085 				case T__34:
12086 				case T__42:
12087 				case T__43:
12088 				case T__44:
12089 				case T__45:
12090 				case T__46:
12091 				case T__47:
12092 				case T__48:
12093 				case T__49:
12094 				case T__50:
12095 				case T__51:
12096 				case T__52:
12097 				case T__53:
12098 				case T__55:
12099 				case T__58:
12100 				case T__60:
12101 				case T__71:
12102 				case T__72:
12103 				case T__73:
12104 				case T__81:
12105 				case T__88:
12106 				case T__89:
12107 				case T__90:
12108 				case T__91:
12109 				case T__92:
12110 				case T__93:
12111 				case T__116:
12112 				case T__117:
12113 				case T__123:
12114 				case T__124:
12115 				case T__125:
12116 				case T__126:
12117 				case T__127:
12118 				case T__128:
12119 				case T__130:
12120 				case Identifier:
12121 					{
12122 					setState(1922);
12123 					identifier();
12124 					}
12125 					break;
12126 				case T__29:
12127 				case T__38:
12128 				case T__39:
12129 				case T__40:
12130 				case T__70:
12131 				case T__77:
12132 				case T__83:
12133 				case T__84:
12134 				case T__99:
12135 				case T__101:
12136 				case T__103:
12137 				case T__114:
12138 				case T__115:
12139 				case OperatorHead:
12140 				case DotOperatorHead:
12141 					{
12142 					setState(1923);
12143 					operator();
12144 					}
12145 					break;
12146 				default:
12147 					throw new NoViableAltException(this);
12148 				}
12149 				setState(1927);
12150 				_errHandler.sync(this);
12151 				switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) {
12152 				case 1:
12153 					{
12154 					setState(1926);
12155 					genericArgumentClause();
12156 					}
12157 					break;
12158 				}
12159 				}
12160 				break;
12161 			case 2:
12162 				enterOuterAlt(_localctx, 2);
12163 				{
12164 				setState(1929);
12165 				literalExpression();
12166 				}
12167 				break;
12168 			case 3:
12169 				enterOuterAlt(_localctx, 3);
12170 				{
12171 				setState(1930);
12172 				selfExpression();
12173 				}
12174 				break;
12175 			case 4:
12176 				enterOuterAlt(_localctx, 4);
12177 				{
12178 				setState(1931);
12179 				superclassExpression();
12180 				}
12181 				break;
12182 			case 5:
12183 				enterOuterAlt(_localctx, 5);
12184 				{
12185 				setState(1932);
12186 				closureExpression();
12187 				}
12188 				break;
12189 			case 6:
12190 				enterOuterAlt(_localctx, 6);
12191 				{
12192 				setState(1933);
12193 				parenthesizedExpression();
12194 				}
12195 				break;
12196 			case 7:
12197 				enterOuterAlt(_localctx, 7);
12198 				{
12199 				setState(1934);
12200 				implicitMemberExpression();
12201 				}
12202 				break;
12203 			case 8:
12204 				enterOuterAlt(_localctx, 8);
12205 				{
12206 				setState(1935);
12207 				wildcardExpression();
12208 				}
12209 				break;
12210 			}
12211 		}
12212 		catch (RecognitionException re) {
12213 			_localctx.exception = re;
12214 			_errHandler.reportError(this, re);
12215 			_errHandler.recover(this, re);
12216 		}
12217 		finally {
12218 			exitRule();
12219 		}
12220 		return _localctx;
12221 	}
12222 
12223 	public static class LiteralExpressionContext extends ParserRuleContext {
12224 		public LiteralContext literal() {
12225 			return getRuleContext(LiteralContext.class,0);
12226 		}
12227 		public ArrayLiteralContext arrayLiteral() {
12228 			return getRuleContext(ArrayLiteralContext.class,0);
12229 		}
12230 		public DictionaryLiteralContext dictionaryLiteral() {
12231 			return getRuleContext(DictionaryLiteralContext.class,0);
12232 		}
12233 		public LiteralExpressionContext(ParserRuleContext parent, int invokingState) {
12234 			super(parent, invokingState);
12235 		}
12236 		@Override public int getRuleIndex() { return RULE_literalExpression; }
12237 		@Override
12238 		public void enterRule(ParseTreeListener listener) {
12239 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLiteralExpression(this);
12240 		}
12241 		@Override
12242 		public void exitRule(ParseTreeListener listener) {
12243 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLiteralExpression(this);
12244 		}
12245 	}
12246 
12247 	public final LiteralExpressionContext literalExpression() throws RecognitionException {
12248 		LiteralExpressionContext _localctx = new LiteralExpressionContext(_ctx, getState());
12249 		enterRule(_localctx, 366, RULE_literalExpression);
12250 		try {
12251 			setState(1945);
12252 			_errHandler.sync(this);
12253 			switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) {
12254 			case 1:
12255 				enterOuterAlt(_localctx, 1);
12256 				{
12257 				setState(1938);
12258 				literal();
12259 				}
12260 				break;
12261 			case 2:
12262 				enterOuterAlt(_localctx, 2);
12263 				{
12264 				setState(1939);
12265 				arrayLiteral();
12266 				}
12267 				break;
12268 			case 3:
12269 				enterOuterAlt(_localctx, 3);
12270 				{
12271 				setState(1940);
12272 				dictionaryLiteral();
12273 				}
12274 				break;
12275 			case 4:
12276 				enterOuterAlt(_localctx, 4);
12277 				{
12278 				setState(1941);
12279 				match(T__105);
12280 				}
12281 				break;
12282 			case 5:
12283 				enterOuterAlt(_localctx, 5);
12284 				{
12285 				setState(1942);
12286 				match(T__106);
12287 				}
12288 				break;
12289 			case 6:
12290 				enterOuterAlt(_localctx, 6);
12291 				{
12292 				setState(1943);
12293 				match(T__107);
12294 				}
12295 				break;
12296 			case 7:
12297 				enterOuterAlt(_localctx, 7);
12298 				{
12299 				setState(1944);
12300 				match(T__108);
12301 				}
12302 				break;
12303 			}
12304 		}
12305 		catch (RecognitionException re) {
12306 			_localctx.exception = re;
12307 			_errHandler.reportError(this, re);
12308 			_errHandler.recover(this, re);
12309 		}
12310 		finally {
12311 			exitRule();
12312 		}
12313 		return _localctx;
12314 	}
12315 
12316 	public static class ArrayLiteralContext extends ParserRuleContext {
12317 		public ArrayLiteralItemsContext arrayLiteralItems() {
12318 			return getRuleContext(ArrayLiteralItemsContext.class,0);
12319 		}
12320 		public ArrayLiteralContext(ParserRuleContext parent, int invokingState) {
12321 			super(parent, invokingState);
12322 		}
12323 		@Override public int getRuleIndex() { return RULE_arrayLiteral; }
12324 		@Override
12325 		public void enterRule(ParseTreeListener listener) {
12326 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterArrayLiteral(this);
12327 		}
12328 		@Override
12329 		public void exitRule(ParseTreeListener listener) {
12330 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitArrayLiteral(this);
12331 		}
12332 	}
12333 
12334 	public final ArrayLiteralContext arrayLiteral() throws RecognitionException {
12335 		ArrayLiteralContext _localctx = new ArrayLiteralContext(_ctx, getState());
12336 		enterRule(_localctx, 368, RULE_arrayLiteral);
12337 		int _la;
12338 		try {
12339 			enterOuterAlt(_localctx, 1);
12340 			{
12341 			setState(1947);
12342 			match(T__97);
12343 			setState(1949);
12344 			_la = _input.LA(1);
12345 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
12346 				{
12347 				setState(1948);
12348 				arrayLiteralItems();
12349 				}
12350 			}
12351 
12352 			setState(1951);
12353 			match(T__98);
12354 			}
12355 		}
12356 		catch (RecognitionException re) {
12357 			_localctx.exception = re;
12358 			_errHandler.reportError(this, re);
12359 			_errHandler.recover(this, re);
12360 		}
12361 		finally {
12362 			exitRule();
12363 		}
12364 		return _localctx;
12365 	}
12366 
12367 	public static class ArrayLiteralItemsContext extends ParserRuleContext {
12368 		public List<ArrayLiteralItemContext> arrayLiteralItem() {
12369 			return getRuleContexts(ArrayLiteralItemContext.class);
12370 		}
12371 		public ArrayLiteralItemContext arrayLiteralItem(int i) {
12372 			return getRuleContext(ArrayLiteralItemContext.class,i);
12373 		}
12374 		public ArrayLiteralItemsContext(ParserRuleContext parent, int invokingState) {
12375 			super(parent, invokingState);
12376 		}
12377 		@Override public int getRuleIndex() { return RULE_arrayLiteralItems; }
12378 		@Override
12379 		public void enterRule(ParseTreeListener listener) {
12380 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterArrayLiteralItems(this);
12381 		}
12382 		@Override
12383 		public void exitRule(ParseTreeListener listener) {
12384 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitArrayLiteralItems(this);
12385 		}
12386 	}
12387 
12388 	public final ArrayLiteralItemsContext arrayLiteralItems() throws RecognitionException {
12389 		ArrayLiteralItemsContext _localctx = new ArrayLiteralItemsContext(_ctx, getState());
12390 		enterRule(_localctx, 370, RULE_arrayLiteralItems);
12391 		int _la;
12392 		try {
12393 			int _alt;
12394 			enterOuterAlt(_localctx, 1);
12395 			{
12396 			setState(1953);
12397 			arrayLiteralItem();
12398 			setState(1958);
12399 			_errHandler.sync(this);
12400 			_alt = getInterpreter().adaptivePredict(_input,246,_ctx);
12401 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
12402 				if ( _alt==1 ) {
12403 					{
12404 					{
12405 					setState(1954);
12406 					match(T__15);
12407 					setState(1955);
12408 					arrayLiteralItem();
12409 					}
12410 					} 
12411 				}
12412 				setState(1960);
12413 				_errHandler.sync(this);
12414 				_alt = getInterpreter().adaptivePredict(_input,246,_ctx);
12415 			}
12416 			setState(1962);
12417 			_la = _input.LA(1);
12418 			if (_la==T__15) {
12419 				{
12420 				setState(1961);
12421 				match(T__15);
12422 				}
12423 			}
12424 
12425 			}
12426 		}
12427 		catch (RecognitionException re) {
12428 			_localctx.exception = re;
12429 			_errHandler.reportError(this, re);
12430 			_errHandler.recover(this, re);
12431 		}
12432 		finally {
12433 			exitRule();
12434 		}
12435 		return _localctx;
12436 	}
12437 
12438 	public static class ArrayLiteralItemContext extends ParserRuleContext {
12439 		public ExpressionContext expression() {
12440 			return getRuleContext(ExpressionContext.class,0);
12441 		}
12442 		public ArrayLiteralItemContext(ParserRuleContext parent, int invokingState) {
12443 			super(parent, invokingState);
12444 		}
12445 		@Override public int getRuleIndex() { return RULE_arrayLiteralItem; }
12446 		@Override
12447 		public void enterRule(ParseTreeListener listener) {
12448 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterArrayLiteralItem(this);
12449 		}
12450 		@Override
12451 		public void exitRule(ParseTreeListener listener) {
12452 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitArrayLiteralItem(this);
12453 		}
12454 	}
12455 
12456 	public final ArrayLiteralItemContext arrayLiteralItem() throws RecognitionException {
12457 		ArrayLiteralItemContext _localctx = new ArrayLiteralItemContext(_ctx, getState());
12458 		enterRule(_localctx, 372, RULE_arrayLiteralItem);
12459 		try {
12460 			enterOuterAlt(_localctx, 1);
12461 			{
12462 			setState(1964);
12463 			expression();
12464 			}
12465 		}
12466 		catch (RecognitionException re) {
12467 			_localctx.exception = re;
12468 			_errHandler.reportError(this, re);
12469 			_errHandler.recover(this, re);
12470 		}
12471 		finally {
12472 			exitRule();
12473 		}
12474 		return _localctx;
12475 	}
12476 
12477 	public static class DictionaryLiteralContext extends ParserRuleContext {
12478 		public DictionaryLiteralItemsContext dictionaryLiteralItems() {
12479 			return getRuleContext(DictionaryLiteralItemsContext.class,0);
12480 		}
12481 		public DictionaryLiteralContext(ParserRuleContext parent, int invokingState) {
12482 			super(parent, invokingState);
12483 		}
12484 		@Override public int getRuleIndex() { return RULE_dictionaryLiteral; }
12485 		@Override
12486 		public void enterRule(ParseTreeListener listener) {
12487 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDictionaryLiteral(this);
12488 		}
12489 		@Override
12490 		public void exitRule(ParseTreeListener listener) {
12491 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDictionaryLiteral(this);
12492 		}
12493 	}
12494 
12495 	public final DictionaryLiteralContext dictionaryLiteral() throws RecognitionException {
12496 		DictionaryLiteralContext _localctx = new DictionaryLiteralContext(_ctx, getState());
12497 		enterRule(_localctx, 374, RULE_dictionaryLiteral);
12498 		try {
12499 			setState(1973);
12500 			_errHandler.sync(this);
12501 			switch ( getInterpreter().adaptivePredict(_input,248,_ctx) ) {
12502 			case 1:
12503 				enterOuterAlt(_localctx, 1);
12504 				{
12505 				setState(1966);
12506 				match(T__97);
12507 				setState(1967);
12508 				dictionaryLiteralItems();
12509 				setState(1968);
12510 				match(T__98);
12511 				}
12512 				break;
12513 			case 2:
12514 				enterOuterAlt(_localctx, 2);
12515 				{
12516 				setState(1970);
12517 				match(T__97);
12518 				setState(1971);
12519 				match(T__1);
12520 				setState(1972);
12521 				match(T__98);
12522 				}
12523 				break;
12524 			}
12525 		}
12526 		catch (RecognitionException re) {
12527 			_localctx.exception = re;
12528 			_errHandler.reportError(this, re);
12529 			_errHandler.recover(this, re);
12530 		}
12531 		finally {
12532 			exitRule();
12533 		}
12534 		return _localctx;
12535 	}
12536 
12537 	public static class DictionaryLiteralItemsContext extends ParserRuleContext {
12538 		public List<DictionaryLiteralItemContext> dictionaryLiteralItem() {
12539 			return getRuleContexts(DictionaryLiteralItemContext.class);
12540 		}
12541 		public DictionaryLiteralItemContext dictionaryLiteralItem(int i) {
12542 			return getRuleContext(DictionaryLiteralItemContext.class,i);
12543 		}
12544 		public DictionaryLiteralItemsContext(ParserRuleContext parent, int invokingState) {
12545 			super(parent, invokingState);
12546 		}
12547 		@Override public int getRuleIndex() { return RULE_dictionaryLiteralItems; }
12548 		@Override
12549 		public void enterRule(ParseTreeListener listener) {
12550 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDictionaryLiteralItems(this);
12551 		}
12552 		@Override
12553 		public void exitRule(ParseTreeListener listener) {
12554 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDictionaryLiteralItems(this);
12555 		}
12556 	}
12557 
12558 	public final DictionaryLiteralItemsContext dictionaryLiteralItems() throws RecognitionException {
12559 		DictionaryLiteralItemsContext _localctx = new DictionaryLiteralItemsContext(_ctx, getState());
12560 		enterRule(_localctx, 376, RULE_dictionaryLiteralItems);
12561 		int _la;
12562 		try {
12563 			int _alt;
12564 			enterOuterAlt(_localctx, 1);
12565 			{
12566 			setState(1975);
12567 			dictionaryLiteralItem();
12568 			setState(1980);
12569 			_errHandler.sync(this);
12570 			_alt = getInterpreter().adaptivePredict(_input,249,_ctx);
12571 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
12572 				if ( _alt==1 ) {
12573 					{
12574 					{
12575 					setState(1976);
12576 					match(T__15);
12577 					setState(1977);
12578 					dictionaryLiteralItem();
12579 					}
12580 					} 
12581 				}
12582 				setState(1982);
12583 				_errHandler.sync(this);
12584 				_alt = getInterpreter().adaptivePredict(_input,249,_ctx);
12585 			}
12586 			setState(1984);
12587 			_la = _input.LA(1);
12588 			if (_la==T__15) {
12589 				{
12590 				setState(1983);
12591 				match(T__15);
12592 				}
12593 			}
12594 
12595 			}
12596 		}
12597 		catch (RecognitionException re) {
12598 			_localctx.exception = re;
12599 			_errHandler.reportError(this, re);
12600 			_errHandler.recover(this, re);
12601 		}
12602 		finally {
12603 			exitRule();
12604 		}
12605 		return _localctx;
12606 	}
12607 
12608 	public static class DictionaryLiteralItemContext extends ParserRuleContext {
12609 		public List<ExpressionContext> expression() {
12610 			return getRuleContexts(ExpressionContext.class);
12611 		}
12612 		public ExpressionContext expression(int i) {
12613 			return getRuleContext(ExpressionContext.class,i);
12614 		}
12615 		public DictionaryLiteralItemContext(ParserRuleContext parent, int invokingState) {
12616 			super(parent, invokingState);
12617 		}
12618 		@Override public int getRuleIndex() { return RULE_dictionaryLiteralItem; }
12619 		@Override
12620 		public void enterRule(ParseTreeListener listener) {
12621 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDictionaryLiteralItem(this);
12622 		}
12623 		@Override
12624 		public void exitRule(ParseTreeListener listener) {
12625 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDictionaryLiteralItem(this);
12626 		}
12627 	}
12628 
12629 	public final DictionaryLiteralItemContext dictionaryLiteralItem() throws RecognitionException {
12630 		DictionaryLiteralItemContext _localctx = new DictionaryLiteralItemContext(_ctx, getState());
12631 		enterRule(_localctx, 378, RULE_dictionaryLiteralItem);
12632 		try {
12633 			enterOuterAlt(_localctx, 1);
12634 			{
12635 			setState(1986);
12636 			expression();
12637 			setState(1987);
12638 			match(T__1);
12639 			setState(1988);
12640 			expression();
12641 			}
12642 		}
12643 		catch (RecognitionException re) {
12644 			_localctx.exception = re;
12645 			_errHandler.reportError(this, re);
12646 			_errHandler.recover(this, re);
12647 		}
12648 		finally {
12649 			exitRule();
12650 		}
12651 		return _localctx;
12652 	}
12653 
12654 	public static class SelfExpressionContext extends ParserRuleContext {
12655 		public IdentifierContext identifier() {
12656 			return getRuleContext(IdentifierContext.class,0);
12657 		}
12658 		public ExpressionListContext expressionList() {
12659 			return getRuleContext(ExpressionListContext.class,0);
12660 		}
12661 		public SelfExpressionContext(ParserRuleContext parent, int invokingState) {
12662 			super(parent, invokingState);
12663 		}
12664 		@Override public int getRuleIndex() { return RULE_selfExpression; }
12665 		@Override
12666 		public void enterRule(ParseTreeListener listener) {
12667 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSelfExpression(this);
12668 		}
12669 		@Override
12670 		public void exitRule(ParseTreeListener listener) {
12671 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSelfExpression(this);
12672 		}
12673 	}
12674 
12675 	public final SelfExpressionContext selfExpression() throws RecognitionException {
12676 		SelfExpressionContext _localctx = new SelfExpressionContext(_ctx, getState());
12677 		enterRule(_localctx, 380, RULE_selfExpression);
12678 		try {
12679 			setState(2002);
12680 			_errHandler.sync(this);
12681 			switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) {
12682 			case 1:
12683 				enterOuterAlt(_localctx, 1);
12684 				{
12685 				setState(1990);
12686 				match(T__109);
12687 				}
12688 				break;
12689 			case 2:
12690 				enterOuterAlt(_localctx, 2);
12691 				{
12692 				setState(1991);
12693 				match(T__109);
12694 				setState(1992);
12695 				match(T__69);
12696 				setState(1993);
12697 				identifier();
12698 				}
12699 				break;
12700 			case 3:
12701 				enterOuterAlt(_localctx, 3);
12702 				{
12703 				setState(1994);
12704 				match(T__109);
12705 				setState(1995);
12706 				match(T__97);
12707 				setState(1996);
12708 				expressionList();
12709 				setState(1997);
12710 				match(T__98);
12711 				}
12712 				break;
12713 			case 4:
12714 				enterOuterAlt(_localctx, 4);
12715 				{
12716 				setState(1999);
12717 				match(T__109);
12718 				setState(2000);
12719 				match(T__69);
12720 				setState(2001);
12721 				match(T__82);
12722 				}
12723 				break;
12724 			}
12725 		}
12726 		catch (RecognitionException re) {
12727 			_localctx.exception = re;
12728 			_errHandler.reportError(this, re);
12729 			_errHandler.recover(this, re);
12730 		}
12731 		finally {
12732 			exitRule();
12733 		}
12734 		return _localctx;
12735 	}
12736 
12737 	public static class SuperclassExpressionContext extends ParserRuleContext {
12738 		public SuperclassMethodExpressionContext superclassMethodExpression() {
12739 			return getRuleContext(SuperclassMethodExpressionContext.class,0);
12740 		}
12741 		public SuperclassSubscriptExpressionContext superclassSubscriptExpression() {
12742 			return getRuleContext(SuperclassSubscriptExpressionContext.class,0);
12743 		}
12744 		public SuperclassInitializerExpressionContext superclassInitializerExpression() {
12745 			return getRuleContext(SuperclassInitializerExpressionContext.class,0);
12746 		}
12747 		public SuperclassExpressionContext(ParserRuleContext parent, int invokingState) {
12748 			super(parent, invokingState);
12749 		}
12750 		@Override public int getRuleIndex() { return RULE_superclassExpression; }
12751 		@Override
12752 		public void enterRule(ParseTreeListener listener) {
12753 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSuperclassExpression(this);
12754 		}
12755 		@Override
12756 		public void exitRule(ParseTreeListener listener) {
12757 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSuperclassExpression(this);
12758 		}
12759 	}
12760 
12761 	public final SuperclassExpressionContext superclassExpression() throws RecognitionException {
12762 		SuperclassExpressionContext _localctx = new SuperclassExpressionContext(_ctx, getState());
12763 		enterRule(_localctx, 382, RULE_superclassExpression);
12764 		try {
12765 			setState(2007);
12766 			_errHandler.sync(this);
12767 			switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) {
12768 			case 1:
12769 				enterOuterAlt(_localctx, 1);
12770 				{
12771 				setState(2004);
12772 				superclassMethodExpression();
12773 				}
12774 				break;
12775 			case 2:
12776 				enterOuterAlt(_localctx, 2);
12777 				{
12778 				setState(2005);
12779 				superclassSubscriptExpression();
12780 				}
12781 				break;
12782 			case 3:
12783 				enterOuterAlt(_localctx, 3);
12784 				{
12785 				setState(2006);
12786 				superclassInitializerExpression();
12787 				}
12788 				break;
12789 			}
12790 		}
12791 		catch (RecognitionException re) {
12792 			_localctx.exception = re;
12793 			_errHandler.reportError(this, re);
12794 			_errHandler.recover(this, re);
12795 		}
12796 		finally {
12797 			exitRule();
12798 		}
12799 		return _localctx;
12800 	}
12801 
12802 	public static class SuperclassMethodExpressionContext extends ParserRuleContext {
12803 		public IdentifierContext identifier() {
12804 			return getRuleContext(IdentifierContext.class,0);
12805 		}
12806 		public SuperclassMethodExpressionContext(ParserRuleContext parent, int invokingState) {
12807 			super(parent, invokingState);
12808 		}
12809 		@Override public int getRuleIndex() { return RULE_superclassMethodExpression; }
12810 		@Override
12811 		public void enterRule(ParseTreeListener listener) {
12812 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSuperclassMethodExpression(this);
12813 		}
12814 		@Override
12815 		public void exitRule(ParseTreeListener listener) {
12816 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSuperclassMethodExpression(this);
12817 		}
12818 	}
12819 
12820 	public final SuperclassMethodExpressionContext superclassMethodExpression() throws RecognitionException {
12821 		SuperclassMethodExpressionContext _localctx = new SuperclassMethodExpressionContext(_ctx, getState());
12822 		enterRule(_localctx, 384, RULE_superclassMethodExpression);
12823 		try {
12824 			enterOuterAlt(_localctx, 1);
12825 			{
12826 			setState(2009);
12827 			match(T__110);
12828 			setState(2010);
12829 			match(T__69);
12830 			setState(2011);
12831 			identifier();
12832 			}
12833 		}
12834 		catch (RecognitionException re) {
12835 			_localctx.exception = re;
12836 			_errHandler.reportError(this, re);
12837 			_errHandler.recover(this, re);
12838 		}
12839 		finally {
12840 			exitRule();
12841 		}
12842 		return _localctx;
12843 	}
12844 
12845 	public static class SuperclassSubscriptExpressionContext extends ParserRuleContext {
12846 		public ExpressionListContext expressionList() {
12847 			return getRuleContext(ExpressionListContext.class,0);
12848 		}
12849 		public SuperclassSubscriptExpressionContext(ParserRuleContext parent, int invokingState) {
12850 			super(parent, invokingState);
12851 		}
12852 		@Override public int getRuleIndex() { return RULE_superclassSubscriptExpression; }
12853 		@Override
12854 		public void enterRule(ParseTreeListener listener) {
12855 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSuperclassSubscriptExpression(this);
12856 		}
12857 		@Override
12858 		public void exitRule(ParseTreeListener listener) {
12859 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSuperclassSubscriptExpression(this);
12860 		}
12861 	}
12862 
12863 	public final SuperclassSubscriptExpressionContext superclassSubscriptExpression() throws RecognitionException {
12864 		SuperclassSubscriptExpressionContext _localctx = new SuperclassSubscriptExpressionContext(_ctx, getState());
12865 		enterRule(_localctx, 386, RULE_superclassSubscriptExpression);
12866 		try {
12867 			enterOuterAlt(_localctx, 1);
12868 			{
12869 			setState(2013);
12870 			match(T__110);
12871 			setState(2014);
12872 			match(T__97);
12873 			setState(2015);
12874 			expressionList();
12875 			setState(2016);
12876 			match(T__98);
12877 			}
12878 		}
12879 		catch (RecognitionException re) {
12880 			_localctx.exception = re;
12881 			_errHandler.reportError(this, re);
12882 			_errHandler.recover(this, re);
12883 		}
12884 		finally {
12885 			exitRule();
12886 		}
12887 		return _localctx;
12888 	}
12889 
12890 	public static class SuperclassInitializerExpressionContext extends ParserRuleContext {
12891 		public SuperclassInitializerExpressionContext(ParserRuleContext parent, int invokingState) {
12892 			super(parent, invokingState);
12893 		}
12894 		@Override public int getRuleIndex() { return RULE_superclassInitializerExpression; }
12895 		@Override
12896 		public void enterRule(ParseTreeListener listener) {
12897 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSuperclassInitializerExpression(this);
12898 		}
12899 		@Override
12900 		public void exitRule(ParseTreeListener listener) {
12901 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSuperclassInitializerExpression(this);
12902 		}
12903 	}
12904 
12905 	public final SuperclassInitializerExpressionContext superclassInitializerExpression() throws RecognitionException {
12906 		SuperclassInitializerExpressionContext _localctx = new SuperclassInitializerExpressionContext(_ctx, getState());
12907 		enterRule(_localctx, 388, RULE_superclassInitializerExpression);
12908 		try {
12909 			enterOuterAlt(_localctx, 1);
12910 			{
12911 			setState(2018);
12912 			match(T__110);
12913 			setState(2019);
12914 			match(T__69);
12915 			setState(2020);
12916 			match(T__82);
12917 			}
12918 		}
12919 		catch (RecognitionException re) {
12920 			_localctx.exception = re;
12921 			_errHandler.reportError(this, re);
12922 			_errHandler.recover(this, re);
12923 		}
12924 		finally {
12925 			exitRule();
12926 		}
12927 		return _localctx;
12928 	}
12929 
12930 	public static class ClosureExpressionContext extends ParserRuleContext {
12931 		public ClosureSignatureContext closureSignature() {
12932 			return getRuleContext(ClosureSignatureContext.class,0);
12933 		}
12934 		public StatementsContext statements() {
12935 			return getRuleContext(StatementsContext.class,0);
12936 		}
12937 		public ClosureExpressionContext(ParserRuleContext parent, int invokingState) {
12938 			super(parent, invokingState);
12939 		}
12940 		@Override public int getRuleIndex() { return RULE_closureExpression; }
12941 		@Override
12942 		public void enterRule(ParseTreeListener listener) {
12943 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterClosureExpression(this);
12944 		}
12945 		@Override
12946 		public void exitRule(ParseTreeListener listener) {
12947 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitClosureExpression(this);
12948 		}
12949 	}
12950 
12951 	public final ClosureExpressionContext closureExpression() throws RecognitionException {
12952 		ClosureExpressionContext _localctx = new ClosureExpressionContext(_ctx, getState());
12953 		enterRule(_localctx, 390, RULE_closureExpression);
12954 		int _la;
12955 		try {
12956 			enterOuterAlt(_localctx, 1);
12957 			{
12958 			setState(2022);
12959 			match(T__13);
12960 			setState(2024);
12961 			_errHandler.sync(this);
12962 			switch ( getInterpreter().adaptivePredict(_input,253,_ctx) ) {
12963 			case 1:
12964 				{
12965 				setState(2023);
12966 				closureSignature();
12967 				}
12968 				break;
12969 			}
12970 			setState(2027);
12971 			_la = _input.LA(1);
12972 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
12973 				{
12974 				setState(2026);
12975 				statements();
12976 				}
12977 			}
12978 
12979 			setState(2029);
12980 			match(T__14);
12981 			}
12982 		}
12983 		catch (RecognitionException re) {
12984 			_localctx.exception = re;
12985 			_errHandler.reportError(this, re);
12986 			_errHandler.recover(this, re);
12987 		}
12988 		finally {
12989 			exitRule();
12990 		}
12991 		return _localctx;
12992 	}
12993 
12994 	public static class ClosureSignatureContext extends ParserRuleContext {
12995 		public ParameterClauseContext parameterClause() {
12996 			return getRuleContext(ParameterClauseContext.class,0);
12997 		}
12998 		public FunctionResultContext functionResult() {
12999 			return getRuleContext(FunctionResultContext.class,0);
13000 		}
13001 		public IdentifierListContext identifierList() {
13002 			return getRuleContext(IdentifierListContext.class,0);
13003 		}
13004 		public CaptureListContext captureList() {
13005 			return getRuleContext(CaptureListContext.class,0);
13006 		}
13007 		public ClosureSignatureContext(ParserRuleContext parent, int invokingState) {
13008 			super(parent, invokingState);
13009 		}
13010 		@Override public int getRuleIndex() { return RULE_closureSignature; }
13011 		@Override
13012 		public void enterRule(ParseTreeListener listener) {
13013 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterClosureSignature(this);
13014 		}
13015 		@Override
13016 		public void exitRule(ParseTreeListener listener) {
13017 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitClosureSignature(this);
13018 		}
13019 	}
13020 
13021 	public final ClosureSignatureContext closureSignature() throws RecognitionException {
13022 		ClosureSignatureContext _localctx = new ClosureSignatureContext(_ctx, getState());
13023 		enterRule(_localctx, 392, RULE_closureSignature);
13024 		int _la;
13025 		try {
13026 			setState(2060);
13027 			_errHandler.sync(this);
13028 			switch ( getInterpreter().adaptivePredict(_input,259,_ctx) ) {
13029 			case 1:
13030 				enterOuterAlt(_localctx, 1);
13031 				{
13032 				setState(2031);
13033 				parameterClause();
13034 				setState(2033);
13035 				_la = _input.LA(1);
13036 				if (_la==T__76) {
13037 					{
13038 					setState(2032);
13039 					functionResult();
13040 					}
13041 				}
13042 
13043 				setState(2035);
13044 				match(T__6);
13045 				}
13046 				break;
13047 			case 2:
13048 				enterOuterAlt(_localctx, 2);
13049 				{
13050 				setState(2037);
13051 				identifierList();
13052 				setState(2039);
13053 				_la = _input.LA(1);
13054 				if (_la==T__76) {
13055 					{
13056 					setState(2038);
13057 					functionResult();
13058 					}
13059 				}
13060 
13061 				setState(2041);
13062 				match(T__6);
13063 				}
13064 				break;
13065 			case 3:
13066 				enterOuterAlt(_localctx, 3);
13067 				{
13068 				setState(2043);
13069 				captureList();
13070 				setState(2044);
13071 				parameterClause();
13072 				setState(2046);
13073 				_la = _input.LA(1);
13074 				if (_la==T__76) {
13075 					{
13076 					setState(2045);
13077 					functionResult();
13078 					}
13079 				}
13080 
13081 				setState(2048);
13082 				match(T__6);
13083 				}
13084 				break;
13085 			case 4:
13086 				enterOuterAlt(_localctx, 4);
13087 				{
13088 				setState(2050);
13089 				captureList();
13090 				setState(2051);
13091 				identifierList();
13092 				setState(2053);
13093 				_la = _input.LA(1);
13094 				if (_la==T__76) {
13095 					{
13096 					setState(2052);
13097 					functionResult();
13098 					}
13099 				}
13100 
13101 				setState(2055);
13102 				match(T__6);
13103 				}
13104 				break;
13105 			case 5:
13106 				enterOuterAlt(_localctx, 5);
13107 				{
13108 				setState(2057);
13109 				captureList();
13110 				setState(2058);
13111 				match(T__6);
13112 				}
13113 				break;
13114 			}
13115 		}
13116 		catch (RecognitionException re) {
13117 			_localctx.exception = re;
13118 			_errHandler.reportError(this, re);
13119 			_errHandler.recover(this, re);
13120 		}
13121 		finally {
13122 			exitRule();
13123 		}
13124 		return _localctx;
13125 	}
13126 
13127 	public static class CaptureListContext extends ParserRuleContext {
13128 		public CaptureListItemsContext captureListItems() {
13129 			return getRuleContext(CaptureListItemsContext.class,0);
13130 		}
13131 		public CaptureListContext(ParserRuleContext parent, int invokingState) {
13132 			super(parent, invokingState);
13133 		}
13134 		@Override public int getRuleIndex() { return RULE_captureList; }
13135 		@Override
13136 		public void enterRule(ParseTreeListener listener) {
13137 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaptureList(this);
13138 		}
13139 		@Override
13140 		public void exitRule(ParseTreeListener listener) {
13141 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaptureList(this);
13142 		}
13143 	}
13144 
13145 	public final CaptureListContext captureList() throws RecognitionException {
13146 		CaptureListContext _localctx = new CaptureListContext(_ctx, getState());
13147 		enterRule(_localctx, 394, RULE_captureList);
13148 		try {
13149 			enterOuterAlt(_localctx, 1);
13150 			{
13151 			setState(2062);
13152 			match(T__97);
13153 			setState(2063);
13154 			captureListItems();
13155 			setState(2064);
13156 			match(T__98);
13157 			}
13158 		}
13159 		catch (RecognitionException re) {
13160 			_localctx.exception = re;
13161 			_errHandler.reportError(this, re);
13162 			_errHandler.recover(this, re);
13163 		}
13164 		finally {
13165 			exitRule();
13166 		}
13167 		return _localctx;
13168 	}
13169 
13170 	public static class CaptureListItemsContext extends ParserRuleContext {
13171 		public List<CaptureListItemContext> captureListItem() {
13172 			return getRuleContexts(CaptureListItemContext.class);
13173 		}
13174 		public CaptureListItemContext captureListItem(int i) {
13175 			return getRuleContext(CaptureListItemContext.class,i);
13176 		}
13177 		public CaptureListItemsContext(ParserRuleContext parent, int invokingState) {
13178 			super(parent, invokingState);
13179 		}
13180 		@Override public int getRuleIndex() { return RULE_captureListItems; }
13181 		@Override
13182 		public void enterRule(ParseTreeListener listener) {
13183 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaptureListItems(this);
13184 		}
13185 		@Override
13186 		public void exitRule(ParseTreeListener listener) {
13187 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaptureListItems(this);
13188 		}
13189 	}
13190 
13191 	public final CaptureListItemsContext captureListItems() throws RecognitionException {
13192 		CaptureListItemsContext _localctx = new CaptureListItemsContext(_ctx, getState());
13193 		enterRule(_localctx, 396, RULE_captureListItems);
13194 		int _la;
13195 		try {
13196 			enterOuterAlt(_localctx, 1);
13197 			{
13198 			setState(2066);
13199 			captureListItem();
13200 			setState(2069);
13201 			_la = _input.LA(1);
13202 			if (_la==T__15) {
13203 				{
13204 				setState(2067);
13205 				match(T__15);
13206 				setState(2068);
13207 				captureListItem();
13208 				}
13209 			}
13210 
13211 			}
13212 		}
13213 		catch (RecognitionException re) {
13214 			_localctx.exception = re;
13215 			_errHandler.reportError(this, re);
13216 			_errHandler.recover(this, re);
13217 		}
13218 		finally {
13219 			exitRule();
13220 		}
13221 		return _localctx;
13222 	}
13223 
13224 	public static class CaptureListItemContext extends ParserRuleContext {
13225 		public ExpressionContext expression() {
13226 			return getRuleContext(ExpressionContext.class,0);
13227 		}
13228 		public CaptureSpecifierContext captureSpecifier() {
13229 			return getRuleContext(CaptureSpecifierContext.class,0);
13230 		}
13231 		public CaptureListItemContext(ParserRuleContext parent, int invokingState) {
13232 			super(parent, invokingState);
13233 		}
13234 		@Override public int getRuleIndex() { return RULE_captureListItem; }
13235 		@Override
13236 		public void enterRule(ParseTreeListener listener) {
13237 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaptureListItem(this);
13238 		}
13239 		@Override
13240 		public void exitRule(ParseTreeListener listener) {
13241 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaptureListItem(this);
13242 		}
13243 	}
13244 
13245 	public final CaptureListItemContext captureListItem() throws RecognitionException {
13246 		CaptureListItemContext _localctx = new CaptureListItemContext(_ctx, getState());
13247 		enterRule(_localctx, 398, RULE_captureListItem);
13248 		try {
13249 			enterOuterAlt(_localctx, 1);
13250 			{
13251 			setState(2072);
13252 			_errHandler.sync(this);
13253 			switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) {
13254 			case 1:
13255 				{
13256 				setState(2071);
13257 				captureSpecifier();
13258 				}
13259 				break;
13260 			}
13261 			setState(2074);
13262 			expression();
13263 			}
13264 		}
13265 		catch (RecognitionException re) {
13266 			_localctx.exception = re;
13267 			_errHandler.reportError(this, re);
13268 			_errHandler.recover(this, re);
13269 		}
13270 		finally {
13271 			exitRule();
13272 		}
13273 		return _localctx;
13274 	}
13275 
13276 	public static class CaptureSpecifierContext extends ParserRuleContext {
13277 		public CaptureSpecifierContext(ParserRuleContext parent, int invokingState) {
13278 			super(parent, invokingState);
13279 		}
13280 		@Override public int getRuleIndex() { return RULE_captureSpecifier; }
13281 		@Override
13282 		public void enterRule(ParseTreeListener listener) {
13283 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCaptureSpecifier(this);
13284 		}
13285 		@Override
13286 		public void exitRule(ParseTreeListener listener) {
13287 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCaptureSpecifier(this);
13288 		}
13289 	}
13290 
13291 	public final CaptureSpecifierContext captureSpecifier() throws RecognitionException {
13292 		CaptureSpecifierContext _localctx = new CaptureSpecifierContext(_ctx, getState());
13293 		enterRule(_localctx, 400, RULE_captureSpecifier);
13294 		int _la;
13295 		try {
13296 			enterOuterAlt(_localctx, 1);
13297 			{
13298 			setState(2076);
13299 			_la = _input.LA(1);
13300 			if ( !(((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & ((1L << (T__55 - 56)) | (1L << (T__58 - 56)) | (1L << (T__111 - 56)) | (1L << (T__112 - 56)))) != 0)) ) {
13301 			_errHandler.recoverInline(this);
13302 			} else {
13303 				consume();
13304 			}
13305 			}
13306 		}
13307 		catch (RecognitionException re) {
13308 			_localctx.exception = re;
13309 			_errHandler.reportError(this, re);
13310 			_errHandler.recover(this, re);
13311 		}
13312 		finally {
13313 			exitRule();
13314 		}
13315 		return _localctx;
13316 	}
13317 
13318 	public static class ImplicitMemberExpressionContext extends ParserRuleContext {
13319 		public IdentifierContext identifier() {
13320 			return getRuleContext(IdentifierContext.class,0);
13321 		}
13322 		public ImplicitMemberExpressionContext(ParserRuleContext parent, int invokingState) {
13323 			super(parent, invokingState);
13324 		}
13325 		@Override public int getRuleIndex() { return RULE_implicitMemberExpression; }
13326 		@Override
13327 		public void enterRule(ParseTreeListener listener) {
13328 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterImplicitMemberExpression(this);
13329 		}
13330 		@Override
13331 		public void exitRule(ParseTreeListener listener) {
13332 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitImplicitMemberExpression(this);
13333 		}
13334 	}
13335 
13336 	public final ImplicitMemberExpressionContext implicitMemberExpression() throws RecognitionException {
13337 		ImplicitMemberExpressionContext _localctx = new ImplicitMemberExpressionContext(_ctx, getState());
13338 		enterRule(_localctx, 402, RULE_implicitMemberExpression);
13339 		try {
13340 			enterOuterAlt(_localctx, 1);
13341 			{
13342 			setState(2078);
13343 			match(T__69);
13344 			setState(2079);
13345 			identifier();
13346 			}
13347 		}
13348 		catch (RecognitionException re) {
13349 			_localctx.exception = re;
13350 			_errHandler.reportError(this, re);
13351 			_errHandler.recover(this, re);
13352 		}
13353 		finally {
13354 			exitRule();
13355 		}
13356 		return _localctx;
13357 	}
13358 
13359 	public static class ParenthesizedExpressionContext extends ParserRuleContext {
13360 		public ExpressionElementListContext expressionElementList() {
13361 			return getRuleContext(ExpressionElementListContext.class,0);
13362 		}
13363 		public ParenthesizedExpressionContext(ParserRuleContext parent, int invokingState) {
13364 			super(parent, invokingState);
13365 		}
13366 		@Override public int getRuleIndex() { return RULE_parenthesizedExpression; }
13367 		@Override
13368 		public void enterRule(ParseTreeListener listener) {
13369 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterParenthesizedExpression(this);
13370 		}
13371 		@Override
13372 		public void exitRule(ParseTreeListener listener) {
13373 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitParenthesizedExpression(this);
13374 		}
13375 	}
13376 
13377 	public final ParenthesizedExpressionContext parenthesizedExpression() throws RecognitionException {
13378 		ParenthesizedExpressionContext _localctx = new ParenthesizedExpressionContext(_ctx, getState());
13379 		enterRule(_localctx, 404, RULE_parenthesizedExpression);
13380 		int _la;
13381 		try {
13382 			enterOuterAlt(_localctx, 1);
13383 			{
13384 			setState(2081);
13385 			match(T__3);
13386 			setState(2083);
13387 			_la = _input.LA(1);
13388 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__13) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (T__69 - 70)) | (1L << (T__70 - 70)) | (1L << (T__71 - 70)) | (1L << (T__72 - 70)) | (1L << (T__73 - 70)) | (1L << (T__77 - 70)) | (1L << (T__80 - 70)) | (1L << (T__81 - 70)) | (1L << (T__83 - 70)) | (1L << (T__84 - 70)) | (1L << (T__88 - 70)) | (1L << (T__89 - 70)) | (1L << (T__90 - 70)) | (1L << (T__91 - 70)) | (1L << (T__92 - 70)) | (1L << (T__93 - 70)) | (1L << (T__97 - 70)) | (1L << (T__99 - 70)) | (1L << (T__101 - 70)) | (1L << (T__103 - 70)) | (1L << (T__104 - 70)) | (1L << (T__105 - 70)) | (1L << (T__106 - 70)) | (1L << (T__107 - 70)) | (1L << (T__108 - 70)) | (1L << (T__109 - 70)) | (1L << (T__110 - 70)) | (1L << (T__114 - 70)) | (1L << (T__115 - 70)) | (1L << (T__116 - 70)) | (1L << (T__117 - 70)) | (1L << (T__123 - 70)) | (1L << (T__124 - 70)) | (1L << (T__125 - 70)) | (1L << (T__126 - 70)) | (1L << (T__127 - 70)) | (1L << (T__128 - 70)) | (1L << (T__130 - 70)) | (1L << (BooleanLiteral - 70)) | (1L << (NilLiteral - 70)))) != 0) || ((((_la - 134)) & ~0x3f) == 0 && ((1L << (_la - 134)) & ((1L << (OperatorHead - 134)) | (1L << (DotOperatorHead - 134)) | (1L << (Identifier - 134)) | (1L << (BinaryLiteral - 134)) | (1L << (OctalLiteral - 134)) | (1L << (DecimalLiteral - 134)) | (1L << (HexadecimalLiteral - 134)) | (1L << (FloatingPointLiteral - 134)) | (1L << (StringLiteral - 134)))) != 0)) {
13389 				{
13390 				setState(2082);
13391 				expressionElementList();
13392 				}
13393 			}
13394 
13395 			setState(2085);
13396 			match(T__4);
13397 			}
13398 		}
13399 		catch (RecognitionException re) {
13400 			_localctx.exception = re;
13401 			_errHandler.reportError(this, re);
13402 			_errHandler.recover(this, re);
13403 		}
13404 		finally {
13405 			exitRule();
13406 		}
13407 		return _localctx;
13408 	}
13409 
13410 	public static class ExpressionElementListContext extends ParserRuleContext {
13411 		public List<ExpressionElementContext> expressionElement() {
13412 			return getRuleContexts(ExpressionElementContext.class);
13413 		}
13414 		public ExpressionElementContext expressionElement(int i) {
13415 			return getRuleContext(ExpressionElementContext.class,i);
13416 		}
13417 		public ExpressionElementListContext(ParserRuleContext parent, int invokingState) {
13418 			super(parent, invokingState);
13419 		}
13420 		@Override public int getRuleIndex() { return RULE_expressionElementList; }
13421 		@Override
13422 		public void enterRule(ParseTreeListener listener) {
13423 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExpressionElementList(this);
13424 		}
13425 		@Override
13426 		public void exitRule(ParseTreeListener listener) {
13427 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExpressionElementList(this);
13428 		}
13429 	}
13430 
13431 	public final ExpressionElementListContext expressionElementList() throws RecognitionException {
13432 		ExpressionElementListContext _localctx = new ExpressionElementListContext(_ctx, getState());
13433 		enterRule(_localctx, 406, RULE_expressionElementList);
13434 		int _la;
13435 		try {
13436 			enterOuterAlt(_localctx, 1);
13437 			{
13438 			setState(2087);
13439 			expressionElement();
13440 			setState(2092);
13441 			_errHandler.sync(this);
13442 			_la = _input.LA(1);
13443 			while (_la==T__15) {
13444 				{
13445 				{
13446 				setState(2088);
13447 				match(T__15);
13448 				setState(2089);
13449 				expressionElement();
13450 				}
13451 				}
13452 				setState(2094);
13453 				_errHandler.sync(this);
13454 				_la = _input.LA(1);
13455 			}
13456 			}
13457 		}
13458 		catch (RecognitionException re) {
13459 			_localctx.exception = re;
13460 			_errHandler.reportError(this, re);
13461 			_errHandler.recover(this, re);
13462 		}
13463 		finally {
13464 			exitRule();
13465 		}
13466 		return _localctx;
13467 	}
13468 
13469 	public static class ExpressionElementContext extends ParserRuleContext {
13470 		public ExpressionContext expression() {
13471 			return getRuleContext(ExpressionContext.class,0);
13472 		}
13473 		public IdentifierContext identifier() {
13474 			return getRuleContext(IdentifierContext.class,0);
13475 		}
13476 		public ExpressionElementContext(ParserRuleContext parent, int invokingState) {
13477 			super(parent, invokingState);
13478 		}
13479 		@Override public int getRuleIndex() { return RULE_expressionElement; }
13480 		@Override
13481 		public void enterRule(ParseTreeListener listener) {
13482 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExpressionElement(this);
13483 		}
13484 		@Override
13485 		public void exitRule(ParseTreeListener listener) {
13486 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExpressionElement(this);
13487 		}
13488 	}
13489 
13490 	public final ExpressionElementContext expressionElement() throws RecognitionException {
13491 		ExpressionElementContext _localctx = new ExpressionElementContext(_ctx, getState());
13492 		enterRule(_localctx, 408, RULE_expressionElement);
13493 		try {
13494 			setState(2100);
13495 			_errHandler.sync(this);
13496 			switch ( getInterpreter().adaptivePredict(_input,264,_ctx) ) {
13497 			case 1:
13498 				enterOuterAlt(_localctx, 1);
13499 				{
13500 				setState(2095);
13501 				expression();
13502 				}
13503 				break;
13504 			case 2:
13505 				enterOuterAlt(_localctx, 2);
13506 				{
13507 				setState(2096);
13508 				identifier();
13509 				setState(2097);
13510 				match(T__1);
13511 				setState(2098);
13512 				expression();
13513 				}
13514 				break;
13515 			}
13516 		}
13517 		catch (RecognitionException re) {
13518 			_localctx.exception = re;
13519 			_errHandler.reportError(this, re);
13520 			_errHandler.recover(this, re);
13521 		}
13522 		finally {
13523 			exitRule();
13524 		}
13525 		return _localctx;
13526 	}
13527 
13528 	public static class WildcardExpressionContext extends ParserRuleContext {
13529 		public WildcardExpressionContext(ParserRuleContext parent, int invokingState) {
13530 			super(parent, invokingState);
13531 		}
13532 		@Override public int getRuleIndex() { return RULE_wildcardExpression; }
13533 		@Override
13534 		public void enterRule(ParseTreeListener listener) {
13535 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterWildcardExpression(this);
13536 		}
13537 		@Override
13538 		public void exitRule(ParseTreeListener listener) {
13539 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitWildcardExpression(this);
13540 		}
13541 	}
13542 
13543 	public final WildcardExpressionContext wildcardExpression() throws RecognitionException {
13544 		WildcardExpressionContext _localctx = new WildcardExpressionContext(_ctx, getState());
13545 		enterRule(_localctx, 410, RULE_wildcardExpression);
13546 		try {
13547 			enterOuterAlt(_localctx, 1);
13548 			{
13549 			setState(2102);
13550 			match(T__80);
13551 			}
13552 		}
13553 		catch (RecognitionException re) {
13554 			_localctx.exception = re;
13555 			_errHandler.reportError(this, re);
13556 			_errHandler.recover(this, re);
13557 		}
13558 		finally {
13559 			exitRule();
13560 		}
13561 		return _localctx;
13562 	}
13563 
13564 	public static class PostfixExpressionContext extends ParserRuleContext {
13565 		public PostfixExpressionContext(ParserRuleContext parent, int invokingState) {
13566 			super(parent, invokingState);
13567 		}
13568 		@Override public int getRuleIndex() { return RULE_postfixExpression; }
13569 	 
13570 		public PostfixExpressionContext() { }
13571 		public void copyFrom(PostfixExpressionContext ctx) {
13572 			super.copyFrom(ctx);
13573 		}
13574 	}
13575 	public static class ExplicitMemberExpression1Context extends PostfixExpressionContext {
13576 		public PostfixExpressionContext postfixExpression() {
13577 			return getRuleContext(PostfixExpressionContext.class,0);
13578 		}
13579 		public TerminalNode DecimalLiteral() { return getToken(SwiftParser.DecimalLiteral, 0); }
13580 		public ExplicitMemberExpression1Context(PostfixExpressionContext ctx) { copyFrom(ctx); }
13581 		@Override
13582 		public void enterRule(ParseTreeListener listener) {
13583 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExplicitMemberExpression1(this);
13584 		}
13585 		@Override
13586 		public void exitRule(ParseTreeListener listener) {
13587 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExplicitMemberExpression1(this);
13588 		}
13589 	}
13590 	public static class DynamicTypeExpressionContext extends PostfixExpressionContext {
13591 		public PostfixExpressionContext postfixExpression() {
13592 			return getRuleContext(PostfixExpressionContext.class,0);
13593 		}
13594 		public DynamicTypeExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13595 		@Override
13596 		public void enterRule(ParseTreeListener listener) {
13597 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDynamicTypeExpression(this);
13598 		}
13599 		@Override
13600 		public void exitRule(ParseTreeListener listener) {
13601 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDynamicTypeExpression(this);
13602 		}
13603 	}
13604 	public static class PostfixOperationContext extends PostfixExpressionContext {
13605 		public PostfixExpressionContext postfixExpression() {
13606 			return getRuleContext(PostfixExpressionContext.class,0);
13607 		}
13608 		public PostfixOperatorContext postfixOperator() {
13609 			return getRuleContext(PostfixOperatorContext.class,0);
13610 		}
13611 		public PostfixOperationContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13612 		@Override
13613 		public void enterRule(ParseTreeListener listener) {
13614 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPostfixOperation(this);
13615 		}
13616 		@Override
13617 		public void exitRule(ParseTreeListener listener) {
13618 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPostfixOperation(this);
13619 		}
13620 	}
13621 	public static class FunctionCallWithClosureExpressionContext extends PostfixExpressionContext {
13622 		public PostfixExpressionContext postfixExpression() {
13623 			return getRuleContext(PostfixExpressionContext.class,0);
13624 		}
13625 		public ClosureExpressionContext closureExpression() {
13626 			return getRuleContext(ClosureExpressionContext.class,0);
13627 		}
13628 		public ParenthesizedExpressionContext parenthesizedExpression() {
13629 			return getRuleContext(ParenthesizedExpressionContext.class,0);
13630 		}
13631 		public FunctionCallWithClosureExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13632 		@Override
13633 		public void enterRule(ParseTreeListener listener) {
13634 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionCallWithClosureExpression(this);
13635 		}
13636 		@Override
13637 		public void exitRule(ParseTreeListener listener) {
13638 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionCallWithClosureExpression(this);
13639 		}
13640 	}
13641 	public static class InitializerExpressionContext extends PostfixExpressionContext {
13642 		public PostfixExpressionContext postfixExpression() {
13643 			return getRuleContext(PostfixExpressionContext.class,0);
13644 		}
13645 		public InitializerExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13646 		@Override
13647 		public void enterRule(ParseTreeListener listener) {
13648 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterInitializerExpression(this);
13649 		}
13650 		@Override
13651 		public void exitRule(ParseTreeListener listener) {
13652 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitInitializerExpression(this);
13653 		}
13654 	}
13655 	public static class SubscriptExpressionContext extends PostfixExpressionContext {
13656 		public PostfixExpressionContext postfixExpression() {
13657 			return getRuleContext(PostfixExpressionContext.class,0);
13658 		}
13659 		public ExpressionListContext expressionList() {
13660 			return getRuleContext(ExpressionListContext.class,0);
13661 		}
13662 		public SubscriptExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13663 		@Override
13664 		public void enterRule(ParseTreeListener listener) {
13665 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSubscriptExpression(this);
13666 		}
13667 		@Override
13668 		public void exitRule(ParseTreeListener listener) {
13669 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSubscriptExpression(this);
13670 		}
13671 	}
13672 	public static class ForcedValueExpressionContext extends PostfixExpressionContext {
13673 		public PostfixExpressionContext postfixExpression() {
13674 			return getRuleContext(PostfixExpressionContext.class,0);
13675 		}
13676 		public ForcedValueExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13677 		@Override
13678 		public void enterRule(ParseTreeListener listener) {
13679 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterForcedValueExpression(this);
13680 		}
13681 		@Override
13682 		public void exitRule(ParseTreeListener listener) {
13683 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitForcedValueExpression(this);
13684 		}
13685 	}
13686 	public static class ExplicitMemberExpression2Context extends PostfixExpressionContext {
13687 		public PostfixExpressionContext postfixExpression() {
13688 			return getRuleContext(PostfixExpressionContext.class,0);
13689 		}
13690 		public IdentifierContext identifier() {
13691 			return getRuleContext(IdentifierContext.class,0);
13692 		}
13693 		public GenericArgumentClauseContext genericArgumentClause() {
13694 			return getRuleContext(GenericArgumentClauseContext.class,0);
13695 		}
13696 		public ExplicitMemberExpression2Context(PostfixExpressionContext ctx) { copyFrom(ctx); }
13697 		@Override
13698 		public void enterRule(ParseTreeListener listener) {
13699 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterExplicitMemberExpression2(this);
13700 		}
13701 		@Override
13702 		public void exitRule(ParseTreeListener listener) {
13703 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitExplicitMemberExpression2(this);
13704 		}
13705 	}
13706 	public static class FunctionCallExpressionContext extends PostfixExpressionContext {
13707 		public PostfixExpressionContext postfixExpression() {
13708 			return getRuleContext(PostfixExpressionContext.class,0);
13709 		}
13710 		public ParenthesizedExpressionContext parenthesizedExpression() {
13711 			return getRuleContext(ParenthesizedExpressionContext.class,0);
13712 		}
13713 		public FunctionCallExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13714 		@Override
13715 		public void enterRule(ParseTreeListener listener) {
13716 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFunctionCallExpression(this);
13717 		}
13718 		@Override
13719 		public void exitRule(ParseTreeListener listener) {
13720 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFunctionCallExpression(this);
13721 		}
13722 	}
13723 	public static class PostfixSelfExpressionContext extends PostfixExpressionContext {
13724 		public PostfixExpressionContext postfixExpression() {
13725 			return getRuleContext(PostfixExpressionContext.class,0);
13726 		}
13727 		public PostfixSelfExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13728 		@Override
13729 		public void enterRule(ParseTreeListener listener) {
13730 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPostfixSelfExpression(this);
13731 		}
13732 		@Override
13733 		public void exitRule(ParseTreeListener listener) {
13734 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPostfixSelfExpression(this);
13735 		}
13736 	}
13737 	public static class PrimaryContext extends PostfixExpressionContext {
13738 		public PrimaryExpressionContext primaryExpression() {
13739 			return getRuleContext(PrimaryExpressionContext.class,0);
13740 		}
13741 		public PrimaryContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13742 		@Override
13743 		public void enterRule(ParseTreeListener listener) {
13744 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrimary(this);
13745 		}
13746 		@Override
13747 		public void exitRule(ParseTreeListener listener) {
13748 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrimary(this);
13749 		}
13750 	}
13751 	public static class OptionalChainingExpressionContext extends PostfixExpressionContext {
13752 		public PostfixExpressionContext postfixExpression() {
13753 			return getRuleContext(PostfixExpressionContext.class,0);
13754 		}
13755 		public OptionalChainingExpressionContext(PostfixExpressionContext ctx) { copyFrom(ctx); }
13756 		@Override
13757 		public void enterRule(ParseTreeListener listener) {
13758 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOptionalChainingExpression(this);
13759 		}
13760 		@Override
13761 		public void exitRule(ParseTreeListener listener) {
13762 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOptionalChainingExpression(this);
13763 		}
13764 	}
13765 
13766 	public final PostfixExpressionContext postfixExpression() throws RecognitionException {
13767 		return postfixExpression(0);
13768 	}
13769 
13770 	private PostfixExpressionContext postfixExpression(int _p) throws RecognitionException {
13771 		ParserRuleContext _parentctx = _ctx;
13772 		int _parentState = getState();
13773 		PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, _parentState);
13774 		PostfixExpressionContext _prevctx = _localctx;
13775 		int _startState = 412;
13776 		enterRecursionRule(_localctx, 412, RULE_postfixExpression, _p);
13777 		int _la;
13778 		try {
13779 			int _alt;
13780 			enterOuterAlt(_localctx, 1);
13781 			{
13782 			{
13783 			_localctx = new PrimaryContext(_localctx);
13784 			_ctx = _localctx;
13785 			_prevctx = _localctx;
13786 
13787 			setState(2105);
13788 			primaryExpression();
13789 			}
13790 			_ctx.stop = _input.LT(-1);
13791 			setState(2145);
13792 			_errHandler.sync(this);
13793 			_alt = getInterpreter().adaptivePredict(_input,268,_ctx);
13794 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
13795 				if ( _alt==1 ) {
13796 					if ( _parseListeners!=null ) triggerExitRuleEvent();
13797 					_prevctx = _localctx;
13798 					{
13799 					setState(2143);
13800 					_errHandler.sync(this);
13801 					switch ( getInterpreter().adaptivePredict(_input,267,_ctx) ) {
13802 					case 1:
13803 						{
13804 						_localctx = new PostfixOperationContext(new PostfixExpressionContext(_parentctx, _parentState));
13805 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13806 						setState(2107);
13807 						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
13808 						setState(2108);
13809 						postfixOperator();
13810 						}
13811 						break;
13812 					case 2:
13813 						{
13814 						_localctx = new FunctionCallWithClosureExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13815 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13816 						setState(2109);
13817 						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
13818 						setState(2111);
13819 						_la = _input.LA(1);
13820 						if (_la==T__3) {
13821 							{
13822 							setState(2110);
13823 							parenthesizedExpression();
13824 							}
13825 						}
13826 
13827 						setState(2113);
13828 						closureExpression();
13829 						}
13830 						break;
13831 					case 3:
13832 						{
13833 						_localctx = new FunctionCallExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13834 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13835 						setState(2114);
13836 						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
13837 						setState(2115);
13838 						parenthesizedExpression();
13839 						}
13840 						break;
13841 					case 4:
13842 						{
13843 						_localctx = new InitializerExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13844 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13845 						setState(2116);
13846 						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
13847 						setState(2117);
13848 						match(T__69);
13849 						setState(2118);
13850 						match(T__82);
13851 						}
13852 						break;
13853 					case 5:
13854 						{
13855 						_localctx = new ExplicitMemberExpression1Context(new PostfixExpressionContext(_parentctx, _parentState));
13856 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13857 						setState(2119);
13858 						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
13859 						setState(2120);
13860 						match(T__69);
13861 						setState(2121);
13862 						match(DecimalLiteral);
13863 						}
13864 						break;
13865 					case 6:
13866 						{
13867 						_localctx = new ExplicitMemberExpression2Context(new PostfixExpressionContext(_parentctx, _parentState));
13868 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13869 						setState(2122);
13870 						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
13871 						setState(2123);
13872 						match(T__69);
13873 						setState(2124);
13874 						identifier();
13875 						setState(2126);
13876 						_errHandler.sync(this);
13877 						switch ( getInterpreter().adaptivePredict(_input,266,_ctx) ) {
13878 						case 1:
13879 							{
13880 							setState(2125);
13881 							genericArgumentClause();
13882 							}
13883 							break;
13884 						}
13885 						}
13886 						break;
13887 					case 7:
13888 						{
13889 						_localctx = new PostfixSelfExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13890 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13891 						setState(2128);
13892 						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
13893 						setState(2129);
13894 						match(T__69);
13895 						setState(2130);
13896 						match(T__109);
13897 						}
13898 						break;
13899 					case 8:
13900 						{
13901 						_localctx = new DynamicTypeExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13902 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13903 						setState(2131);
13904 						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
13905 						setState(2132);
13906 						match(T__69);
13907 						setState(2133);
13908 						match(T__113);
13909 						}
13910 						break;
13911 					case 9:
13912 						{
13913 						_localctx = new SubscriptExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13914 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13915 						setState(2134);
13916 						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
13917 						setState(2135);
13918 						match(T__97);
13919 						setState(2136);
13920 						expressionList();
13921 						setState(2137);
13922 						match(T__98);
13923 						}
13924 						break;
13925 					case 10:
13926 						{
13927 						_localctx = new ForcedValueExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13928 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13929 						setState(2139);
13930 						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
13931 						setState(2140);
13932 						match(T__84);
13933 						}
13934 						break;
13935 					case 11:
13936 						{
13937 						_localctx = new OptionalChainingExpressionContext(new PostfixExpressionContext(_parentctx, _parentState));
13938 						pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression);
13939 						setState(2141);
13940 						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
13941 						setState(2142);
13942 						match(T__83);
13943 						}
13944 						break;
13945 					}
13946 					} 
13947 				}
13948 				setState(2147);
13949 				_errHandler.sync(this);
13950 				_alt = getInterpreter().adaptivePredict(_input,268,_ctx);
13951 			}
13952 			}
13953 		}
13954 		catch (RecognitionException re) {
13955 			_localctx.exception = re;
13956 			_errHandler.reportError(this, re);
13957 			_errHandler.recover(this, re);
13958 		}
13959 		finally {
13960 			unrollRecursionContexts(_parentctx);
13961 		}
13962 		return _localctx;
13963 	}
13964 
13965 	public static class OperatorHeadContext extends ParserRuleContext {
13966 		public TerminalNode OperatorHead() { return getToken(SwiftParser.OperatorHead, 0); }
13967 		public OperatorHeadContext(ParserRuleContext parent, int invokingState) {
13968 			super(parent, invokingState);
13969 		}
13970 		@Override public int getRuleIndex() { return RULE_operatorHead; }
13971 		@Override
13972 		public void enterRule(ParseTreeListener listener) {
13973 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOperatorHead(this);
13974 		}
13975 		@Override
13976 		public void exitRule(ParseTreeListener listener) {
13977 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOperatorHead(this);
13978 		}
13979 	}
13980 
13981 	public final OperatorHeadContext operatorHead() throws RecognitionException {
13982 		OperatorHeadContext _localctx = new OperatorHeadContext(_ctx, getState());
13983 		enterRule(_localctx, 414, RULE_operatorHead);
13984 		int _la;
13985 		try {
13986 			enterOuterAlt(_localctx, 1);
13987 			{
13988 			setState(2148);
13989 			_la = _input.LA(1);
13990 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__29) | (1L << T__38) | (1L << T__39) | (1L << T__40))) != 0) || ((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__83 - 71)) | (1L << (T__84 - 71)) | (1L << (T__99 - 71)) | (1L << (T__101 - 71)) | (1L << (T__103 - 71)) | (1L << (T__114 - 71)) | (1L << (T__115 - 71)) | (1L << (OperatorHead - 71)))) != 0)) ) {
13991 			_errHandler.recoverInline(this);
13992 			} else {
13993 				consume();
13994 			}
13995 			}
13996 		}
13997 		catch (RecognitionException re) {
13998 			_localctx.exception = re;
13999 			_errHandler.reportError(this, re);
14000 			_errHandler.recover(this, re);
14001 		}
14002 		finally {
14003 			exitRule();
14004 		}
14005 		return _localctx;
14006 	}
14007 
14008 	public static class OperatorCharacterContext extends ParserRuleContext {
14009 		public OperatorHeadContext operatorHead() {
14010 			return getRuleContext(OperatorHeadContext.class,0);
14011 		}
14012 		public TerminalNode OperatorCharacter() { return getToken(SwiftParser.OperatorCharacter, 0); }
14013 		public OperatorCharacterContext(ParserRuleContext parent, int invokingState) {
14014 			super(parent, invokingState);
14015 		}
14016 		@Override public int getRuleIndex() { return RULE_operatorCharacter; }
14017 		@Override
14018 		public void enterRule(ParseTreeListener listener) {
14019 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOperatorCharacter(this);
14020 		}
14021 		@Override
14022 		public void exitRule(ParseTreeListener listener) {
14023 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOperatorCharacter(this);
14024 		}
14025 	}
14026 
14027 	public final OperatorCharacterContext operatorCharacter() throws RecognitionException {
14028 		OperatorCharacterContext _localctx = new OperatorCharacterContext(_ctx, getState());
14029 		enterRule(_localctx, 416, RULE_operatorCharacter);
14030 		try {
14031 			setState(2152);
14032 			switch (_input.LA(1)) {
14033 			case T__29:
14034 			case T__38:
14035 			case T__39:
14036 			case T__40:
14037 			case T__70:
14038 			case T__83:
14039 			case T__84:
14040 			case T__99:
14041 			case T__101:
14042 			case T__103:
14043 			case T__114:
14044 			case T__115:
14045 			case OperatorHead:
14046 				enterOuterAlt(_localctx, 1);
14047 				{
14048 				setState(2150);
14049 				operatorHead();
14050 				}
14051 				break;
14052 			case OperatorCharacter:
14053 				enterOuterAlt(_localctx, 2);
14054 				{
14055 				setState(2151);
14056 				match(OperatorCharacter);
14057 				}
14058 				break;
14059 			default:
14060 				throw new NoViableAltException(this);
14061 			}
14062 		}
14063 		catch (RecognitionException re) {
14064 			_localctx.exception = re;
14065 			_errHandler.reportError(this, re);
14066 			_errHandler.recover(this, re);
14067 		}
14068 		finally {
14069 			exitRule();
14070 		}
14071 		return _localctx;
14072 	}
14073 
14074 	public static class OperatorContext extends ParserRuleContext {
14075 		public OperatorHeadContext operatorHead() {
14076 			return getRuleContext(OperatorHeadContext.class,0);
14077 		}
14078 		public List<OperatorCharacterContext> operatorCharacter() {
14079 			return getRuleContexts(OperatorCharacterContext.class);
14080 		}
14081 		public OperatorCharacterContext operatorCharacter(int i) {
14082 			return getRuleContext(OperatorCharacterContext.class,i);
14083 		}
14084 		public OperatorContext(ParserRuleContext parent, int invokingState) {
14085 			super(parent, invokingState);
14086 		}
14087 		@Override public int getRuleIndex() { return RULE_operator; }
14088 		@Override
14089 		public void enterRule(ParseTreeListener listener) {
14090 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOperator(this);
14091 		}
14092 		@Override
14093 		public void exitRule(ParseTreeListener listener) {
14094 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOperator(this);
14095 		}
14096 	}
14097 
14098 	public final OperatorContext operator() throws RecognitionException {
14099 		OperatorContext _localctx = new OperatorContext(_ctx, getState());
14100 		enterRule(_localctx, 418, RULE_operator);
14101 		try {
14102 			int _alt;
14103 			setState(2169);
14104 			switch (_input.LA(1)) {
14105 			case T__29:
14106 			case T__38:
14107 			case T__39:
14108 			case T__40:
14109 			case T__70:
14110 			case T__83:
14111 			case T__84:
14112 			case T__99:
14113 			case T__101:
14114 			case T__103:
14115 			case T__114:
14116 			case T__115:
14117 			case OperatorHead:
14118 				enterOuterAlt(_localctx, 1);
14119 				{
14120 				setState(2154);
14121 				operatorHead();
14122 				setState(2158);
14123 				_errHandler.sync(this);
14124 				_alt = getInterpreter().adaptivePredict(_input,270,_ctx);
14125 				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14126 					if ( _alt==1 ) {
14127 						{
14128 						{
14129 						setState(2155);
14130 						operatorCharacter();
14131 						}
14132 						} 
14133 					}
14134 					setState(2160);
14135 					_errHandler.sync(this);
14136 					_alt = getInterpreter().adaptivePredict(_input,270,_ctx);
14137 				}
14138 				}
14139 				break;
14140 			case DotOperatorHead:
14141 				enterOuterAlt(_localctx, 2);
14142 				{
14143 				setState(2161);
14144 				match(DotOperatorHead);
14145 				setState(2165);
14146 				_errHandler.sync(this);
14147 				_alt = getInterpreter().adaptivePredict(_input,271,_ctx);
14148 				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14149 					if ( _alt==1 ) {
14150 						{
14151 						{
14152 						setState(2162);
14153 						operatorCharacter();
14154 						}
14155 						} 
14156 					}
14157 					setState(2167);
14158 					_errHandler.sync(this);
14159 					_alt = getInterpreter().adaptivePredict(_input,271,_ctx);
14160 				}
14161 				}
14162 				break;
14163 			case T__77:
14164 				enterOuterAlt(_localctx, 3);
14165 				{
14166 				setState(2168);
14167 				match(T__77);
14168 				}
14169 				break;
14170 			default:
14171 				throw new NoViableAltException(this);
14172 			}
14173 		}
14174 		catch (RecognitionException re) {
14175 			_localctx.exception = re;
14176 			_errHandler.reportError(this, re);
14177 			_errHandler.recover(this, re);
14178 		}
14179 		finally {
14180 			exitRule();
14181 		}
14182 		return _localctx;
14183 	}
14184 
14185 	public static class BinaryOperatorContext extends ParserRuleContext {
14186 		public OperatorContext operator() {
14187 			return getRuleContext(OperatorContext.class,0);
14188 		}
14189 		public BinaryOperatorContext(ParserRuleContext parent, int invokingState) {
14190 			super(parent, invokingState);
14191 		}
14192 		@Override public int getRuleIndex() { return RULE_binaryOperator; }
14193 		@Override
14194 		public void enterRule(ParseTreeListener listener) {
14195 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBinaryOperator(this);
14196 		}
14197 		@Override
14198 		public void exitRule(ParseTreeListener listener) {
14199 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBinaryOperator(this);
14200 		}
14201 	}
14202 
14203 	public final BinaryOperatorContext binaryOperator() throws RecognitionException {
14204 		BinaryOperatorContext _localctx = new BinaryOperatorContext(_ctx, getState());
14205 		enterRule(_localctx, 420, RULE_binaryOperator);
14206 		try {
14207 			enterOuterAlt(_localctx, 1);
14208 			{
14209 			setState(2171);
14210 			operator();
14211 			}
14212 		}
14213 		catch (RecognitionException re) {
14214 			_localctx.exception = re;
14215 			_errHandler.reportError(this, re);
14216 			_errHandler.recover(this, re);
14217 		}
14218 		finally {
14219 			exitRule();
14220 		}
14221 		return _localctx;
14222 	}
14223 
14224 	public static class PrefixOperatorContext extends ParserRuleContext {
14225 		public OperatorContext operator() {
14226 			return getRuleContext(OperatorContext.class,0);
14227 		}
14228 		public PrefixOperatorContext(ParserRuleContext parent, int invokingState) {
14229 			super(parent, invokingState);
14230 		}
14231 		@Override public int getRuleIndex() { return RULE_prefixOperator; }
14232 		@Override
14233 		public void enterRule(ParseTreeListener listener) {
14234 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPrefixOperator(this);
14235 		}
14236 		@Override
14237 		public void exitRule(ParseTreeListener listener) {
14238 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPrefixOperator(this);
14239 		}
14240 	}
14241 
14242 	public final PrefixOperatorContext prefixOperator() throws RecognitionException {
14243 		PrefixOperatorContext _localctx = new PrefixOperatorContext(_ctx, getState());
14244 		enterRule(_localctx, 422, RULE_prefixOperator);
14245 		try {
14246 			enterOuterAlt(_localctx, 1);
14247 			{
14248 			setState(2173);
14249 			operator();
14250 			}
14251 		}
14252 		catch (RecognitionException re) {
14253 			_localctx.exception = re;
14254 			_errHandler.reportError(this, re);
14255 			_errHandler.recover(this, re);
14256 		}
14257 		finally {
14258 			exitRule();
14259 		}
14260 		return _localctx;
14261 	}
14262 
14263 	public static class PostfixOperatorContext extends ParserRuleContext {
14264 		public OperatorContext operator() {
14265 			return getRuleContext(OperatorContext.class,0);
14266 		}
14267 		public PostfixOperatorContext(ParserRuleContext parent, int invokingState) {
14268 			super(parent, invokingState);
14269 		}
14270 		@Override public int getRuleIndex() { return RULE_postfixOperator; }
14271 		@Override
14272 		public void enterRule(ParseTreeListener listener) {
14273 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPostfixOperator(this);
14274 		}
14275 		@Override
14276 		public void exitRule(ParseTreeListener listener) {
14277 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPostfixOperator(this);
14278 		}
14279 	}
14280 
14281 	public final PostfixOperatorContext postfixOperator() throws RecognitionException {
14282 		PostfixOperatorContext _localctx = new PostfixOperatorContext(_ctx, getState());
14283 		enterRule(_localctx, 424, RULE_postfixOperator);
14284 		try {
14285 			enterOuterAlt(_localctx, 1);
14286 			{
14287 			setState(2175);
14288 			operator();
14289 			}
14290 		}
14291 		catch (RecognitionException re) {
14292 			_localctx.exception = re;
14293 			_errHandler.reportError(this, re);
14294 			_errHandler.recover(this, re);
14295 		}
14296 		finally {
14297 			exitRule();
14298 		}
14299 		return _localctx;
14300 	}
14301 
14302 	public static class STypeContext extends ParserRuleContext {
14303 		public ArrayTypeContext arrayType() {
14304 			return getRuleContext(ArrayTypeContext.class,0);
14305 		}
14306 		public DictionaryTypeContext dictionaryType() {
14307 			return getRuleContext(DictionaryTypeContext.class,0);
14308 		}
14309 		public TypeIdentifierContext typeIdentifier() {
14310 			return getRuleContext(TypeIdentifierContext.class,0);
14311 		}
14312 		public TupleTypeContext tupleType() {
14313 			return getRuleContext(TupleTypeContext.class,0);
14314 		}
14315 		public ProtocolCompositionTypeContext protocolCompositionType() {
14316 			return getRuleContext(ProtocolCompositionTypeContext.class,0);
14317 		}
14318 		public List<STypeContext> sType() {
14319 			return getRuleContexts(STypeContext.class);
14320 		}
14321 		public STypeContext sType(int i) {
14322 			return getRuleContext(STypeContext.class,i);
14323 		}
14324 		public STypeContext(ParserRuleContext parent, int invokingState) {
14325 			super(parent, invokingState);
14326 		}
14327 		@Override public int getRuleIndex() { return RULE_sType; }
14328 		@Override
14329 		public void enterRule(ParseTreeListener listener) {
14330 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterSType(this);
14331 		}
14332 		@Override
14333 		public void exitRule(ParseTreeListener listener) {
14334 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitSType(this);
14335 		}
14336 	}
14337 
14338 	public final STypeContext sType() throws RecognitionException {
14339 		return sType(0);
14340 	}
14341 
14342 	private STypeContext sType(int _p) throws RecognitionException {
14343 		ParserRuleContext _parentctx = _ctx;
14344 		int _parentState = getState();
14345 		STypeContext _localctx = new STypeContext(_ctx, _parentState);
14346 		STypeContext _prevctx = _localctx;
14347 		int _startState = 426;
14348 		enterRecursionRule(_localctx, 426, RULE_sType, _p);
14349 		int _la;
14350 		try {
14351 			int _alt;
14352 			enterOuterAlt(_localctx, 1);
14353 			{
14354 			setState(2183);
14355 			_errHandler.sync(this);
14356 			switch ( getInterpreter().adaptivePredict(_input,273,_ctx) ) {
14357 			case 1:
14358 				{
14359 				setState(2178);
14360 				arrayType();
14361 				}
14362 				break;
14363 			case 2:
14364 				{
14365 				setState(2179);
14366 				dictionaryType();
14367 				}
14368 				break;
14369 			case 3:
14370 				{
14371 				setState(2180);
14372 				typeIdentifier();
14373 				}
14374 				break;
14375 			case 4:
14376 				{
14377 				setState(2181);
14378 				tupleType();
14379 				}
14380 				break;
14381 			case 5:
14382 				{
14383 				setState(2182);
14384 				protocolCompositionType();
14385 				}
14386 				break;
14387 			}
14388 			_ctx.stop = _input.LT(-1);
14389 			setState(2207);
14390 			_errHandler.sync(this);
14391 			_alt = getInterpreter().adaptivePredict(_input,276,_ctx);
14392 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14393 				if ( _alt==1 ) {
14394 					if ( _parseListeners!=null ) triggerExitRuleEvent();
14395 					_prevctx = _localctx;
14396 					{
14397 					setState(2205);
14398 					_errHandler.sync(this);
14399 					switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) {
14400 					case 1:
14401 						{
14402 						_localctx = new STypeContext(_parentctx, _parentState);
14403 						pushNewRecursionContext(_localctx, _startState, RULE_sType);
14404 						setState(2185);
14405 						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
14406 						setState(2187);
14407 						_la = _input.LA(1);
14408 						if (_la==T__74) {
14409 							{
14410 							setState(2186);
14411 							match(T__74);
14412 							}
14413 						}
14414 
14415 						setState(2189);
14416 						match(T__76);
14417 						setState(2190);
14418 						sType(10);
14419 						}
14420 						break;
14421 					case 2:
14422 						{
14423 						_localctx = new STypeContext(_parentctx, _parentState);
14424 						pushNewRecursionContext(_localctx, _startState, RULE_sType);
14425 						setState(2191);
14426 						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
14427 						setState(2192);
14428 						match(T__75);
14429 						setState(2193);
14430 						match(T__76);
14431 						setState(2194);
14432 						sType(9);
14433 						}
14434 						break;
14435 					case 3:
14436 						{
14437 						_localctx = new STypeContext(_parentctx, _parentState);
14438 						pushNewRecursionContext(_localctx, _startState, RULE_sType);
14439 						setState(2195);
14440 						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
14441 						setState(2196);
14442 						match(T__83);
14443 						}
14444 						break;
14445 					case 4:
14446 						{
14447 						_localctx = new STypeContext(_parentctx, _parentState);
14448 						pushNewRecursionContext(_localctx, _startState, RULE_sType);
14449 						setState(2197);
14450 						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
14451 						setState(2198);
14452 						match(T__84);
14453 						}
14454 						break;
14455 					case 5:
14456 						{
14457 						_localctx = new STypeContext(_parentctx, _parentState);
14458 						pushNewRecursionContext(_localctx, _startState, RULE_sType);
14459 						setState(2199);
14460 						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
14461 						setState(2200);
14462 						match(T__69);
14463 						setState(2201);
14464 						match(T__116);
14465 						}
14466 						break;
14467 					case 6:
14468 						{
14469 						_localctx = new STypeContext(_parentctx, _parentState);
14470 						pushNewRecursionContext(_localctx, _startState, RULE_sType);
14471 						setState(2202);
14472 						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
14473 						setState(2203);
14474 						match(T__69);
14475 						setState(2204);
14476 						match(T__117);
14477 						}
14478 						break;
14479 					}
14480 					} 
14481 				}
14482 				setState(2209);
14483 				_errHandler.sync(this);
14484 				_alt = getInterpreter().adaptivePredict(_input,276,_ctx);
14485 			}
14486 			}
14487 		}
14488 		catch (RecognitionException re) {
14489 			_localctx.exception = re;
14490 			_errHandler.reportError(this, re);
14491 			_errHandler.recover(this, re);
14492 		}
14493 		finally {
14494 			unrollRecursionContexts(_parentctx);
14495 		}
14496 		return _localctx;
14497 	}
14498 
14499 	public static class ArrayTypeContext extends ParserRuleContext {
14500 		public STypeContext sType() {
14501 			return getRuleContext(STypeContext.class,0);
14502 		}
14503 		public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
14504 			super(parent, invokingState);
14505 		}
14506 		@Override public int getRuleIndex() { return RULE_arrayType; }
14507 		@Override
14508 		public void enterRule(ParseTreeListener listener) {
14509 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterArrayType(this);
14510 		}
14511 		@Override
14512 		public void exitRule(ParseTreeListener listener) {
14513 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitArrayType(this);
14514 		}
14515 	}
14516 
14517 	public final ArrayTypeContext arrayType() throws RecognitionException {
14518 		ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
14519 		enterRule(_localctx, 428, RULE_arrayType);
14520 		try {
14521 			enterOuterAlt(_localctx, 1);
14522 			{
14523 			setState(2210);
14524 			match(T__97);
14525 			setState(2211);
14526 			sType(0);
14527 			setState(2212);
14528 			match(T__98);
14529 			}
14530 		}
14531 		catch (RecognitionException re) {
14532 			_localctx.exception = re;
14533 			_errHandler.reportError(this, re);
14534 			_errHandler.recover(this, re);
14535 		}
14536 		finally {
14537 			exitRule();
14538 		}
14539 		return _localctx;
14540 	}
14541 
14542 	public static class DictionaryTypeContext extends ParserRuleContext {
14543 		public List<STypeContext> sType() {
14544 			return getRuleContexts(STypeContext.class);
14545 		}
14546 		public STypeContext sType(int i) {
14547 			return getRuleContext(STypeContext.class,i);
14548 		}
14549 		public DictionaryTypeContext(ParserRuleContext parent, int invokingState) {
14550 			super(parent, invokingState);
14551 		}
14552 		@Override public int getRuleIndex() { return RULE_dictionaryType; }
14553 		@Override
14554 		public void enterRule(ParseTreeListener listener) {
14555 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterDictionaryType(this);
14556 		}
14557 		@Override
14558 		public void exitRule(ParseTreeListener listener) {
14559 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitDictionaryType(this);
14560 		}
14561 	}
14562 
14563 	public final DictionaryTypeContext dictionaryType() throws RecognitionException {
14564 		DictionaryTypeContext _localctx = new DictionaryTypeContext(_ctx, getState());
14565 		enterRule(_localctx, 430, RULE_dictionaryType);
14566 		try {
14567 			enterOuterAlt(_localctx, 1);
14568 			{
14569 			setState(2214);
14570 			match(T__97);
14571 			setState(2215);
14572 			sType(0);
14573 			setState(2216);
14574 			match(T__1);
14575 			setState(2217);
14576 			sType(0);
14577 			setState(2218);
14578 			match(T__98);
14579 			}
14580 		}
14581 		catch (RecognitionException re) {
14582 			_localctx.exception = re;
14583 			_errHandler.reportError(this, re);
14584 			_errHandler.recover(this, re);
14585 		}
14586 		finally {
14587 			exitRule();
14588 		}
14589 		return _localctx;
14590 	}
14591 
14592 	public static class OptionalTypeContext extends ParserRuleContext {
14593 		public STypeContext sType() {
14594 			return getRuleContext(STypeContext.class,0);
14595 		}
14596 		public OptionalTypeContext(ParserRuleContext parent, int invokingState) {
14597 			super(parent, invokingState);
14598 		}
14599 		@Override public int getRuleIndex() { return RULE_optionalType; }
14600 		@Override
14601 		public void enterRule(ParseTreeListener listener) {
14602 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOptionalType(this);
14603 		}
14604 		@Override
14605 		public void exitRule(ParseTreeListener listener) {
14606 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOptionalType(this);
14607 		}
14608 	}
14609 
14610 	public final OptionalTypeContext optionalType() throws RecognitionException {
14611 		OptionalTypeContext _localctx = new OptionalTypeContext(_ctx, getState());
14612 		enterRule(_localctx, 432, RULE_optionalType);
14613 		try {
14614 			enterOuterAlt(_localctx, 1);
14615 			{
14616 			setState(2220);
14617 			sType(0);
14618 			setState(2221);
14619 			match(T__83);
14620 			}
14621 		}
14622 		catch (RecognitionException re) {
14623 			_localctx.exception = re;
14624 			_errHandler.reportError(this, re);
14625 			_errHandler.recover(this, re);
14626 		}
14627 		finally {
14628 			exitRule();
14629 		}
14630 		return _localctx;
14631 	}
14632 
14633 	public static class ImplicitlyUnwrappedOptionalTypeContext extends ParserRuleContext {
14634 		public STypeContext sType() {
14635 			return getRuleContext(STypeContext.class,0);
14636 		}
14637 		public ImplicitlyUnwrappedOptionalTypeContext(ParserRuleContext parent, int invokingState) {
14638 			super(parent, invokingState);
14639 		}
14640 		@Override public int getRuleIndex() { return RULE_implicitlyUnwrappedOptionalType; }
14641 		@Override
14642 		public void enterRule(ParseTreeListener listener) {
14643 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterImplicitlyUnwrappedOptionalType(this);
14644 		}
14645 		@Override
14646 		public void exitRule(ParseTreeListener listener) {
14647 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitImplicitlyUnwrappedOptionalType(this);
14648 		}
14649 	}
14650 
14651 	public final ImplicitlyUnwrappedOptionalTypeContext implicitlyUnwrappedOptionalType() throws RecognitionException {
14652 		ImplicitlyUnwrappedOptionalTypeContext _localctx = new ImplicitlyUnwrappedOptionalTypeContext(_ctx, getState());
14653 		enterRule(_localctx, 434, RULE_implicitlyUnwrappedOptionalType);
14654 		try {
14655 			enterOuterAlt(_localctx, 1);
14656 			{
14657 			setState(2223);
14658 			sType(0);
14659 			setState(2224);
14660 			match(T__84);
14661 			}
14662 		}
14663 		catch (RecognitionException re) {
14664 			_localctx.exception = re;
14665 			_errHandler.reportError(this, re);
14666 			_errHandler.recover(this, re);
14667 		}
14668 		finally {
14669 			exitRule();
14670 		}
14671 		return _localctx;
14672 	}
14673 
14674 	public static class TypeAnnotationContext extends ParserRuleContext {
14675 		public STypeContext sType() {
14676 			return getRuleContext(STypeContext.class,0);
14677 		}
14678 		public AttributesContext attributes() {
14679 			return getRuleContext(AttributesContext.class,0);
14680 		}
14681 		public TypeAnnotationContext(ParserRuleContext parent, int invokingState) {
14682 			super(parent, invokingState);
14683 		}
14684 		@Override public int getRuleIndex() { return RULE_typeAnnotation; }
14685 		@Override
14686 		public void enterRule(ParseTreeListener listener) {
14687 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeAnnotation(this);
14688 		}
14689 		@Override
14690 		public void exitRule(ParseTreeListener listener) {
14691 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeAnnotation(this);
14692 		}
14693 	}
14694 
14695 	public final TypeAnnotationContext typeAnnotation() throws RecognitionException {
14696 		TypeAnnotationContext _localctx = new TypeAnnotationContext(_ctx, getState());
14697 		enterRule(_localctx, 436, RULE_typeAnnotation);
14698 		int _la;
14699 		try {
14700 			enterOuterAlt(_localctx, 1);
14701 			{
14702 			setState(2226);
14703 			match(T__1);
14704 			setState(2228);
14705 			_la = _input.LA(1);
14706 			if (_la==T__96) {
14707 				{
14708 				setState(2227);
14709 				attributes();
14710 				}
14711 			}
14712 
14713 			setState(2230);
14714 			sType(0);
14715 			}
14716 		}
14717 		catch (RecognitionException re) {
14718 			_localctx.exception = re;
14719 			_errHandler.reportError(this, re);
14720 			_errHandler.recover(this, re);
14721 		}
14722 		finally {
14723 			exitRule();
14724 		}
14725 		return _localctx;
14726 	}
14727 
14728 	public static class TypeIdentifierContext extends ParserRuleContext {
14729 		public TypeNameContext typeName() {
14730 			return getRuleContext(TypeNameContext.class,0);
14731 		}
14732 		public GenericArgumentClauseContext genericArgumentClause() {
14733 			return getRuleContext(GenericArgumentClauseContext.class,0);
14734 		}
14735 		public TypeIdentifierContext typeIdentifier() {
14736 			return getRuleContext(TypeIdentifierContext.class,0);
14737 		}
14738 		public TypeIdentifierContext(ParserRuleContext parent, int invokingState) {
14739 			super(parent, invokingState);
14740 		}
14741 		@Override public int getRuleIndex() { return RULE_typeIdentifier; }
14742 		@Override
14743 		public void enterRule(ParseTreeListener listener) {
14744 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeIdentifier(this);
14745 		}
14746 		@Override
14747 		public void exitRule(ParseTreeListener listener) {
14748 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeIdentifier(this);
14749 		}
14750 	}
14751 
14752 	public final TypeIdentifierContext typeIdentifier() throws RecognitionException {
14753 		TypeIdentifierContext _localctx = new TypeIdentifierContext(_ctx, getState());
14754 		enterRule(_localctx, 438, RULE_typeIdentifier);
14755 		int _la;
14756 		try {
14757 			setState(2244);
14758 			_errHandler.sync(this);
14759 			switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) {
14760 			case 1:
14761 				enterOuterAlt(_localctx, 1);
14762 				{
14763 				setState(2232);
14764 				typeName();
14765 				setState(2234);
14766 				_errHandler.sync(this);
14767 				switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) {
14768 				case 1:
14769 					{
14770 					setState(2233);
14771 					genericArgumentClause();
14772 					}
14773 					break;
14774 				}
14775 				}
14776 				break;
14777 			case 2:
14778 				enterOuterAlt(_localctx, 2);
14779 				{
14780 				setState(2236);
14781 				typeName();
14782 				setState(2238);
14783 				_la = _input.LA(1);
14784 				if (_la==T__38) {
14785 					{
14786 					setState(2237);
14787 					genericArgumentClause();
14788 					}
14789 				}
14790 
14791 				setState(2240);
14792 				match(T__69);
14793 				setState(2241);
14794 				typeIdentifier();
14795 				}
14796 				break;
14797 			case 3:
14798 				enterOuterAlt(_localctx, 3);
14799 				{
14800 				setState(2243);
14801 				match(T__118);
14802 				}
14803 				break;
14804 			}
14805 		}
14806 		catch (RecognitionException re) {
14807 			_localctx.exception = re;
14808 			_errHandler.reportError(this, re);
14809 			_errHandler.recover(this, re);
14810 		}
14811 		finally {
14812 			exitRule();
14813 		}
14814 		return _localctx;
14815 	}
14816 
14817 	public static class TypeNameContext extends ParserRuleContext {
14818 		public IdentifierContext identifier() {
14819 			return getRuleContext(IdentifierContext.class,0);
14820 		}
14821 		public TypeNameContext(ParserRuleContext parent, int invokingState) {
14822 			super(parent, invokingState);
14823 		}
14824 		@Override public int getRuleIndex() { return RULE_typeName; }
14825 		@Override
14826 		public void enterRule(ParseTreeListener listener) {
14827 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeName(this);
14828 		}
14829 		@Override
14830 		public void exitRule(ParseTreeListener listener) {
14831 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeName(this);
14832 		}
14833 	}
14834 
14835 	public final TypeNameContext typeName() throws RecognitionException {
14836 		TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
14837 		enterRule(_localctx, 440, RULE_typeName);
14838 		try {
14839 			enterOuterAlt(_localctx, 1);
14840 			{
14841 			setState(2246);
14842 			identifier();
14843 			}
14844 		}
14845 		catch (RecognitionException re) {
14846 			_localctx.exception = re;
14847 			_errHandler.reportError(this, re);
14848 			_errHandler.recover(this, re);
14849 		}
14850 		finally {
14851 			exitRule();
14852 		}
14853 		return _localctx;
14854 	}
14855 
14856 	public static class TupleTypeContext extends ParserRuleContext {
14857 		public TupleTypeBodyContext tupleTypeBody() {
14858 			return getRuleContext(TupleTypeBodyContext.class,0);
14859 		}
14860 		public TupleTypeContext(ParserRuleContext parent, int invokingState) {
14861 			super(parent, invokingState);
14862 		}
14863 		@Override public int getRuleIndex() { return RULE_tupleType; }
14864 		@Override
14865 		public void enterRule(ParseTreeListener listener) {
14866 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTupleType(this);
14867 		}
14868 		@Override
14869 		public void exitRule(ParseTreeListener listener) {
14870 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTupleType(this);
14871 		}
14872 	}
14873 
14874 	public final TupleTypeContext tupleType() throws RecognitionException {
14875 		TupleTypeContext _localctx = new TupleTypeContext(_ctx, getState());
14876 		enterRule(_localctx, 442, RULE_tupleType);
14877 		int _la;
14878 		try {
14879 			enterOuterAlt(_localctx, 1);
14880 			{
14881 			setState(2248);
14882 			match(T__3);
14883 			setState(2250);
14884 			_la = _input.LA(1);
14885 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__3) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (T__67 - 68)) | (1L << (T__71 - 68)) | (1L << (T__72 - 68)) | (1L << (T__73 - 68)) | (1L << (T__78 - 68)) | (1L << (T__81 - 68)) | (1L << (T__88 - 68)) | (1L << (T__89 - 68)) | (1L << (T__90 - 68)) | (1L << (T__91 - 68)) | (1L << (T__92 - 68)) | (1L << (T__93 - 68)) | (1L << (T__96 - 68)) | (1L << (T__97 - 68)) | (1L << (T__116 - 68)) | (1L << (T__117 - 68)) | (1L << (T__118 - 68)) | (1L << (T__123 - 68)) | (1L << (T__124 - 68)) | (1L << (T__125 - 68)) | (1L << (T__126 - 68)) | (1L << (T__127 - 68)) | (1L << (T__128 - 68)) | (1L << (T__130 - 68)))) != 0) || _la==Identifier) {
14886 				{
14887 				setState(2249);
14888 				tupleTypeBody();
14889 				}
14890 			}
14891 
14892 			setState(2252);
14893 			match(T__4);
14894 			}
14895 		}
14896 		catch (RecognitionException re) {
14897 			_localctx.exception = re;
14898 			_errHandler.reportError(this, re);
14899 			_errHandler.recover(this, re);
14900 		}
14901 		finally {
14902 			exitRule();
14903 		}
14904 		return _localctx;
14905 	}
14906 
14907 	public static class TupleTypeBodyContext extends ParserRuleContext {
14908 		public TupleTypeElementListContext tupleTypeElementList() {
14909 			return getRuleContext(TupleTypeElementListContext.class,0);
14910 		}
14911 		public TupleTypeBodyContext(ParserRuleContext parent, int invokingState) {
14912 			super(parent, invokingState);
14913 		}
14914 		@Override public int getRuleIndex() { return RULE_tupleTypeBody; }
14915 		@Override
14916 		public void enterRule(ParseTreeListener listener) {
14917 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTupleTypeBody(this);
14918 		}
14919 		@Override
14920 		public void exitRule(ParseTreeListener listener) {
14921 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTupleTypeBody(this);
14922 		}
14923 	}
14924 
14925 	public final TupleTypeBodyContext tupleTypeBody() throws RecognitionException {
14926 		TupleTypeBodyContext _localctx = new TupleTypeBodyContext(_ctx, getState());
14927 		enterRule(_localctx, 444, RULE_tupleTypeBody);
14928 		int _la;
14929 		try {
14930 			enterOuterAlt(_localctx, 1);
14931 			{
14932 			setState(2254);
14933 			tupleTypeElementList();
14934 			setState(2256);
14935 			_la = _input.LA(1);
14936 			if (_la==T__77) {
14937 				{
14938 				setState(2255);
14939 				match(T__77);
14940 				}
14941 			}
14942 
14943 			}
14944 		}
14945 		catch (RecognitionException re) {
14946 			_localctx.exception = re;
14947 			_errHandler.reportError(this, re);
14948 			_errHandler.recover(this, re);
14949 		}
14950 		finally {
14951 			exitRule();
14952 		}
14953 		return _localctx;
14954 	}
14955 
14956 	public static class TupleTypeElementListContext extends ParserRuleContext {
14957 		public TupleTypeElementContext tupleTypeElement() {
14958 			return getRuleContext(TupleTypeElementContext.class,0);
14959 		}
14960 		public TupleTypeElementListContext tupleTypeElementList() {
14961 			return getRuleContext(TupleTypeElementListContext.class,0);
14962 		}
14963 		public TupleTypeElementListContext(ParserRuleContext parent, int invokingState) {
14964 			super(parent, invokingState);
14965 		}
14966 		@Override public int getRuleIndex() { return RULE_tupleTypeElementList; }
14967 		@Override
14968 		public void enterRule(ParseTreeListener listener) {
14969 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTupleTypeElementList(this);
14970 		}
14971 		@Override
14972 		public void exitRule(ParseTreeListener listener) {
14973 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTupleTypeElementList(this);
14974 		}
14975 	}
14976 
14977 	public final TupleTypeElementListContext tupleTypeElementList() throws RecognitionException {
14978 		TupleTypeElementListContext _localctx = new TupleTypeElementListContext(_ctx, getState());
14979 		enterRule(_localctx, 446, RULE_tupleTypeElementList);
14980 		try {
14981 			setState(2263);
14982 			_errHandler.sync(this);
14983 			switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) {
14984 			case 1:
14985 				enterOuterAlt(_localctx, 1);
14986 				{
14987 				setState(2258);
14988 				tupleTypeElement();
14989 				}
14990 				break;
14991 			case 2:
14992 				enterOuterAlt(_localctx, 2);
14993 				{
14994 				setState(2259);
14995 				tupleTypeElement();
14996 				setState(2260);
14997 				match(T__15);
14998 				setState(2261);
14999 				tupleTypeElementList();
15000 				}
15001 				break;
15002 			}
15003 		}
15004 		catch (RecognitionException re) {
15005 			_localctx.exception = re;
15006 			_errHandler.reportError(this, re);
15007 			_errHandler.recover(this, re);
15008 		}
15009 		finally {
15010 			exitRule();
15011 		}
15012 		return _localctx;
15013 	}
15014 
15015 	public static class TupleTypeElementContext extends ParserRuleContext {
15016 		public STypeContext sType() {
15017 			return getRuleContext(STypeContext.class,0);
15018 		}
15019 		public AttributesContext attributes() {
15020 			return getRuleContext(AttributesContext.class,0);
15021 		}
15022 		public ElementNameContext elementName() {
15023 			return getRuleContext(ElementNameContext.class,0);
15024 		}
15025 		public TypeAnnotationContext typeAnnotation() {
15026 			return getRuleContext(TypeAnnotationContext.class,0);
15027 		}
15028 		public TupleTypeElementContext(ParserRuleContext parent, int invokingState) {
15029 			super(parent, invokingState);
15030 		}
15031 		@Override public int getRuleIndex() { return RULE_tupleTypeElement; }
15032 		@Override
15033 		public void enterRule(ParseTreeListener listener) {
15034 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTupleTypeElement(this);
15035 		}
15036 		@Override
15037 		public void exitRule(ParseTreeListener listener) {
15038 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTupleTypeElement(this);
15039 		}
15040 	}
15041 
15042 	public final TupleTypeElementContext tupleTypeElement() throws RecognitionException {
15043 		TupleTypeElementContext _localctx = new TupleTypeElementContext(_ctx, getState());
15044 		enterRule(_localctx, 448, RULE_tupleTypeElement);
15045 		int _la;
15046 		try {
15047 			setState(2278);
15048 			_errHandler.sync(this);
15049 			switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) {
15050 			case 1:
15051 				enterOuterAlt(_localctx, 1);
15052 				{
15053 				setState(2266);
15054 				_la = _input.LA(1);
15055 				if (_la==T__96) {
15056 					{
15057 					setState(2265);
15058 					attributes();
15059 					}
15060 				}
15061 
15062 				setState(2269);
15063 				_la = _input.LA(1);
15064 				if (_la==T__78) {
15065 					{
15066 					setState(2268);
15067 					match(T__78);
15068 					}
15069 				}
15070 
15071 				setState(2271);
15072 				sType(0);
15073 				}
15074 				break;
15075 			case 2:
15076 				enterOuterAlt(_localctx, 2);
15077 				{
15078 				setState(2273);
15079 				_la = _input.LA(1);
15080 				if (_la==T__78) {
15081 					{
15082 					setState(2272);
15083 					match(T__78);
15084 					}
15085 				}
15086 
15087 				setState(2275);
15088 				elementName();
15089 				setState(2276);
15090 				typeAnnotation();
15091 				}
15092 				break;
15093 			}
15094 		}
15095 		catch (RecognitionException re) {
15096 			_localctx.exception = re;
15097 			_errHandler.reportError(this, re);
15098 			_errHandler.recover(this, re);
15099 		}
15100 		finally {
15101 			exitRule();
15102 		}
15103 		return _localctx;
15104 	}
15105 
15106 	public static class ElementNameContext extends ParserRuleContext {
15107 		public IdentifierContext identifier() {
15108 			return getRuleContext(IdentifierContext.class,0);
15109 		}
15110 		public ElementNameContext(ParserRuleContext parent, int invokingState) {
15111 			super(parent, invokingState);
15112 		}
15113 		@Override public int getRuleIndex() { return RULE_elementName; }
15114 		@Override
15115 		public void enterRule(ParseTreeListener listener) {
15116 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterElementName(this);
15117 		}
15118 		@Override
15119 		public void exitRule(ParseTreeListener listener) {
15120 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitElementName(this);
15121 		}
15122 	}
15123 
15124 	public final ElementNameContext elementName() throws RecognitionException {
15125 		ElementNameContext _localctx = new ElementNameContext(_ctx, getState());
15126 		enterRule(_localctx, 450, RULE_elementName);
15127 		try {
15128 			enterOuterAlt(_localctx, 1);
15129 			{
15130 			setState(2280);
15131 			identifier();
15132 			}
15133 		}
15134 		catch (RecognitionException re) {
15135 			_localctx.exception = re;
15136 			_errHandler.reportError(this, re);
15137 			_errHandler.recover(this, re);
15138 		}
15139 		finally {
15140 			exitRule();
15141 		}
15142 		return _localctx;
15143 	}
15144 
15145 	public static class ProtocolCompositionTypeContext extends ParserRuleContext {
15146 		public ProtocolIdentifierListContext protocolIdentifierList() {
15147 			return getRuleContext(ProtocolIdentifierListContext.class,0);
15148 		}
15149 		public ProtocolCompositionTypeContext(ParserRuleContext parent, int invokingState) {
15150 			super(parent, invokingState);
15151 		}
15152 		@Override public int getRuleIndex() { return RULE_protocolCompositionType; }
15153 		@Override
15154 		public void enterRule(ParseTreeListener listener) {
15155 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolCompositionType(this);
15156 		}
15157 		@Override
15158 		public void exitRule(ParseTreeListener listener) {
15159 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolCompositionType(this);
15160 		}
15161 	}
15162 
15163 	public final ProtocolCompositionTypeContext protocolCompositionType() throws RecognitionException {
15164 		ProtocolCompositionTypeContext _localctx = new ProtocolCompositionTypeContext(_ctx, getState());
15165 		enterRule(_localctx, 452, RULE_protocolCompositionType);
15166 		int _la;
15167 		try {
15168 			enterOuterAlt(_localctx, 1);
15169 			{
15170 			setState(2282);
15171 			match(T__67);
15172 			setState(2283);
15173 			match(T__38);
15174 			setState(2285);
15175 			_la = _input.LA(1);
15176 			if (((((_la - 31)) & ~0x3f) == 0 && ((1L << (_la - 31)) & ((1L << (T__30 - 31)) | (1L << (T__31 - 31)) | (1L << (T__32 - 31)) | (1L << (T__34 - 31)) | (1L << (T__42 - 31)) | (1L << (T__43 - 31)) | (1L << (T__44 - 31)) | (1L << (T__45 - 31)) | (1L << (T__46 - 31)) | (1L << (T__47 - 31)) | (1L << (T__48 - 31)) | (1L << (T__49 - 31)) | (1L << (T__50 - 31)) | (1L << (T__51 - 31)) | (1L << (T__52 - 31)) | (1L << (T__53 - 31)) | (1L << (T__55 - 31)) | (1L << (T__58 - 31)) | (1L << (T__60 - 31)) | (1L << (T__71 - 31)) | (1L << (T__72 - 31)) | (1L << (T__73 - 31)) | (1L << (T__81 - 31)) | (1L << (T__88 - 31)) | (1L << (T__89 - 31)) | (1L << (T__90 - 31)) | (1L << (T__91 - 31)) | (1L << (T__92 - 31)) | (1L << (T__93 - 31)))) != 0) || ((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (T__116 - 117)) | (1L << (T__117 - 117)) | (1L << (T__118 - 117)) | (1L << (T__123 - 117)) | (1L << (T__124 - 117)) | (1L << (T__125 - 117)) | (1L << (T__126 - 117)) | (1L << (T__127 - 117)) | (1L << (T__128 - 117)) | (1L << (T__130 - 117)) | (1L << (Identifier - 117)))) != 0)) {
15177 				{
15178 				setState(2284);
15179 				protocolIdentifierList();
15180 				}
15181 			}
15182 
15183 			setState(2287);
15184 			match(T__39);
15185 			}
15186 		}
15187 		catch (RecognitionException re) {
15188 			_localctx.exception = re;
15189 			_errHandler.reportError(this, re);
15190 			_errHandler.recover(this, re);
15191 		}
15192 		finally {
15193 			exitRule();
15194 		}
15195 		return _localctx;
15196 	}
15197 
15198 	public static class ProtocolIdentifierListContext extends ParserRuleContext {
15199 		public ProtocolIdentifierContext protocolIdentifier() {
15200 			return getRuleContext(ProtocolIdentifierContext.class,0);
15201 		}
15202 		public ProtocolIdentifierListContext protocolIdentifierList() {
15203 			return getRuleContext(ProtocolIdentifierListContext.class,0);
15204 		}
15205 		public ProtocolIdentifierListContext(ParserRuleContext parent, int invokingState) {
15206 			super(parent, invokingState);
15207 		}
15208 		@Override public int getRuleIndex() { return RULE_protocolIdentifierList; }
15209 		@Override
15210 		public void enterRule(ParseTreeListener listener) {
15211 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolIdentifierList(this);
15212 		}
15213 		@Override
15214 		public void exitRule(ParseTreeListener listener) {
15215 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolIdentifierList(this);
15216 		}
15217 	}
15218 
15219 	public final ProtocolIdentifierListContext protocolIdentifierList() throws RecognitionException {
15220 		ProtocolIdentifierListContext _localctx = new ProtocolIdentifierListContext(_ctx, getState());
15221 		enterRule(_localctx, 454, RULE_protocolIdentifierList);
15222 		try {
15223 			setState(2294);
15224 			_errHandler.sync(this);
15225 			switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) {
15226 			case 1:
15227 				enterOuterAlt(_localctx, 1);
15228 				{
15229 				setState(2289);
15230 				protocolIdentifier();
15231 				}
15232 				break;
15233 			case 2:
15234 				enterOuterAlt(_localctx, 2);
15235 				{
15236 				setState(2290);
15237 				protocolIdentifier();
15238 				setState(2291);
15239 				match(T__15);
15240 				setState(2292);
15241 				protocolIdentifierList();
15242 				}
15243 				break;
15244 			}
15245 		}
15246 		catch (RecognitionException re) {
15247 			_localctx.exception = re;
15248 			_errHandler.reportError(this, re);
15249 			_errHandler.recover(this, re);
15250 		}
15251 		finally {
15252 			exitRule();
15253 		}
15254 		return _localctx;
15255 	}
15256 
15257 	public static class ProtocolIdentifierContext extends ParserRuleContext {
15258 		public TypeIdentifierContext typeIdentifier() {
15259 			return getRuleContext(TypeIdentifierContext.class,0);
15260 		}
15261 		public ProtocolIdentifierContext(ParserRuleContext parent, int invokingState) {
15262 			super(parent, invokingState);
15263 		}
15264 		@Override public int getRuleIndex() { return RULE_protocolIdentifier; }
15265 		@Override
15266 		public void enterRule(ParseTreeListener listener) {
15267 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterProtocolIdentifier(this);
15268 		}
15269 		@Override
15270 		public void exitRule(ParseTreeListener listener) {
15271 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitProtocolIdentifier(this);
15272 		}
15273 	}
15274 
15275 	public final ProtocolIdentifierContext protocolIdentifier() throws RecognitionException {
15276 		ProtocolIdentifierContext _localctx = new ProtocolIdentifierContext(_ctx, getState());
15277 		enterRule(_localctx, 456, RULE_protocolIdentifier);
15278 		try {
15279 			enterOuterAlt(_localctx, 1);
15280 			{
15281 			setState(2296);
15282 			typeIdentifier();
15283 			}
15284 		}
15285 		catch (RecognitionException re) {
15286 			_localctx.exception = re;
15287 			_errHandler.reportError(this, re);
15288 			_errHandler.recover(this, re);
15289 		}
15290 		finally {
15291 			exitRule();
15292 		}
15293 		return _localctx;
15294 	}
15295 
15296 	public static class MetatypeTypeContext extends ParserRuleContext {
15297 		public STypeContext sType() {
15298 			return getRuleContext(STypeContext.class,0);
15299 		}
15300 		public MetatypeTypeContext(ParserRuleContext parent, int invokingState) {
15301 			super(parent, invokingState);
15302 		}
15303 		@Override public int getRuleIndex() { return RULE_metatypeType; }
15304 		@Override
15305 		public void enterRule(ParseTreeListener listener) {
15306 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterMetatypeType(this);
15307 		}
15308 		@Override
15309 		public void exitRule(ParseTreeListener listener) {
15310 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitMetatypeType(this);
15311 		}
15312 	}
15313 
15314 	public final MetatypeTypeContext metatypeType() throws RecognitionException {
15315 		MetatypeTypeContext _localctx = new MetatypeTypeContext(_ctx, getState());
15316 		enterRule(_localctx, 458, RULE_metatypeType);
15317 		try {
15318 			setState(2306);
15319 			_errHandler.sync(this);
15320 			switch ( getInterpreter().adaptivePredict(_input,290,_ctx) ) {
15321 			case 1:
15322 				enterOuterAlt(_localctx, 1);
15323 				{
15324 				setState(2298);
15325 				sType(0);
15326 				setState(2299);
15327 				match(T__69);
15328 				setState(2300);
15329 				match(T__116);
15330 				}
15331 				break;
15332 			case 2:
15333 				enterOuterAlt(_localctx, 2);
15334 				{
15335 				setState(2302);
15336 				sType(0);
15337 				setState(2303);
15338 				match(T__69);
15339 				setState(2304);
15340 				match(T__117);
15341 				}
15342 				break;
15343 			}
15344 		}
15345 		catch (RecognitionException re) {
15346 			_localctx.exception = re;
15347 			_errHandler.reportError(this, re);
15348 			_errHandler.recover(this, re);
15349 		}
15350 		finally {
15351 			exitRule();
15352 		}
15353 		return _localctx;
15354 	}
15355 
15356 	public static class TypeInheritanceClauseContext extends ParserRuleContext {
15357 		public ClassRequirementContext classRequirement() {
15358 			return getRuleContext(ClassRequirementContext.class,0);
15359 		}
15360 		public TypeInheritanceListContext typeInheritanceList() {
15361 			return getRuleContext(TypeInheritanceListContext.class,0);
15362 		}
15363 		public TypeInheritanceClauseContext(ParserRuleContext parent, int invokingState) {
15364 			super(parent, invokingState);
15365 		}
15366 		@Override public int getRuleIndex() { return RULE_typeInheritanceClause; }
15367 		@Override
15368 		public void enterRule(ParseTreeListener listener) {
15369 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeInheritanceClause(this);
15370 		}
15371 		@Override
15372 		public void exitRule(ParseTreeListener listener) {
15373 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeInheritanceClause(this);
15374 		}
15375 	}
15376 
15377 	public final TypeInheritanceClauseContext typeInheritanceClause() throws RecognitionException {
15378 		TypeInheritanceClauseContext _localctx = new TypeInheritanceClauseContext(_ctx, getState());
15379 		enterRule(_localctx, 460, RULE_typeInheritanceClause);
15380 		try {
15381 			setState(2317);
15382 			_errHandler.sync(this);
15383 			switch ( getInterpreter().adaptivePredict(_input,291,_ctx) ) {
15384 			case 1:
15385 				enterOuterAlt(_localctx, 1);
15386 				{
15387 				setState(2308);
15388 				match(T__1);
15389 				setState(2309);
15390 				classRequirement();
15391 				setState(2310);
15392 				match(T__15);
15393 				setState(2311);
15394 				typeInheritanceList();
15395 				}
15396 				break;
15397 			case 2:
15398 				enterOuterAlt(_localctx, 2);
15399 				{
15400 				setState(2313);
15401 				match(T__1);
15402 				setState(2314);
15403 				classRequirement();
15404 				}
15405 				break;
15406 			case 3:
15407 				enterOuterAlt(_localctx, 3);
15408 				{
15409 				setState(2315);
15410 				match(T__1);
15411 				setState(2316);
15412 				typeInheritanceList();
15413 				}
15414 				break;
15415 			}
15416 		}
15417 		catch (RecognitionException re) {
15418 			_localctx.exception = re;
15419 			_errHandler.reportError(this, re);
15420 			_errHandler.recover(this, re);
15421 		}
15422 		finally {
15423 			exitRule();
15424 		}
15425 		return _localctx;
15426 	}
15427 
15428 	public static class TypeInheritanceListContext extends ParserRuleContext {
15429 		public List<TypeIdentifierContext> typeIdentifier() {
15430 			return getRuleContexts(TypeIdentifierContext.class);
15431 		}
15432 		public TypeIdentifierContext typeIdentifier(int i) {
15433 			return getRuleContext(TypeIdentifierContext.class,i);
15434 		}
15435 		public TypeInheritanceListContext(ParserRuleContext parent, int invokingState) {
15436 			super(parent, invokingState);
15437 		}
15438 		@Override public int getRuleIndex() { return RULE_typeInheritanceList; }
15439 		@Override
15440 		public void enterRule(ParseTreeListener listener) {
15441 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterTypeInheritanceList(this);
15442 		}
15443 		@Override
15444 		public void exitRule(ParseTreeListener listener) {
15445 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitTypeInheritanceList(this);
15446 		}
15447 	}
15448 
15449 	public final TypeInheritanceListContext typeInheritanceList() throws RecognitionException {
15450 		TypeInheritanceListContext _localctx = new TypeInheritanceListContext(_ctx, getState());
15451 		enterRule(_localctx, 462, RULE_typeInheritanceList);
15452 		int _la;
15453 		try {
15454 			enterOuterAlt(_localctx, 1);
15455 			{
15456 			setState(2319);
15457 			typeIdentifier();
15458 			setState(2324);
15459 			_errHandler.sync(this);
15460 			_la = _input.LA(1);
15461 			while (_la==T__15) {
15462 				{
15463 				{
15464 				setState(2320);
15465 				match(T__15);
15466 				setState(2321);
15467 				typeIdentifier();
15468 				}
15469 				}
15470 				setState(2326);
15471 				_errHandler.sync(this);
15472 				_la = _input.LA(1);
15473 			}
15474 			}
15475 		}
15476 		catch (RecognitionException re) {
15477 			_localctx.exception = re;
15478 			_errHandler.reportError(this, re);
15479 			_errHandler.recover(this, re);
15480 		}
15481 		finally {
15482 			exitRule();
15483 		}
15484 		return _localctx;
15485 	}
15486 
15487 	public static class ClassRequirementContext extends ParserRuleContext {
15488 		public ClassRequirementContext(ParserRuleContext parent, int invokingState) {
15489 			super(parent, invokingState);
15490 		}
15491 		@Override public int getRuleIndex() { return RULE_classRequirement; }
15492 		@Override
15493 		public void enterRule(ParseTreeListener listener) {
15494 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterClassRequirement(this);
15495 		}
15496 		@Override
15497 		public void exitRule(ParseTreeListener listener) {
15498 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitClassRequirement(this);
15499 		}
15500 	}
15501 
15502 	public final ClassRequirementContext classRequirement() throws RecognitionException {
15503 		ClassRequirementContext _localctx = new ClassRequirementContext(_ctx, getState());
15504 		enterRule(_localctx, 464, RULE_classRequirement);
15505 		try {
15506 			enterOuterAlt(_localctx, 1);
15507 			{
15508 			setState(2327);
15509 			match(T__41);
15510 			}
15511 		}
15512 		catch (RecognitionException re) {
15513 			_localctx.exception = re;
15514 			_errHandler.reportError(this, re);
15515 			_errHandler.recover(this, re);
15516 		}
15517 		finally {
15518 			exitRule();
15519 		}
15520 		return _localctx;
15521 	}
15522 
15523 	public static class CompilerControlStatementContext extends ParserRuleContext {
15524 		public BuildConfigurationStatementContext buildConfigurationStatement() {
15525 			return getRuleContext(BuildConfigurationStatementContext.class,0);
15526 		}
15527 		public LineControlStatementContext lineControlStatement() {
15528 			return getRuleContext(LineControlStatementContext.class,0);
15529 		}
15530 		public CompilerControlStatementContext(ParserRuleContext parent, int invokingState) {
15531 			super(parent, invokingState);
15532 		}
15533 		@Override public int getRuleIndex() { return RULE_compilerControlStatement; }
15534 		@Override
15535 		public void enterRule(ParseTreeListener listener) {
15536 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterCompilerControlStatement(this);
15537 		}
15538 		@Override
15539 		public void exitRule(ParseTreeListener listener) {
15540 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitCompilerControlStatement(this);
15541 		}
15542 	}
15543 
15544 	public final CompilerControlStatementContext compilerControlStatement() throws RecognitionException {
15545 		CompilerControlStatementContext _localctx = new CompilerControlStatementContext(_ctx, getState());
15546 		enterRule(_localctx, 466, RULE_compilerControlStatement);
15547 		try {
15548 			setState(2331);
15549 			switch (_input.LA(1)) {
15550 			case T__119:
15551 				enterOuterAlt(_localctx, 1);
15552 				{
15553 				setState(2329);
15554 				buildConfigurationStatement();
15555 				}
15556 				break;
15557 			case T__129:
15558 				enterOuterAlt(_localctx, 2);
15559 				{
15560 				setState(2330);
15561 				lineControlStatement();
15562 				}
15563 				break;
15564 			default:
15565 				throw new NoViableAltException(this);
15566 			}
15567 		}
15568 		catch (RecognitionException re) {
15569 			_localctx.exception = re;
15570 			_errHandler.reportError(this, re);
15571 			_errHandler.recover(this, re);
15572 		}
15573 		finally {
15574 			exitRule();
15575 		}
15576 		return _localctx;
15577 	}
15578 
15579 	public static class BuildConfigurationStatementContext extends ParserRuleContext {
15580 		public BuildConfigurationContext buildConfiguration() {
15581 			return getRuleContext(BuildConfigurationContext.class,0);
15582 		}
15583 		public StatementsContext statements() {
15584 			return getRuleContext(StatementsContext.class,0);
15585 		}
15586 		public BuildConfigurationElseIfClausesContext buildConfigurationElseIfClauses() {
15587 			return getRuleContext(BuildConfigurationElseIfClausesContext.class,0);
15588 		}
15589 		public BuildConfigurationElseClauseContext buildConfigurationElseClause() {
15590 			return getRuleContext(BuildConfigurationElseClauseContext.class,0);
15591 		}
15592 		public BuildConfigurationStatementContext(ParserRuleContext parent, int invokingState) {
15593 			super(parent, invokingState);
15594 		}
15595 		@Override public int getRuleIndex() { return RULE_buildConfigurationStatement; }
15596 		@Override
15597 		public void enterRule(ParseTreeListener listener) {
15598 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBuildConfigurationStatement(this);
15599 		}
15600 		@Override
15601 		public void exitRule(ParseTreeListener listener) {
15602 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBuildConfigurationStatement(this);
15603 		}
15604 	}
15605 
15606 	public final BuildConfigurationStatementContext buildConfigurationStatement() throws RecognitionException {
15607 		BuildConfigurationStatementContext _localctx = new BuildConfigurationStatementContext(_ctx, getState());
15608 		enterRule(_localctx, 468, RULE_buildConfigurationStatement);
15609 		int _la;
15610 		try {
15611 			enterOuterAlt(_localctx, 1);
15612 			{
15613 			setState(2333);
15614 			match(T__119);
15615 			setState(2334);
15616 			buildConfiguration(0);
15617 			setState(2336);
15618 			_la = _input.LA(1);
15619 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
15620 				{
15621 				setState(2335);
15622 				statements();
15623 				}
15624 			}
15625 
15626 			setState(2339);
15627 			_la = _input.LA(1);
15628 			if (_la==T__121) {
15629 				{
15630 				setState(2338);
15631 				buildConfigurationElseIfClauses();
15632 				}
15633 			}
15634 
15635 			setState(2342);
15636 			_la = _input.LA(1);
15637 			if (_la==T__122) {
15638 				{
15639 				setState(2341);
15640 				buildConfigurationElseClause();
15641 				}
15642 			}
15643 
15644 			setState(2344);
15645 			match(T__120);
15646 			}
15647 		}
15648 		catch (RecognitionException re) {
15649 			_localctx.exception = re;
15650 			_errHandler.reportError(this, re);
15651 			_errHandler.recover(this, re);
15652 		}
15653 		finally {
15654 			exitRule();
15655 		}
15656 		return _localctx;
15657 	}
15658 
15659 	public static class BuildConfigurationElseIfClausesContext extends ParserRuleContext {
15660 		public List<BuildConfigurationElseIfClauseContext> buildConfigurationElseIfClause() {
15661 			return getRuleContexts(BuildConfigurationElseIfClauseContext.class);
15662 		}
15663 		public BuildConfigurationElseIfClauseContext buildConfigurationElseIfClause(int i) {
15664 			return getRuleContext(BuildConfigurationElseIfClauseContext.class,i);
15665 		}
15666 		public BuildConfigurationElseIfClausesContext(ParserRuleContext parent, int invokingState) {
15667 			super(parent, invokingState);
15668 		}
15669 		@Override public int getRuleIndex() { return RULE_buildConfigurationElseIfClauses; }
15670 		@Override
15671 		public void enterRule(ParseTreeListener listener) {
15672 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBuildConfigurationElseIfClauses(this);
15673 		}
15674 		@Override
15675 		public void exitRule(ParseTreeListener listener) {
15676 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBuildConfigurationElseIfClauses(this);
15677 		}
15678 	}
15679 
15680 	public final BuildConfigurationElseIfClausesContext buildConfigurationElseIfClauses() throws RecognitionException {
15681 		BuildConfigurationElseIfClausesContext _localctx = new BuildConfigurationElseIfClausesContext(_ctx, getState());
15682 		enterRule(_localctx, 470, RULE_buildConfigurationElseIfClauses);
15683 		int _la;
15684 		try {
15685 			enterOuterAlt(_localctx, 1);
15686 			{
15687 			setState(2347); 
15688 			_errHandler.sync(this);
15689 			_la = _input.LA(1);
15690 			do {
15691 				{
15692 				{
15693 				setState(2346);
15694 				buildConfigurationElseIfClause();
15695 				}
15696 				}
15697 				setState(2349); 
15698 				_errHandler.sync(this);
15699 				_la = _input.LA(1);
15700 			} while ( _la==T__121 );
15701 			}
15702 		}
15703 		catch (RecognitionException re) {
15704 			_localctx.exception = re;
15705 			_errHandler.reportError(this, re);
15706 			_errHandler.recover(this, re);
15707 		}
15708 		finally {
15709 			exitRule();
15710 		}
15711 		return _localctx;
15712 	}
15713 
15714 	public static class BuildConfigurationElseIfClauseContext extends ParserRuleContext {
15715 		public BuildConfigurationContext buildConfiguration() {
15716 			return getRuleContext(BuildConfigurationContext.class,0);
15717 		}
15718 		public StatementsContext statements() {
15719 			return getRuleContext(StatementsContext.class,0);
15720 		}
15721 		public BuildConfigurationElseIfClauseContext(ParserRuleContext parent, int invokingState) {
15722 			super(parent, invokingState);
15723 		}
15724 		@Override public int getRuleIndex() { return RULE_buildConfigurationElseIfClause; }
15725 		@Override
15726 		public void enterRule(ParseTreeListener listener) {
15727 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBuildConfigurationElseIfClause(this);
15728 		}
15729 		@Override
15730 		public void exitRule(ParseTreeListener listener) {
15731 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBuildConfigurationElseIfClause(this);
15732 		}
15733 	}
15734 
15735 	public final BuildConfigurationElseIfClauseContext buildConfigurationElseIfClause() throws RecognitionException {
15736 		BuildConfigurationElseIfClauseContext _localctx = new BuildConfigurationElseIfClauseContext(_ctx, getState());
15737 		enterRule(_localctx, 472, RULE_buildConfigurationElseIfClause);
15738 		int _la;
15739 		try {
15740 			enterOuterAlt(_localctx, 1);
15741 			{
15742 			setState(2351);
15743 			match(T__121);
15744 			setState(2352);
15745 			buildConfiguration(0);
15746 			setState(2354);
15747 			_la = _input.LA(1);
15748 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
15749 				{
15750 				setState(2353);
15751 				statements();
15752 				}
15753 			}
15754 
15755 			}
15756 		}
15757 		catch (RecognitionException re) {
15758 			_localctx.exception = re;
15759 			_errHandler.reportError(this, re);
15760 			_errHandler.recover(this, re);
15761 		}
15762 		finally {
15763 			exitRule();
15764 		}
15765 		return _localctx;
15766 	}
15767 
15768 	public static class BuildConfigurationElseClauseContext extends ParserRuleContext {
15769 		public StatementsContext statements() {
15770 			return getRuleContext(StatementsContext.class,0);
15771 		}
15772 		public BuildConfigurationElseClauseContext(ParserRuleContext parent, int invokingState) {
15773 			super(parent, invokingState);
15774 		}
15775 		@Override public int getRuleIndex() { return RULE_buildConfigurationElseClause; }
15776 		@Override
15777 		public void enterRule(ParseTreeListener listener) {
15778 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBuildConfigurationElseClause(this);
15779 		}
15780 		@Override
15781 		public void exitRule(ParseTreeListener listener) {
15782 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBuildConfigurationElseClause(this);
15783 		}
15784 	}
15785 
15786 	public final BuildConfigurationElseClauseContext buildConfigurationElseClause() throws RecognitionException {
15787 		BuildConfigurationElseClauseContext _localctx = new BuildConfigurationElseClauseContext(_ctx, getState());
15788 		enterRule(_localctx, 474, RULE_buildConfigurationElseClause);
15789 		int _la;
15790 		try {
15791 			enterOuterAlt(_localctx, 1);
15792 			{
15793 			setState(2356);
15794 			match(T__122);
15795 			setState(2358);
15796 			_la = _input.LA(1);
15797 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__11) | (1L << T__12) | (1L << T__13) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__54) | (1L << T__55) | (1L << T__58) | (1L << T__59) | (1L << T__60) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__70 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__77 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__84 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__88 - 64)) | (1L << (T__89 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__99 - 64)) | (1L << (T__101 - 64)) | (1L << (T__103 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (T__106 - 64)) | (1L << (T__107 - 64)) | (1L << (T__108 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__114 - 64)) | (1L << (T__115 - 64)) | (1L << (T__116 - 64)) | (1L << (T__117 - 64)) | (1L << (T__119 - 64)) | (1L << (T__123 - 64)) | (1L << (T__124 - 64)) | (1L << (T__125 - 64)) | (1L << (T__126 - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (T__127 - 128)) | (1L << (T__128 - 128)) | (1L << (T__129 - 128)) | (1L << (T__130 - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NilLiteral - 128)) | (1L << (OperatorHead - 128)) | (1L << (DotOperatorHead - 128)) | (1L << (Identifier - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (FloatingPointLiteral - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
15798 				{
15799 				setState(2357);
15800 				statements();
15801 				}
15802 			}
15803 
15804 			}
15805 		}
15806 		catch (RecognitionException re) {
15807 			_localctx.exception = re;
15808 			_errHandler.reportError(this, re);
15809 			_errHandler.recover(this, re);
15810 		}
15811 		finally {
15812 			exitRule();
15813 		}
15814 		return _localctx;
15815 	}
15816 
15817 	public static class BuildConfigurationContext extends ParserRuleContext {
15818 		public List<BuildConfigurationContext> buildConfiguration() {
15819 			return getRuleContexts(BuildConfigurationContext.class);
15820 		}
15821 		public BuildConfigurationContext buildConfiguration(int i) {
15822 			return getRuleContext(BuildConfigurationContext.class,i);
15823 		}
15824 		public PlatformTestingFunctionContext platformTestingFunction() {
15825 			return getRuleContext(PlatformTestingFunctionContext.class,0);
15826 		}
15827 		public IdentifierContext identifier() {
15828 			return getRuleContext(IdentifierContext.class,0);
15829 		}
15830 		public BooleanLiteralContext booleanLiteral() {
15831 			return getRuleContext(BooleanLiteralContext.class,0);
15832 		}
15833 		public BuildConfigurationContext(ParserRuleContext parent, int invokingState) {
15834 			super(parent, invokingState);
15835 		}
15836 		@Override public int getRuleIndex() { return RULE_buildConfiguration; }
15837 		@Override
15838 		public void enterRule(ParseTreeListener listener) {
15839 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBuildConfiguration(this);
15840 		}
15841 		@Override
15842 		public void exitRule(ParseTreeListener listener) {
15843 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBuildConfiguration(this);
15844 		}
15845 	}
15846 
15847 	public final BuildConfigurationContext buildConfiguration() throws RecognitionException {
15848 		return buildConfiguration(0);
15849 	}
15850 
15851 	private BuildConfigurationContext buildConfiguration(int _p) throws RecognitionException {
15852 		ParserRuleContext _parentctx = _ctx;
15853 		int _parentState = getState();
15854 		BuildConfigurationContext _localctx = new BuildConfigurationContext(_ctx, _parentState);
15855 		BuildConfigurationContext _prevctx = _localctx;
15856 		int _startState = 476;
15857 		enterRecursionRule(_localctx, 476, RULE_buildConfiguration, _p);
15858 		int _la;
15859 		try {
15860 			int _alt;
15861 			enterOuterAlt(_localctx, 1);
15862 			{
15863 			setState(2370);
15864 			_errHandler.sync(this);
15865 			switch ( getInterpreter().adaptivePredict(_input,300,_ctx) ) {
15866 			case 1:
15867 				{
15868 				setState(2361);
15869 				match(T__84);
15870 				setState(2362);
15871 				buildConfiguration(2);
15872 				}
15873 				break;
15874 			case 2:
15875 				{
15876 				setState(2363);
15877 				platformTestingFunction();
15878 				}
15879 				break;
15880 			case 3:
15881 				{
15882 				setState(2364);
15883 				identifier();
15884 				}
15885 				break;
15886 			case 4:
15887 				{
15888 				setState(2365);
15889 				booleanLiteral();
15890 				}
15891 				break;
15892 			case 5:
15893 				{
15894 				setState(2366);
15895 				match(T__3);
15896 				setState(2367);
15897 				buildConfiguration(0);
15898 				setState(2368);
15899 				match(T__4);
15900 				}
15901 				break;
15902 			}
15903 			_ctx.stop = _input.LT(-1);
15904 			setState(2377);
15905 			_errHandler.sync(this);
15906 			_alt = getInterpreter().adaptivePredict(_input,301,_ctx);
15907 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
15908 				if ( _alt==1 ) {
15909 					if ( _parseListeners!=null ) triggerExitRuleEvent();
15910 					_prevctx = _localctx;
15911 					{
15912 					{
15913 					_localctx = new BuildConfigurationContext(_parentctx, _parentState);
15914 					pushNewRecursionContext(_localctx, _startState, RULE_buildConfiguration);
15915 					setState(2372);
15916 					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
15917 					setState(2373);
15918 					_la = _input.LA(1);
15919 					if ( !(_la==T__114 || _la==T__115) ) {
15920 					_errHandler.recoverInline(this);
15921 					} else {
15922 						consume();
15923 					}
15924 					setState(2374);
15925 					buildConfiguration(2);
15926 					}
15927 					} 
15928 				}
15929 				setState(2379);
15930 				_errHandler.sync(this);
15931 				_alt = getInterpreter().adaptivePredict(_input,301,_ctx);
15932 			}
15933 			}
15934 		}
15935 		catch (RecognitionException re) {
15936 			_localctx.exception = re;
15937 			_errHandler.reportError(this, re);
15938 			_errHandler.recover(this, re);
15939 		}
15940 		finally {
15941 			unrollRecursionContexts(_parentctx);
15942 		}
15943 		return _localctx;
15944 	}
15945 
15946 	public static class PlatformTestingFunctionContext extends ParserRuleContext {
15947 		public OperatingSystemContext operatingSystem() {
15948 			return getRuleContext(OperatingSystemContext.class,0);
15949 		}
15950 		public ArchitectureContext architecture() {
15951 			return getRuleContext(ArchitectureContext.class,0);
15952 		}
15953 		public PlatformTestingFunctionContext(ParserRuleContext parent, int invokingState) {
15954 			super(parent, invokingState);
15955 		}
15956 		@Override public int getRuleIndex() { return RULE_platformTestingFunction; }
15957 		@Override
15958 		public void enterRule(ParseTreeListener listener) {
15959 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterPlatformTestingFunction(this);
15960 		}
15961 		@Override
15962 		public void exitRule(ParseTreeListener listener) {
15963 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitPlatformTestingFunction(this);
15964 		}
15965 	}
15966 
15967 	public final PlatformTestingFunctionContext platformTestingFunction() throws RecognitionException {
15968 		PlatformTestingFunctionContext _localctx = new PlatformTestingFunctionContext(_ctx, getState());
15969 		enterRule(_localctx, 478, RULE_platformTestingFunction);
15970 		try {
15971 			setState(2390);
15972 			switch (_input.LA(1)) {
15973 			case T__123:
15974 				enterOuterAlt(_localctx, 1);
15975 				{
15976 				setState(2380);
15977 				match(T__123);
15978 				setState(2381);
15979 				match(T__3);
15980 				setState(2382);
15981 				operatingSystem();
15982 				setState(2383);
15983 				match(T__4);
15984 				}
15985 				break;
15986 			case T__124:
15987 				enterOuterAlt(_localctx, 2);
15988 				{
15989 				setState(2385);
15990 				match(T__124);
15991 				setState(2386);
15992 				match(T__3);
15993 				setState(2387);
15994 				architecture();
15995 				setState(2388);
15996 				match(T__4);
15997 				}
15998 				break;
15999 			default:
16000 				throw new NoViableAltException(this);
16001 			}
16002 		}
16003 		catch (RecognitionException re) {
16004 			_localctx.exception = re;
16005 			_errHandler.reportError(this, re);
16006 			_errHandler.recover(this, re);
16007 		}
16008 		finally {
16009 			exitRule();
16010 		}
16011 		return _localctx;
16012 	}
16013 
16014 	public static class OperatingSystemContext extends ParserRuleContext {
16015 		public OperatingSystemContext(ParserRuleContext parent, int invokingState) {
16016 			super(parent, invokingState);
16017 		}
16018 		@Override public int getRuleIndex() { return RULE_operatingSystem; }
16019 		@Override
16020 		public void enterRule(ParseTreeListener listener) {
16021 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterOperatingSystem(this);
16022 		}
16023 		@Override
16024 		public void exitRule(ParseTreeListener listener) {
16025 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitOperatingSystem(this);
16026 		}
16027 	}
16028 
16029 	public final OperatingSystemContext operatingSystem() throws RecognitionException {
16030 		OperatingSystemContext _localctx = new OperatingSystemContext(_ctx, getState());
16031 		enterRule(_localctx, 480, RULE_operatingSystem);
16032 		int _la;
16033 		try {
16034 			enterOuterAlt(_localctx, 1);
16035 			{
16036 			setState(2392);
16037 			_la = _input.LA(1);
16038 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__30) | (1L << T__32) | (1L << T__34) | (1L << T__36))) != 0)) ) {
16039 			_errHandler.recoverInline(this);
16040 			} else {
16041 				consume();
16042 			}
16043 			}
16044 		}
16045 		catch (RecognitionException re) {
16046 			_localctx.exception = re;
16047 			_errHandler.reportError(this, re);
16048 			_errHandler.recover(this, re);
16049 		}
16050 		finally {
16051 			exitRule();
16052 		}
16053 		return _localctx;
16054 	}
16055 
16056 	public static class ArchitectureContext extends ParserRuleContext {
16057 		public ArchitectureContext(ParserRuleContext parent, int invokingState) {
16058 			super(parent, invokingState);
16059 		}
16060 		@Override public int getRuleIndex() { return RULE_architecture; }
16061 		@Override
16062 		public void enterRule(ParseTreeListener listener) {
16063 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterArchitecture(this);
16064 		}
16065 		@Override
16066 		public void exitRule(ParseTreeListener listener) {
16067 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitArchitecture(this);
16068 		}
16069 	}
16070 
16071 	public final ArchitectureContext architecture() throws RecognitionException {
16072 		ArchitectureContext _localctx = new ArchitectureContext(_ctx, getState());
16073 		enterRule(_localctx, 482, RULE_architecture);
16074 		int _la;
16075 		try {
16076 			enterOuterAlt(_localctx, 1);
16077 			{
16078 			setState(2394);
16079 			_la = _input.LA(1);
16080 			if ( !(((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & ((1L << (T__125 - 126)) | (1L << (T__126 - 126)) | (1L << (T__127 - 126)) | (1L << (T__128 - 126)))) != 0)) ) {
16081 			_errHandler.recoverInline(this);
16082 			} else {
16083 				consume();
16084 			}
16085 			}
16086 		}
16087 		catch (RecognitionException re) {
16088 			_localctx.exception = re;
16089 			_errHandler.reportError(this, re);
16090 			_errHandler.recover(this, re);
16091 		}
16092 		finally {
16093 			exitRule();
16094 		}
16095 		return _localctx;
16096 	}
16097 
16098 	public static class LineControlStatementContext extends ParserRuleContext {
16099 		public LineNumberContext lineNumber() {
16100 			return getRuleContext(LineNumberContext.class,0);
16101 		}
16102 		public FileNameContext fileName() {
16103 			return getRuleContext(FileNameContext.class,0);
16104 		}
16105 		public LineControlStatementContext(ParserRuleContext parent, int invokingState) {
16106 			super(parent, invokingState);
16107 		}
16108 		@Override public int getRuleIndex() { return RULE_lineControlStatement; }
16109 		@Override
16110 		public void enterRule(ParseTreeListener listener) {
16111 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLineControlStatement(this);
16112 		}
16113 		@Override
16114 		public void exitRule(ParseTreeListener listener) {
16115 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLineControlStatement(this);
16116 		}
16117 	}
16118 
16119 	public final LineControlStatementContext lineControlStatement() throws RecognitionException {
16120 		LineControlStatementContext _localctx = new LineControlStatementContext(_ctx, getState());
16121 		enterRule(_localctx, 484, RULE_lineControlStatement);
16122 		try {
16123 			enterOuterAlt(_localctx, 1);
16124 			{
16125 			setState(2396);
16126 			match(T__129);
16127 			setState(2400);
16128 			_errHandler.sync(this);
16129 			switch ( getInterpreter().adaptivePredict(_input,303,_ctx) ) {
16130 			case 1:
16131 				{
16132 				setState(2397);
16133 				lineNumber();
16134 				setState(2398);
16135 				fileName();
16136 				}
16137 				break;
16138 			}
16139 			}
16140 		}
16141 		catch (RecognitionException re) {
16142 			_localctx.exception = re;
16143 			_errHandler.reportError(this, re);
16144 			_errHandler.recover(this, re);
16145 		}
16146 		finally {
16147 			exitRule();
16148 		}
16149 		return _localctx;
16150 	}
16151 
16152 	public static class LineNumberContext extends ParserRuleContext {
16153 		public IntegerLiteralContext integerLiteral() {
16154 			return getRuleContext(IntegerLiteralContext.class,0);
16155 		}
16156 		public LineNumberContext(ParserRuleContext parent, int invokingState) {
16157 			super(parent, invokingState);
16158 		}
16159 		@Override public int getRuleIndex() { return RULE_lineNumber; }
16160 		@Override
16161 		public void enterRule(ParseTreeListener listener) {
16162 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLineNumber(this);
16163 		}
16164 		@Override
16165 		public void exitRule(ParseTreeListener listener) {
16166 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLineNumber(this);
16167 		}
16168 	}
16169 
16170 	public final LineNumberContext lineNumber() throws RecognitionException {
16171 		LineNumberContext _localctx = new LineNumberContext(_ctx, getState());
16172 		enterRule(_localctx, 486, RULE_lineNumber);
16173 		try {
16174 			enterOuterAlt(_localctx, 1);
16175 			{
16176 			setState(2402);
16177 			integerLiteral();
16178 			}
16179 		}
16180 		catch (RecognitionException re) {
16181 			_localctx.exception = re;
16182 			_errHandler.reportError(this, re);
16183 			_errHandler.recover(this, re);
16184 		}
16185 		finally {
16186 			exitRule();
16187 		}
16188 		return _localctx;
16189 	}
16190 
16191 	public static class FileNameContext extends ParserRuleContext {
16192 		public TerminalNode StringLiteral() { return getToken(SwiftParser.StringLiteral, 0); }
16193 		public FileNameContext(ParserRuleContext parent, int invokingState) {
16194 			super(parent, invokingState);
16195 		}
16196 		@Override public int getRuleIndex() { return RULE_fileName; }
16197 		@Override
16198 		public void enterRule(ParseTreeListener listener) {
16199 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterFileName(this);
16200 		}
16201 		@Override
16202 		public void exitRule(ParseTreeListener listener) {
16203 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitFileName(this);
16204 		}
16205 	}
16206 
16207 	public final FileNameContext fileName() throws RecognitionException {
16208 		FileNameContext _localctx = new FileNameContext(_ctx, getState());
16209 		enterRule(_localctx, 488, RULE_fileName);
16210 		try {
16211 			enterOuterAlt(_localctx, 1);
16212 			{
16213 			setState(2404);
16214 			match(StringLiteral);
16215 			}
16216 		}
16217 		catch (RecognitionException re) {
16218 			_localctx.exception = re;
16219 			_errHandler.reportError(this, re);
16220 			_errHandler.recover(this, re);
16221 		}
16222 		finally {
16223 			exitRule();
16224 		}
16225 		return _localctx;
16226 	}
16227 
16228 	public static class IdentifierContext extends ParserRuleContext {
16229 		public TerminalNode Identifier() { return getToken(SwiftParser.Identifier, 0); }
16230 		public ContextSensitiveKeywordContext contextSensitiveKeyword() {
16231 			return getRuleContext(ContextSensitiveKeywordContext.class,0);
16232 		}
16233 		public IdentifierContext(ParserRuleContext parent, int invokingState) {
16234 			super(parent, invokingState);
16235 		}
16236 		@Override public int getRuleIndex() { return RULE_identifier; }
16237 		@Override
16238 		public void enterRule(ParseTreeListener listener) {
16239 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterIdentifier(this);
16240 		}
16241 		@Override
16242 		public void exitRule(ParseTreeListener listener) {
16243 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitIdentifier(this);
16244 		}
16245 	}
16246 
16247 	public final IdentifierContext identifier() throws RecognitionException {
16248 		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
16249 		enterRule(_localctx, 490, RULE_identifier);
16250 		try {
16251 			setState(2408);
16252 			switch (_input.LA(1)) {
16253 			case Identifier:
16254 				enterOuterAlt(_localctx, 1);
16255 				{
16256 				setState(2406);
16257 				match(Identifier);
16258 				}
16259 				break;
16260 			case T__30:
16261 			case T__31:
16262 			case T__32:
16263 			case T__34:
16264 			case T__42:
16265 			case T__43:
16266 			case T__44:
16267 			case T__45:
16268 			case T__46:
16269 			case T__47:
16270 			case T__48:
16271 			case T__49:
16272 			case T__50:
16273 			case T__51:
16274 			case T__52:
16275 			case T__53:
16276 			case T__55:
16277 			case T__58:
16278 			case T__60:
16279 			case T__71:
16280 			case T__72:
16281 			case T__73:
16282 			case T__81:
16283 			case T__88:
16284 			case T__89:
16285 			case T__90:
16286 			case T__91:
16287 			case T__92:
16288 			case T__93:
16289 			case T__116:
16290 			case T__117:
16291 			case T__123:
16292 			case T__124:
16293 			case T__125:
16294 			case T__126:
16295 			case T__127:
16296 			case T__128:
16297 			case T__130:
16298 				enterOuterAlt(_localctx, 2);
16299 				{
16300 				setState(2407);
16301 				contextSensitiveKeyword();
16302 				}
16303 				break;
16304 			default:
16305 				throw new NoViableAltException(this);
16306 			}
16307 		}
16308 		catch (RecognitionException re) {
16309 			_localctx.exception = re;
16310 			_errHandler.reportError(this, re);
16311 			_errHandler.recover(this, re);
16312 		}
16313 		finally {
16314 			exitRule();
16315 		}
16316 		return _localctx;
16317 	}
16318 
16319 	public static class KeywordContext extends ParserRuleContext {
16320 		public KeywordContext(ParserRuleContext parent, int invokingState) {
16321 			super(parent, invokingState);
16322 		}
16323 		@Override public int getRuleIndex() { return RULE_keyword; }
16324 		@Override
16325 		public void enterRule(ParseTreeListener listener) {
16326 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterKeyword(this);
16327 		}
16328 		@Override
16329 		public void exitRule(ParseTreeListener listener) {
16330 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitKeyword(this);
16331 		}
16332 	}
16333 
16334 	public final KeywordContext keyword() throws RecognitionException {
16335 		KeywordContext _localctx = new KeywordContext(_ctx, getState());
16336 		enterRule(_localctx, 492, RULE_keyword);
16337 		int _la;
16338 		try {
16339 			enterOuterAlt(_localctx, 1);
16340 			{
16341 			setState(2410);
16342 			_la = _input.LA(1);
16343 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__12) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__23) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__41) | (1L << T__42) | (1L << T__54))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__66 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__82 - 64)) | (1L << (T__85 - 64)) | (1L << (T__86 - 64)) | (1L << (T__87 - 64)) | (1L << (T__94 - 64)) | (1L << (T__95 - 64)) | (1L << (T__109 - 64)) | (1L << (T__110 - 64)) | (1L << (T__113 - 64)) | (1L << (T__116 - 64)) | (1L << (T__118 - 64)))) != 0)) ) {
16344 			_errHandler.recoverInline(this);
16345 			} else {
16346 				consume();
16347 			}
16348 			}
16349 		}
16350 		catch (RecognitionException re) {
16351 			_localctx.exception = re;
16352 			_errHandler.reportError(this, re);
16353 			_errHandler.recover(this, re);
16354 		}
16355 		finally {
16356 			exitRule();
16357 		}
16358 		return _localctx;
16359 	}
16360 
16361 	public static class ContextSensitiveKeywordContext extends ParserRuleContext {
16362 		public ContextSensitiveKeywordContext(ParserRuleContext parent, int invokingState) {
16363 			super(parent, invokingState);
16364 		}
16365 		@Override public int getRuleIndex() { return RULE_contextSensitiveKeyword; }
16366 		@Override
16367 		public void enterRule(ParseTreeListener listener) {
16368 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterContextSensitiveKeyword(this);
16369 		}
16370 		@Override
16371 		public void exitRule(ParseTreeListener listener) {
16372 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitContextSensitiveKeyword(this);
16373 		}
16374 	}
16375 
16376 	public final ContextSensitiveKeywordContext contextSensitiveKeyword() throws RecognitionException {
16377 		ContextSensitiveKeywordContext _localctx = new ContextSensitiveKeywordContext(_ctx, getState());
16378 		enterRule(_localctx, 494, RULE_contextSensitiveKeyword);
16379 		int _la;
16380 		try {
16381 			enterOuterAlt(_localctx, 1);
16382 			{
16383 			setState(2412);
16384 			_la = _input.LA(1);
16385 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__34) | (1L << T__42) | (1L << T__43) | (1L << T__44) | (1L << T__45) | (1L << T__46) | (1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52) | (1L << T__53) | (1L << T__55) | (1L << T__58) | (1L << T__60))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (T__71 - 72)) | (1L << (T__72 - 72)) | (1L << (T__73 - 72)) | (1L << (T__81 - 72)) | (1L << (T__88 - 72)) | (1L << (T__89 - 72)) | (1L << (T__90 - 72)) | (1L << (T__91 - 72)) | (1L << (T__92 - 72)) | (1L << (T__93 - 72)) | (1L << (T__116 - 72)) | (1L << (T__117 - 72)) | (1L << (T__123 - 72)) | (1L << (T__124 - 72)) | (1L << (T__125 - 72)) | (1L << (T__126 - 72)) | (1L << (T__127 - 72)) | (1L << (T__128 - 72)) | (1L << (T__130 - 72)))) != 0)) ) {
16386 			_errHandler.recoverInline(this);
16387 			} else {
16388 				consume();
16389 			}
16390 			}
16391 		}
16392 		catch (RecognitionException re) {
16393 			_localctx.exception = re;
16394 			_errHandler.reportError(this, re);
16395 			_errHandler.recover(this, re);
16396 		}
16397 		finally {
16398 			exitRule();
16399 		}
16400 		return _localctx;
16401 	}
16402 
16403 	public static class IdentifierListContext extends ParserRuleContext {
16404 		public List<IdentifierContext> identifier() {
16405 			return getRuleContexts(IdentifierContext.class);
16406 		}
16407 		public IdentifierContext identifier(int i) {
16408 			return getRuleContext(IdentifierContext.class,i);
16409 		}
16410 		public IdentifierListContext(ParserRuleContext parent, int invokingState) {
16411 			super(parent, invokingState);
16412 		}
16413 		@Override public int getRuleIndex() { return RULE_identifierList; }
16414 		@Override
16415 		public void enterRule(ParseTreeListener listener) {
16416 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterIdentifierList(this);
16417 		}
16418 		@Override
16419 		public void exitRule(ParseTreeListener listener) {
16420 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitIdentifierList(this);
16421 		}
16422 	}
16423 
16424 	public final IdentifierListContext identifierList() throws RecognitionException {
16425 		IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState());
16426 		enterRule(_localctx, 496, RULE_identifierList);
16427 		int _la;
16428 		try {
16429 			enterOuterAlt(_localctx, 1);
16430 			{
16431 			setState(2416);
16432 			switch (_input.LA(1)) {
16433 			case T__30:
16434 			case T__31:
16435 			case T__32:
16436 			case T__34:
16437 			case T__42:
16438 			case T__43:
16439 			case T__44:
16440 			case T__45:
16441 			case T__46:
16442 			case T__47:
16443 			case T__48:
16444 			case T__49:
16445 			case T__50:
16446 			case T__51:
16447 			case T__52:
16448 			case T__53:
16449 			case T__55:
16450 			case T__58:
16451 			case T__60:
16452 			case T__71:
16453 			case T__72:
16454 			case T__73:
16455 			case T__81:
16456 			case T__88:
16457 			case T__89:
16458 			case T__90:
16459 			case T__91:
16460 			case T__92:
16461 			case T__93:
16462 			case T__116:
16463 			case T__117:
16464 			case T__123:
16465 			case T__124:
16466 			case T__125:
16467 			case T__126:
16468 			case T__127:
16469 			case T__128:
16470 			case T__130:
16471 			case Identifier:
16472 				{
16473 				setState(2414);
16474 				identifier();
16475 				}
16476 				break;
16477 			case T__80:
16478 				{
16479 				setState(2415);
16480 				match(T__80);
16481 				}
16482 				break;
16483 			default:
16484 				throw new NoViableAltException(this);
16485 			}
16486 			setState(2425);
16487 			_errHandler.sync(this);
16488 			_la = _input.LA(1);
16489 			while (_la==T__15) {
16490 				{
16491 				{
16492 				setState(2418);
16493 				match(T__15);
16494 				setState(2421);
16495 				switch (_input.LA(1)) {
16496 				case T__30:
16497 				case T__31:
16498 				case T__32:
16499 				case T__34:
16500 				case T__42:
16501 				case T__43:
16502 				case T__44:
16503 				case T__45:
16504 				case T__46:
16505 				case T__47:
16506 				case T__48:
16507 				case T__49:
16508 				case T__50:
16509 				case T__51:
16510 				case T__52:
16511 				case T__53:
16512 				case T__55:
16513 				case T__58:
16514 				case T__60:
16515 				case T__71:
16516 				case T__72:
16517 				case T__73:
16518 				case T__81:
16519 				case T__88:
16520 				case T__89:
16521 				case T__90:
16522 				case T__91:
16523 				case T__92:
16524 				case T__93:
16525 				case T__116:
16526 				case T__117:
16527 				case T__123:
16528 				case T__124:
16529 				case T__125:
16530 				case T__126:
16531 				case T__127:
16532 				case T__128:
16533 				case T__130:
16534 				case Identifier:
16535 					{
16536 					setState(2419);
16537 					identifier();
16538 					}
16539 					break;
16540 				case T__80:
16541 					{
16542 					setState(2420);
16543 					match(T__80);
16544 					}
16545 					break;
16546 				default:
16547 					throw new NoViableAltException(this);
16548 				}
16549 				}
16550 				}
16551 				setState(2427);
16552 				_errHandler.sync(this);
16553 				_la = _input.LA(1);
16554 			}
16555 			}
16556 		}
16557 		catch (RecognitionException re) {
16558 			_localctx.exception = re;
16559 			_errHandler.reportError(this, re);
16560 			_errHandler.recover(this, re);
16561 		}
16562 		finally {
16563 			exitRule();
16564 		}
16565 		return _localctx;
16566 	}
16567 
16568 	public static class BooleanLiteralContext extends ParserRuleContext {
16569 		public TerminalNode BooleanLiteral() { return getToken(SwiftParser.BooleanLiteral, 0); }
16570 		public BooleanLiteralContext(ParserRuleContext parent, int invokingState) {
16571 			super(parent, invokingState);
16572 		}
16573 		@Override public int getRuleIndex() { return RULE_booleanLiteral; }
16574 		@Override
16575 		public void enterRule(ParseTreeListener listener) {
16576 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterBooleanLiteral(this);
16577 		}
16578 		@Override
16579 		public void exitRule(ParseTreeListener listener) {
16580 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitBooleanLiteral(this);
16581 		}
16582 	}
16583 
16584 	public final BooleanLiteralContext booleanLiteral() throws RecognitionException {
16585 		BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState());
16586 		enterRule(_localctx, 498, RULE_booleanLiteral);
16587 		try {
16588 			enterOuterAlt(_localctx, 1);
16589 			{
16590 			setState(2428);
16591 			match(BooleanLiteral);
16592 			}
16593 		}
16594 		catch (RecognitionException re) {
16595 			_localctx.exception = re;
16596 			_errHandler.reportError(this, re);
16597 			_errHandler.recover(this, re);
16598 		}
16599 		finally {
16600 			exitRule();
16601 		}
16602 		return _localctx;
16603 	}
16604 
16605 	public static class LiteralContext extends ParserRuleContext {
16606 		public NumericLiteralContext numericLiteral() {
16607 			return getRuleContext(NumericLiteralContext.class,0);
16608 		}
16609 		public TerminalNode StringLiteral() { return getToken(SwiftParser.StringLiteral, 0); }
16610 		public TerminalNode BooleanLiteral() { return getToken(SwiftParser.BooleanLiteral, 0); }
16611 		public TerminalNode NilLiteral() { return getToken(SwiftParser.NilLiteral, 0); }
16612 		public LiteralContext(ParserRuleContext parent, int invokingState) {
16613 			super(parent, invokingState);
16614 		}
16615 		@Override public int getRuleIndex() { return RULE_literal; }
16616 		@Override
16617 		public void enterRule(ParseTreeListener listener) {
16618 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterLiteral(this);
16619 		}
16620 		@Override
16621 		public void exitRule(ParseTreeListener listener) {
16622 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitLiteral(this);
16623 		}
16624 	}
16625 
16626 	public final LiteralContext literal() throws RecognitionException {
16627 		LiteralContext _localctx = new LiteralContext(_ctx, getState());
16628 		enterRule(_localctx, 500, RULE_literal);
16629 		try {
16630 			setState(2434);
16631 			switch (_input.LA(1)) {
16632 			case T__99:
16633 			case BinaryLiteral:
16634 			case OctalLiteral:
16635 			case DecimalLiteral:
16636 			case HexadecimalLiteral:
16637 			case FloatingPointLiteral:
16638 				enterOuterAlt(_localctx, 1);
16639 				{
16640 				setState(2430);
16641 				numericLiteral();
16642 				}
16643 				break;
16644 			case StringLiteral:
16645 				enterOuterAlt(_localctx, 2);
16646 				{
16647 				setState(2431);
16648 				match(StringLiteral);
16649 				}
16650 				break;
16651 			case BooleanLiteral:
16652 				enterOuterAlt(_localctx, 3);
16653 				{
16654 				setState(2432);
16655 				match(BooleanLiteral);
16656 				}
16657 				break;
16658 			case NilLiteral:
16659 				enterOuterAlt(_localctx, 4);
16660 				{
16661 				setState(2433);
16662 				match(NilLiteral);
16663 				}
16664 				break;
16665 			default:
16666 				throw new NoViableAltException(this);
16667 			}
16668 		}
16669 		catch (RecognitionException re) {
16670 			_localctx.exception = re;
16671 			_errHandler.reportError(this, re);
16672 			_errHandler.recover(this, re);
16673 		}
16674 		finally {
16675 			exitRule();
16676 		}
16677 		return _localctx;
16678 	}
16679 
16680 	public static class NumericLiteralContext extends ParserRuleContext {
16681 		public IntegerLiteralContext integerLiteral() {
16682 			return getRuleContext(IntegerLiteralContext.class,0);
16683 		}
16684 		public TerminalNode FloatingPointLiteral() { return getToken(SwiftParser.FloatingPointLiteral, 0); }
16685 		public NumericLiteralContext(ParserRuleContext parent, int invokingState) {
16686 			super(parent, invokingState);
16687 		}
16688 		@Override public int getRuleIndex() { return RULE_numericLiteral; }
16689 		@Override
16690 		public void enterRule(ParseTreeListener listener) {
16691 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterNumericLiteral(this);
16692 		}
16693 		@Override
16694 		public void exitRule(ParseTreeListener listener) {
16695 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitNumericLiteral(this);
16696 		}
16697 	}
16698 
16699 	public final NumericLiteralContext numericLiteral() throws RecognitionException {
16700 		NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
16701 		enterRule(_localctx, 502, RULE_numericLiteral);
16702 		int _la;
16703 		try {
16704 			setState(2444);
16705 			_errHandler.sync(this);
16706 			switch ( getInterpreter().adaptivePredict(_input,311,_ctx) ) {
16707 			case 1:
16708 				enterOuterAlt(_localctx, 1);
16709 				{
16710 				setState(2437);
16711 				_la = _input.LA(1);
16712 				if (_la==T__99) {
16713 					{
16714 					setState(2436);
16715 					match(T__99);
16716 					}
16717 				}
16718 
16719 				setState(2439);
16720 				integerLiteral();
16721 				}
16722 				break;
16723 			case 2:
16724 				enterOuterAlt(_localctx, 2);
16725 				{
16726 				setState(2441);
16727 				_la = _input.LA(1);
16728 				if (_la==T__99) {
16729 					{
16730 					setState(2440);
16731 					match(T__99);
16732 					}
16733 				}
16734 
16735 				setState(2443);
16736 				match(FloatingPointLiteral);
16737 				}
16738 				break;
16739 			}
16740 		}
16741 		catch (RecognitionException re) {
16742 			_localctx.exception = re;
16743 			_errHandler.reportError(this, re);
16744 			_errHandler.recover(this, re);
16745 		}
16746 		finally {
16747 			exitRule();
16748 		}
16749 		return _localctx;
16750 	}
16751 
16752 	public static class IntegerLiteralContext extends ParserRuleContext {
16753 		public TerminalNode BinaryLiteral() { return getToken(SwiftParser.BinaryLiteral, 0); }
16754 		public TerminalNode OctalLiteral() { return getToken(SwiftParser.OctalLiteral, 0); }
16755 		public TerminalNode DecimalLiteral() { return getToken(SwiftParser.DecimalLiteral, 0); }
16756 		public TerminalNode HexadecimalLiteral() { return getToken(SwiftParser.HexadecimalLiteral, 0); }
16757 		public IntegerLiteralContext(ParserRuleContext parent, int invokingState) {
16758 			super(parent, invokingState);
16759 		}
16760 		@Override public int getRuleIndex() { return RULE_integerLiteral; }
16761 		@Override
16762 		public void enterRule(ParseTreeListener listener) {
16763 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).enterIntegerLiteral(this);
16764 		}
16765 		@Override
16766 		public void exitRule(ParseTreeListener listener) {
16767 			if ( listener instanceof SwiftListener ) ((SwiftListener)listener).exitIntegerLiteral(this);
16768 		}
16769 	}
16770 
16771 	public final IntegerLiteralContext integerLiteral() throws RecognitionException {
16772 		IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState());
16773 		enterRule(_localctx, 504, RULE_integerLiteral);
16774 		int _la;
16775 		try {
16776 			enterOuterAlt(_localctx, 1);
16777 			{
16778 			setState(2446);
16779 			_la = _input.LA(1);
16780 			if ( !(((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & ((1L << (BinaryLiteral - 139)) | (1L << (OctalLiteral - 139)) | (1L << (DecimalLiteral - 139)) | (1L << (HexadecimalLiteral - 139)))) != 0)) ) {
16781 			_errHandler.recoverInline(this);
16782 			} else {
16783 				consume();
16784 			}
16785 			}
16786 		}
16787 		catch (RecognitionException re) {
16788 			_localctx.exception = re;
16789 			_errHandler.reportError(this, re);
16790 			_errHandler.recover(this, re);
16791 		}
16792 		finally {
16793 			exitRule();
16794 		}
16795 		return _localctx;
16796 	}
16797 
16798 	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
16799 		switch (ruleIndex) {
16800 		case 155:
16801 			return pattern_sempred((PatternContext)_localctx, predIndex);
16802 		case 206:
16803 			return postfixExpression_sempred((PostfixExpressionContext)_localctx, predIndex);
16804 		case 213:
16805 			return sType_sempred((STypeContext)_localctx, predIndex);
16806 		case 238:
16807 			return buildConfiguration_sempred((BuildConfigurationContext)_localctx, predIndex);
16808 		}
16809 		return true;
16810 	}
16811 	private boolean pattern_sempred(PatternContext _localctx, int predIndex) {
16812 		switch (predIndex) {
16813 		case 0:
16814 			return precpred(_ctx, 2);
16815 		}
16816 		return true;
16817 	}
16818 	private boolean postfixExpression_sempred(PostfixExpressionContext _localctx, int predIndex) {
16819 		switch (predIndex) {
16820 		case 1:
16821 			return precpred(_ctx, 11);
16822 		case 2:
16823 			return precpred(_ctx, 10);
16824 		case 3:
16825 			return precpred(_ctx, 9);
16826 		case 4:
16827 			return precpred(_ctx, 8);
16828 		case 5:
16829 			return precpred(_ctx, 7);
16830 		case 6:
16831 			return precpred(_ctx, 6);
16832 		case 7:
16833 			return precpred(_ctx, 5);
16834 		case 8:
16835 			return precpred(_ctx, 4);
16836 		case 9:
16837 			return precpred(_ctx, 3);
16838 		case 10:
16839 			return precpred(_ctx, 2);
16840 		case 11:
16841 			return precpred(_ctx, 1);
16842 		}
16843 		return true;
16844 	}
16845 	private boolean sType_sempred(STypeContext _localctx, int predIndex) {
16846 		switch (predIndex) {
16847 		case 12:
16848 			return precpred(_ctx, 9);
16849 		case 13:
16850 			return precpred(_ctx, 8);
16851 		case 14:
16852 			return precpred(_ctx, 5);
16853 		case 15:
16854 			return precpred(_ctx, 4);
16855 		case 16:
16856 			return precpred(_ctx, 2);
16857 		case 17:
16858 			return precpred(_ctx, 1);
16859 		}
16860 		return true;
16861 	}
16862 	private boolean buildConfiguration_sempred(BuildConfigurationContext _localctx, int predIndex) {
16863 		switch (predIndex) {
16864 		case 18:
16865 			return precpred(_ctx, 1);
16866 		}
16867 		return true;
16868 	}
16869 
16870 	public static final String _serializedATN =
16871 		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u0097\u0993\4\2\t"+
16872 		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
16873 		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
16874 		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
16875 		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
16876 		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
16877 		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
16878 		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
16879 		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
16880 		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
16881 		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
16882 		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
16883 		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
16884 		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
16885 		"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
16886 		"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
16887 		"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
16888 		"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
16889 		"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
16890 		"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+
16891 		"\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+
16892 		"\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+
16893 		"\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+
16894 		"\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+
16895 		"\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+
16896 		"\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+
16897 		"\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+
16898 		"\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+
16899 		"\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+
16900 		"\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+
16901 		"\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+
16902 		"\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+
16903 		"\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+
16904 		"\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+
16905 		"\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+
16906 		"\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+
16907 		"\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+
16908 		"\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+
16909 		"\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1"+
16910 		"\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5"+
16911 		"\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa"+
16912 		"\t\u00fa\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd\t\u00fd\4\u00fe\t\u00fe"+
16913 		"\3\2\3\2\7\2\u01ff\n\2\f\2\16\2\u0202\13\2\3\2\3\2\3\3\3\3\5\3\u0208\n"+
16914 		"\3\3\3\3\3\5\3\u020c\n\3\3\3\3\3\5\3\u0210\n\3\3\3\3\3\3\3\5\3\u0215\n"+
16915 		"\3\3\3\3\3\5\3\u0219\n\3\3\3\3\3\5\3\u021d\n\3\3\3\3\3\5\3\u0221\n\3\3"+
16916 		"\3\3\3\5\3\u0225\n\3\5\3\u0227\n\3\3\4\6\4\u022a\n\4\r\4\16\4\u022b\3"+
16917 		"\5\3\5\3\5\3\5\5\5\u0232\n\5\3\6\3\6\5\6\u0236\n\6\3\6\3\6\5\6\u023a\n"+
16918 		"\6\3\6\3\6\5\6\u023e\n\6\3\6\3\6\3\6\3\6\5\6\u0244\n\6\3\6\3\6\5\6\u0248"+
16919 		"\n\6\3\6\3\6\5\6\u024c\n\6\3\6\3\6\5\6\u0250\n\6\3\7\3\7\5\7\u0254\n\7"+
16920 		"\3\b\3\b\5\b\u0258\n\b\3\b\3\b\3\b\3\b\5\b\u025e\n\b\3\b\3\b\3\t\3\t\3"+
16921 		"\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\5\13\u026e\n\13\3\f\3\f\3\f"+
16922 		"\3\f\5\f\u0274\n\f\3\r\3\r\3\r\3\r\5\r\u027a\n\r\3\16\3\16\3\16\3\16\3"+
16923 		"\16\3\17\3\17\3\17\3\17\5\17\u0285\n\17\3\17\3\17\3\20\3\20\5\20\u028b"+
16924 		"\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21"+
16925 		"\u0299\n\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\7\23\u02a2\n\23\f\23\16"+
16926 		"\23\u02a5\13\23\3\24\3\24\5\24\u02a9\n\24\3\25\3\25\3\25\3\26\3\26\3\26"+
16927 		"\3\26\3\26\3\26\5\26\u02b4\n\26\3\27\3\27\3\27\3\30\3\30\3\31\3\31\3\31"+
16928 		"\3\31\3\31\5\31\u02c0\n\31\3\32\3\32\5\32\u02c4\n\32\3\33\3\33\5\33\u02c8"+
16929 		"\n\33\3\34\3\34\3\35\3\35\5\35\u02ce\n\35\3\36\3\36\3\36\3\37\3\37\3\37"+
16930 		"\3 \3 \3 \5 \u02d9\n \3!\3!\5!\u02dd\n!\3\"\3\"\5\"\u02e1\n\"\3\"\5\""+
16931 		"\u02e4\n\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u02f2\n#\3$\3$\3$"+
16932 		"\7$\u02f7\n$\f$\16$\u02fa\13$\3%\3%\3%\5%\u02ff\n%\3&\3&\3&\3&\5&\u0305"+
16933 		"\n&\3\'\3\'\3\'\5\'\u030a\n\'\3\'\5\'\u030d\n\'\3(\3(\3(\3(\3(\3(\3(\3"+
16934 		"(\5(\u0317\n(\3)\3)\3)\7)\u031c\n)\f)\16)\u031f\13)\3*\3*\3*\3*\5*\u0325"+
16935 		"\n*\3+\3+\3+\3,\3,\3-\3-\3-\3-\3-\3.\3.\3.\7.\u0334\n.\f.\16.\u0337\13"+
16936 		".\3/\3/\3/\3/\5/\u033d\n/\3\60\3\60\3\61\3\61\3\62\3\62\3\62\5\62\u0346"+
16937 		"\n\62\3\62\3\62\3\63\3\63\3\63\7\63\u034d\n\63\f\63\16\63\u0350\13\63"+
16938 		"\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\5\64\u035b\n\64\3\65\3\65"+
16939 		"\3\65\3\66\3\66\3\66\7\66\u0363\n\66\f\66\16\66\u0366\13\66\3\67\3\67"+
16940 		"\5\67\u036a\n\67\38\38\38\38\38\38\38\38\58\u0374\n8\39\39\39\39\3:\3"+
16941 		":\3:\3:\3;\3;\3;\7;\u0381\n;\f;\16;\u0384\13;\3<\3<\3=\3=\5=\u038a\n="+
16942 		"\3=\3=\5=\u038e\n=\3=\3=\5=\u0392\n=\3=\3=\5=\u0396\n=\3=\3=\5=\u039a"+
16943 		"\n=\3=\3=\5=\u039e\n=\3=\3=\5=\u03a2\n=\3=\3=\5=\u03a6\n=\3=\3=\5=\u03aa"+
16944 		"\n=\3=\3=\5=\u03ae\n=\3=\3=\5=\u03b2\n=\3=\3=\5=\u03b6\n=\3=\3=\5=\u03ba"+
16945 		"\n=\3=\3=\5=\u03be\n=\3=\3=\5=\u03c2\n=\5=\u03c4\n=\3>\3>\5>\u03c8\n>"+
16946 		"\3?\3?\5?\u03cc\n?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@"+
16947 		"\3@\3@\3@\3@\3@\3@\3@\3@\5@\u03e7\n@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A"+
16948 		"\3A\3A\3A\3A\5A\u03f8\nA\3B\3B\5B\u03fc\nB\3C\3C\5C\u0400\nC\3C\3C\3D"+
16949 		"\5D\u0405\nD\3D\3D\5D\u0409\nD\3D\3D\3E\3E\3F\3F\3F\3F\3F\5F\u0414\nF"+
16950 		"\3G\3G\5G\u0418\nG\3H\5H\u041b\nH\3H\5H\u041e\nH\3H\3H\3H\3I\3I\3I\7I"+
16951 		"\u0426\nI\fI\16I\u0429\13I\3J\3J\5J\u042d\nJ\3K\3K\3K\3L\3L\3L\3L\3L\3"+
16952 		"L\3L\3L\3L\3L\3L\3L\3L\3L\3L\3L\3L\3L\3L\5L\u0445\nL\3L\3L\3L\3L\3L\3"+
16953 		"L\3L\3L\3L\3L\5L\u0451\nL\3M\5M\u0454\nM\3M\5M\u0457\nM\3M\3M\3N\3N\3"+
16954 		"O\3O\3O\5O\u0460\nO\3O\3O\3O\3O\3O\3O\3O\5O\u0469\nO\3P\5P\u046c\nP\3"+
16955 		"P\3P\3P\3Q\5Q\u0472\nQ\3Q\3Q\5Q\u0476\nQ\3Q\3Q\3R\3R\3R\3R\3S\3S\3S\5"+
16956 		"S\u0481\nS\3S\3S\3S\3S\3S\3S\3S\5S\u048a\nS\3T\5T\u048d\nT\3T\3T\3U\5"+
16957 		"U\u0492\nU\3U\3U\3V\3V\3V\5V\u0499\nV\3V\3V\3V\3V\3V\5V\u04a0\nV\3V\3"+
16958 		"V\5V\u04a4\nV\3W\5W\u04a7\nW\3W\3W\5W\u04ab\nW\3W\3W\3X\5X\u04b0\nX\3"+
16959 		"X\3X\5X\u04b4\nX\3X\3X\3Y\3Y\3Y\3Z\5Z\u04bc\nZ\3Z\5Z\u04bf\nZ\3Z\3Z\3"+
16960 		"Z\3[\3[\3\\\3\\\3\\\3]\3]\3]\5]\u04cc\n]\3]\3]\3]\3]\3]\3]\5]\u04d4\n"+
16961 		"]\3]\3]\5]\u04d8\n]\3^\5^\u04db\n^\3^\5^\u04de\n^\3^\3^\3_\3_\5_\u04e4"+
16962 		"\n_\3`\3`\5`\u04e8\n`\3`\5`\u04eb\n`\3a\3a\5a\u04ef\na\3a\3a\3b\3b\3c"+
16963 		"\3c\5c\u04f7\nc\3d\3d\3d\3d\3d\5d\u04fe\nd\3d\3d\5d\u0502\nd\3e\3e\3e"+
16964 		"\7e\u0507\ne\fe\16e\u050a\13e\3f\5f\u050d\nf\3f\5f\u0510\nf\3f\5f\u0513"+
16965 		"\nf\3f\5f\u0516\nf\3f\5f\u0519\nf\3f\3f\5f\u051d\nf\3f\5f\u0520\nf\3f"+
16966 		"\5f\u0523\nf\3f\3f\5f\u0527\nf\3f\5f\u052a\nf\3f\3f\5f\u052e\nf\3f\5f"+
16967 		"\u0531\nf\3f\5f\u0534\nf\3f\3f\5f\u0538\nf\3f\3f\3f\3f\5f\u053e\nf\3g"+
16968 		"\3g\5g\u0542\ng\3h\3h\5h\u0546\nh\3i\3i\3i\3j\5j\u054c\nj\3j\5j\u054f"+
16969 		"\nj\3j\3j\3k\3k\5k\u0555\nk\3l\5l\u0558\nl\3l\3l\3l\5l\u055d\nl\3l\5l"+
16970 		"\u0560\nl\3l\3l\5l\u0564\nl\3l\3l\3m\3m\5m\u056a\nm\3n\3n\3n\5n\u056f"+
16971 		"\nn\5n\u0571\nn\3o\5o\u0574\no\3o\5o\u0577\no\3o\3o\3o\3p\3p\3p\7p\u057f"+
16972 		"\np\fp\16p\u0582\13p\3q\3q\5q\u0586\nq\3r\3r\3s\3s\3t\3t\3t\5t\u058f\n"+
16973 		"t\3t\5t\u0592\nt\3t\3t\5t\u0596\nt\3t\3t\3u\3u\5u\u059c\nu\3v\3v\5v\u05a0"+
16974 		"\nv\3w\5w\u05a3\nw\3w\3w\3w\3x\3x\3x\7x\u05ab\nx\fx\16x\u05ae\13x\3y\3"+
16975 		"y\5y\u05b2\ny\3z\3z\3z\3{\5{\u05b8\n{\3{\5{\u05bb\n{\3{\3{\3{\5{\u05c0"+
16976 		"\n{\3{\5{\u05c3\n{\3{\3{\3|\3|\3}\3}\5}\u05cb\n}\3}\3}\3~\5~\u05d0\n~"+
16977 		"\3~\7~\u05d3\n~\f~\16~\u05d6\13~\3~\3~\3~\5~\u05db\n~\3~\5~\u05de\n~\3"+
16978 		"~\3~\3\177\3\177\3\u0080\3\u0080\5\u0080\u05e6\n\u0080\3\u0080\3\u0080"+
16979 		"\3\u0081\5\u0081\u05eb\n\u0081\3\u0081\5\u0081\u05ee\n\u0081\3\u0081\3"+
16980 		"\u0081\3\u0081\5\u0081\u05f3\n\u0081\3\u0081\3\u0081\3\u0082\3\u0082\3"+
16981 		"\u0083\3\u0083\5\u0083\u05fb\n\u0083\3\u0083\3\u0083\3\u0084\3\u0084\5"+
16982 		"\u0084\u0601\n\u0084\3\u0084\3\u0084\5\u0084\u0605\n\u0084\3\u0084\3\u0084"+
16983 		"\5\u0084\u0609\n\u0084\3\u0084\3\u0084\5\u0084\u060d\n\u0084\3\u0084\3"+
16984 		"\u0084\5\u0084\u0611\n\u0084\5\u0084\u0613\n\u0084\3\u0085\3\u0085\5\u0085"+
16985 		"\u0617\n\u0085\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087"+
16986 		"\3\u0087\5\u0087\u0621\n\u0087\3\u0087\3\u0087\3\u0088\3\u0088\5\u0088"+
16987 		"\u0627\n\u0088\3\u0088\3\u0088\5\u0088\u062b\n\u0088\3\u0089\3\u0089\3"+
16988 		"\u0089\3\u0089\3\u008a\3\u008a\5\u008a\u0633\n\u008a\3\u008a\5\u008a\u0636"+
16989 		"\n\u008a\3\u008b\3\u008b\5\u008b\u063a\n\u008b\3\u008b\3\u008b\5\u008b"+
16990 		"\u063e\n\u008b\3\u008b\3\u008b\3\u008c\5\u008c\u0643\n\u008c\3\u008c\5"+
16991 		"\u008c\u0646\n\u008c\3\u008c\3\u008c\5\u008c\u064a\n\u008c\3\u008d\3\u008d"+
16992 		"\3\u008e\5\u008e\u064f\n\u008e\3\u008e\3\u008e\3\u008e\3\u008f\5\u008f"+
16993 		"\u0655\n\u008f\3\u008f\5\u008f\u0658\n\u008f\3\u008f\3\u008f\3\u008f\5"+
16994 		"\u008f\u065d\n\u008f\3\u008f\5\u008f\u0660\n\u008f\3\u008f\3\u008f\3\u0090"+
16995 		"\3\u0090\5\u0090\u0666\n\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091"+
16996 		"\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091"+
16997 		"\5\u0091\u0676\n\u0091\3\u0092\5\u0092\u0679\n\u0092\3\u0092\5\u0092\u067c"+
16998 		"\n\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\5\u0093\u0683\n\u0093"+
16999 		"\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\5\u0094\u068a\n\u0094\3\u0095"+
17000 		"\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096"+
17001 		"\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+
17002 		"\3\u0098\5\u0098\u06a0\n\u0098\3\u0098\5\u0098\u06a3\n\u0098\3\u0098\5"+
17003 		"\u0098\u06a6\n\u0098\3\u0098\5\u0098\u06a9\n\u0098\5\u0098\u06ab\n\u0098"+
17004 		"\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009b\3\u009b\3\u009b\3\u009c"+
17005 		"\3\u009c\3\u009d\3\u009d\3\u009d\5\u009d\u06ba\n\u009d\3\u009d\3\u009d"+
17006 		"\5\u009d\u06be\n\u009d\3\u009d\3\u009d\3\u009d\5\u009d\u06c3\n\u009d\3"+
17007 		"\u009d\3\u009d\3\u009d\3\u009d\5\u009d\u06c9\n\u009d\3\u009d\3\u009d\3"+
17008 		"\u009d\7\u009d\u06ce\n\u009d\f\u009d\16\u009d\u06d1\13\u009d\3\u009e\3"+
17009 		"\u009e\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u06db\n"+
17010 		"\u00a0\3\u00a1\3\u00a1\5\u00a1\u06df\n\u00a1\3\u00a1\3\u00a1\3\u00a2\3"+
17011 		"\u00a2\3\u00a2\7\u00a2\u06e6\n\u00a2\f\u00a2\16\u00a2\u06e9\13\u00a2\3"+
17012 		"\u00a3\3\u00a3\3\u00a4\5\u00a4\u06ee\n\u00a4\3\u00a4\5\u00a4\u06f1\n\u00a4"+
17013 		"\3\u00a4\3\u00a4\5\u00a4\u06f5\n\u00a4\3\u00a5\3\u00a5\5\u00a5\u06f9\n"+
17014 		"\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8"+
17015 		"\3\u00a8\3\u00a9\3\u00a9\3\u00a9\5\u00a9\u0707\n\u00a9\3\u00aa\3\u00aa"+
17016 		"\3\u00ab\3\u00ab\5\u00ab\u070d\n\u00ab\3\u00ab\3\u00ab\3\u00ac\6\u00ac"+
17017 		"\u0712\n\u00ac\r\u00ac\16\u00ac\u0713\3\u00ad\3\u00ad\5\u00ad\u0718\n"+
17018 		"\u00ad\3\u00ae\3\u00ae\5\u00ae\u071c\n\u00ae\3\u00ae\3\u00ae\3\u00ae\5"+
17019 		"\u00ae\u0721\n\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0726\n\u00ae\3\u00ae"+
17020 		"\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae"+
17021 		"\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u0739"+
17022 		"\n\u00ae\3\u00af\3\u00af\3\u00af\7\u00af\u073e\n\u00af\f\u00af\16\u00af"+
17023 		"\u0741\13\u00af\3\u00b0\5\u00b0\u0744\n\u00b0\3\u00b0\3\u00b0\7\u00b0"+
17024 		"\u0748\n\u00b0\f\u00b0\16\u00b0\u074b\13\u00b0\3\u00b1\5\u00b1\u074e\n"+
17025 		"\u00b1\3\u00b1\3\u00b1\5\u00b1\u0752\n\u00b1\3\u00b1\5\u00b1\u0755\n\u00b1"+
17026 		"\3\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\5\u00b3\u075c\n\u00b3\3\u00b4"+
17027 		"\3\u00b4\3\u00b4\3\u00b4\3\u00b4\5\u00b4\u0763\n\u00b4\3\u00b4\3\u00b4"+
17028 		"\3\u00b4\3\u00b4\5\u00b4\u0769\n\u00b4\3\u00b4\3\u00b4\3\u00b4\5\u00b4"+
17029 		"\u076e\n\u00b4\3\u00b5\3\u00b5\3\u00b6\3\u00b6\5\u00b6\u0774\n\u00b6\3"+
17030 		"\u00b6\3\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7"+
17031 		"\3\u00b7\3\u00b7\3\u00b7\3\u00b7\5\u00b7\u0783\n\u00b7\3\u00b8\3\u00b8"+
17032 		"\5\u00b8\u0787\n\u00b8\3\u00b8\5\u00b8\u078a\n\u00b8\3\u00b8\3\u00b8\3"+
17033 		"\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u0793\n\u00b8\3\u00b9\3"+
17034 		"\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u079c\n\u00b9\3"+
17035 		"\u00ba\3\u00ba\5\u00ba\u07a0\n\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb\3"+
17036 		"\u00bb\7\u00bb\u07a7\n\u00bb\f\u00bb\16\u00bb\u07aa\13\u00bb\3\u00bb\5"+
17037 		"\u00bb\u07ad\n\u00bb\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3"+
17038 		"\u00bd\3\u00bd\3\u00bd\5\u00bd\u07b8\n\u00bd\3\u00be\3\u00be\3\u00be\7"+
17039 		"\u00be\u07bd\n\u00be\f\u00be\16\u00be\u07c0\13\u00be\3\u00be\5\u00be\u07c3"+
17040 		"\n\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+
17041 		"\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0"+
17042 		"\u07d5\n\u00c0\3\u00c1\3\u00c1\3\u00c1\5\u00c1\u07da\n\u00c1\3\u00c2\3"+
17043 		"\u00c2\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4"+
17044 		"\3\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5\5\u00c5\u07eb\n\u00c5\3\u00c5"+
17045 		"\5\u00c5\u07ee\n\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\5\u00c6\u07f4\n"+
17046 		"\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u07fa\n\u00c6\3\u00c6\3"+
17047 		"\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0801\n\u00c6\3\u00c6\3\u00c6\3"+
17048 		"\u00c6\3\u00c6\3\u00c6\5\u00c6\u0808\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3"+
17049 		"\u00c6\3\u00c6\5\u00c6\u080f\n\u00c6\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3"+
17050 		"\u00c8\3\u00c8\3\u00c8\5\u00c8\u0818\n\u00c8\3\u00c9\5\u00c9\u081b\n\u00c9"+
17051 		"\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc"+
17052 		"\5\u00cc\u0826\n\u00cc\3\u00cc\3\u00cc\3\u00cd\3\u00cd\3\u00cd\7\u00cd"+
17053 		"\u082d\n\u00cd\f\u00cd\16\u00cd\u0830\13\u00cd\3\u00ce\3\u00ce\3\u00ce"+
17054 		"\3\u00ce\3\u00ce\5\u00ce\u0837\n\u00ce\3\u00cf\3\u00cf\3\u00d0\3\u00d0"+
17055 		"\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\5\u00d0\u0842\n\u00d0\3\u00d0"+
17056 		"\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0"+
17057 		"\3\u00d0\3\u00d0\3\u00d0\5\u00d0\u0851\n\u00d0\3\u00d0\3\u00d0\3\u00d0"+
17058 		"\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0"+
17059 		"\3\u00d0\3\u00d0\3\u00d0\7\u00d0\u0862\n\u00d0\f\u00d0\16\u00d0\u0865"+
17060 		"\13\u00d0\3\u00d1\3\u00d1\3\u00d2\3\u00d2\5\u00d2\u086b\n\u00d2\3\u00d3"+
17061 		"\3\u00d3\7\u00d3\u086f\n\u00d3\f\u00d3\16\u00d3\u0872\13\u00d3\3\u00d3"+
17062 		"\3\u00d3\7\u00d3\u0876\n\u00d3\f\u00d3\16\u00d3\u0879\13\u00d3\3\u00d3"+
17063 		"\5\u00d3\u087c\n\u00d3\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d6\3\u00d6"+
17064 		"\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\5\u00d7\u088a\n\u00d7"+
17065 		"\3\u00d7\3\u00d7\5\u00d7\u088e\n\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7"+
17066 		"\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d7"+
17067 		"\3\u00d7\3\u00d7\3\u00d7\7\u00d7\u08a0\n\u00d7\f\u00d7\16\u00d7\u08a3"+
17068 		"\13\u00d7\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9"+
17069 		"\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da\3\u00db\3\u00db\3\u00db\3\u00dc"+
17070 		"\3\u00dc\5\u00dc\u08b7\n\u00dc\3\u00dc\3\u00dc\3\u00dd\3\u00dd\5\u00dd"+
17071 		"\u08bd\n\u00dd\3\u00dd\3\u00dd\5\u00dd\u08c1\n\u00dd\3\u00dd\3\u00dd\3"+
17072 		"\u00dd\3\u00dd\5\u00dd\u08c7\n\u00dd\3\u00de\3\u00de\3\u00df\3\u00df\5"+
17073 		"\u00df\u08cd\n\u00df\3\u00df\3\u00df\3\u00e0\3\u00e0\5\u00e0\u08d3\n\u00e0"+
17074 		"\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\5\u00e1\u08da\n\u00e1\3\u00e2"+
17075 		"\5\u00e2\u08dd\n\u00e2\3\u00e2\5\u00e2\u08e0\n\u00e2\3\u00e2\3\u00e2\5"+
17076 		"\u00e2\u08e4\n\u00e2\3\u00e2\3\u00e2\3\u00e2\5\u00e2\u08e9\n\u00e2\3\u00e3"+
17077 		"\3\u00e3\3\u00e4\3\u00e4\3\u00e4\5\u00e4\u08f0\n\u00e4\3\u00e4\3\u00e4"+
17078 		"\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u08f9\n\u00e5\3\u00e6"+
17079 		"\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7"+
17080 		"\5\u00e7\u0905\n\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e8"+
17081 		"\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u0910\n\u00e8\3\u00e9\3\u00e9\3\u00e9"+
17082 		"\7\u00e9\u0915\n\u00e9\f\u00e9\16\u00e9\u0918\13\u00e9\3\u00ea\3\u00ea"+
17083 		"\3\u00eb\3\u00eb\5\u00eb\u091e\n\u00eb\3\u00ec\3\u00ec\3\u00ec\5\u00ec"+
17084 		"\u0923\n\u00ec\3\u00ec\5\u00ec\u0926\n\u00ec\3\u00ec\5\u00ec\u0929\n\u00ec"+
17085 		"\3\u00ec\3\u00ec\3\u00ed\6\u00ed\u092e\n\u00ed\r\u00ed\16\u00ed\u092f"+
17086 		"\3\u00ee\3\u00ee\3\u00ee\5\u00ee\u0935\n\u00ee\3\u00ef\3\u00ef\5\u00ef"+
17087 		"\u0939\n\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
17088 		"\3\u00f0\3\u00f0\3\u00f0\5\u00f0\u0945\n\u00f0\3\u00f0\3\u00f0\3\u00f0"+
17089 		"\7\u00f0\u094a\n\u00f0\f\u00f0\16\u00f0\u094d\13\u00f0\3\u00f1\3\u00f1"+
17090 		"\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\5\u00f1"+
17091 		"\u0959\n\u00f1\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f4\3\u00f4\3\u00f4"+
17092 		"\3\u00f4\5\u00f4\u0963\n\u00f4\3\u00f5\3\u00f5\3\u00f6\3\u00f6\3\u00f7"+
17093 		"\3\u00f7\5\u00f7\u096b\n\u00f7\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00fa"+
17094 		"\3\u00fa\5\u00fa\u0973\n\u00fa\3\u00fa\3\u00fa\3\u00fa\5\u00fa\u0978\n"+
17095 		"\u00fa\7\u00fa\u097a\n\u00fa\f\u00fa\16\u00fa\u097d\13\u00fa\3\u00fb\3"+
17096 		"\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc\5\u00fc\u0985\n\u00fc\3\u00fd\5"+
17097 		"\u00fd\u0988\n\u00fd\3\u00fd\3\u00fd\5\u00fd\u098c\n\u00fd\3\u00fd\5\u00fd"+
17098 		"\u098f\n\u00fd\3\u00fe\3\u00fe\3\u00fe\2\6\u0138\u019e\u01ac\u01de\u00ff"+
17099 		"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH"+
17100 		"JLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c"+
17101 		"\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4"+
17102 		"\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc"+
17103 		"\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4"+
17104 		"\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec"+
17105 		"\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104"+
17106 		"\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c"+
17107 		"\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134"+
17108 		"\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c"+
17109 		"\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164"+
17110 		"\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c"+
17111 		"\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194"+
17112 		"\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac"+
17113 		"\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4"+
17114 		"\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc"+
17115 		"\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4"+
17116 		"\u01f6\u01f8\u01fa\2\20\3\2!(\4\2\u008f\u008f\u0091\u0092\5\2\35\35,,"+
17117 		"CG\3\2MN\3\2VW\3\2^`\5\2::==rs\13\2  )+IIVWffhhjjuv\u0088\u0088\3\2uv"+
17118 		"\6\2!!##%%\'\'\3\2\u0080\u0083\22\2\5\5\b\r\17\17\23\27\32\32\34\36,-"+
17119 		"99BGUUXZabpqttwwyy\16\2!#%%-8::==??JLTT[`wx~\u0083\u0085\u0085\3\2\u008d"+
17120 		"\u0090\u0a50\2\u0200\3\2\2\2\4\u0226\3\2\2\2\6\u0229\3\2\2\2\b\u0231\3"+
17121 		"\2\2\2\n\u024f\3\2\2\2\f\u0253\3\2\2\2\16\u0255\3\2\2\2\20\u0261\3\2\2"+
17122 		"\2\22\u0265\3\2\2\2\24\u026d\3\2\2\2\26\u026f\3\2\2\2\30\u0279\3\2\2\2"+
17123 		"\32\u027b\3\2\2\2\34\u0280\3\2\2\2\36\u0288\3\2\2\2 \u0298\3\2\2\2\"\u029a"+
17124 		"\3\2\2\2$\u029e\3\2\2\2&\u02a6\3\2\2\2(\u02aa\3\2\2\2*\u02b3\3\2\2\2,"+
17125 		"\u02b5\3\2\2\2.\u02b8\3\2\2\2\60\u02bf\3\2\2\2\62\u02c1\3\2\2\2\64\u02c5"+
17126 		"\3\2\2\2\66\u02c9\3\2\2\28\u02cb\3\2\2\2:\u02cf\3\2\2\2<\u02d2\3\2\2\2"+
17127 		">\u02d5\3\2\2\2@\u02da\3\2\2\2B\u02de\3\2\2\2D\u02f1\3\2\2\2F\u02f3\3"+
17128 		"\2\2\2H\u02fe\3\2\2\2J\u0300\3\2\2\2L\u0306\3\2\2\2N\u0316\3\2\2\2P\u0318"+
17129 		"\3\2\2\2R\u0324\3\2\2\2T\u0326\3\2\2\2V\u0329\3\2\2\2X\u032b\3\2\2\2Z"+
17130 		"\u0330\3\2\2\2\\\u033c\3\2\2\2^\u033e\3\2\2\2`\u0340\3\2\2\2b\u0342\3"+
17131 		"\2\2\2d\u0349\3\2\2\2f\u035a\3\2\2\2h\u035c\3\2\2\2j\u035f\3\2\2\2l\u0369"+
17132 		"\3\2\2\2n\u0373\3\2\2\2p\u0375\3\2\2\2r\u0379\3\2\2\2t\u037d\3\2\2\2v"+
17133 		"\u0385\3\2\2\2x\u03c3\3\2\2\2z\u03c5\3\2\2\2|\u03c9\3\2\2\2~\u03e6\3\2"+
17134 		"\2\2\u0080\u03f7\3\2\2\2\u0082\u03f9\3\2\2\2\u0084\u03fd\3\2\2\2\u0086"+
17135 		"\u0404\3\2\2\2\u0088\u040c\3\2\2\2\u008a\u0413\3\2\2\2\u008c\u0417\3\2"+
17136 		"\2\2\u008e\u041a\3\2\2\2\u0090\u0422\3\2\2\2\u0092\u042a\3\2\2\2\u0094"+
17137 		"\u042e\3\2\2\2\u0096\u0450\3\2\2\2\u0098\u0453\3\2\2\2\u009a\u045a\3\2"+
17138 		"\2\2\u009c\u0468\3\2\2\2\u009e\u046b\3\2\2\2\u00a0\u0471\3\2\2\2\u00a2"+
17139 		"\u0479\3\2\2\2\u00a4\u0489\3\2\2\2\u00a6\u048c\3\2\2\2\u00a8\u0491\3\2"+
17140 		"\2\2\u00aa\u04a3\3\2\2\2\u00ac\u04a6\3\2\2\2\u00ae\u04af\3\2\2\2\u00b0"+
17141 		"\u04b7\3\2\2\2\u00b2\u04bb\3\2\2\2\u00b4\u04c3\3\2\2\2\u00b6\u04c5\3\2"+
17142 		"\2\2\u00b8\u04d7\3\2\2\2\u00ba\u04da\3\2\2\2\u00bc\u04e3\3\2\2\2\u00be"+
17143 		"\u04e5\3\2\2\2\u00c0\u04ec\3\2\2\2\u00c2\u04f2\3\2\2\2\u00c4\u04f4\3\2"+
17144 		"\2\2\u00c6\u0501\3\2\2\2\u00c8\u0503\3\2\2\2\u00ca\u053d\3\2\2\2\u00cc"+
17145 		"\u0541\3\2\2\2\u00ce\u0545\3\2\2\2\u00d0\u0547\3\2\2\2\u00d2\u054b\3\2"+
17146 		"\2\2\u00d4\u0554\3\2\2\2\u00d6\u0557\3\2\2\2\u00d8\u0567\3\2\2\2\u00da"+
17147 		"\u0570\3\2\2\2\u00dc\u0573\3\2\2\2\u00de\u057b\3\2\2\2\u00e0\u0583\3\2"+
17148 		"\2\2\u00e2\u0587\3\2\2\2\u00e4\u0589\3\2\2\2\u00e6\u058b\3\2\2\2\u00e8"+
17149 		"\u0599\3\2\2\2\u00ea\u059f\3\2\2\2\u00ec\u05a2\3\2\2\2\u00ee\u05a7\3\2"+
17150 		"\2\2\u00f0\u05af\3\2\2\2\u00f2\u05b3\3\2\2\2\u00f4\u05b7\3\2\2\2\u00f6"+
17151 		"\u05c6\3\2\2\2\u00f8\u05c8\3\2\2\2\u00fa\u05cf\3\2\2\2\u00fc\u05e1\3\2"+
17152 		"\2\2\u00fe\u05e3\3\2\2\2\u0100\u05ea\3\2\2\2\u0102\u05f6\3\2\2\2\u0104"+
17153 		"\u05f8\3\2\2\2\u0106\u0612\3\2\2\2\u0108\u0614\3\2\2\2\u010a\u0618\3\2"+
17154 		"\2\2\u010c\u061d\3\2\2\2\u010e\u0624\3\2\2\2\u0110\u062c\3\2\2\2\u0112"+
17155 		"\u0630\3\2\2\2\u0114\u0637\3\2\2\2\u0116\u0642\3\2\2\2\u0118\u064b\3\2"+
17156 		"\2\2\u011a\u064e\3\2\2\2\u011c\u0654\3\2\2\2\u011e\u0663\3\2\2\2\u0120"+
17157 		"\u0675\3\2\2\2\u0122\u0678\3\2\2\2\u0124\u0680\3\2\2\2\u0126\u0689\3\2"+
17158 		"\2\2\u0128\u068b\3\2\2\2\u012a\u0691\3\2\2\2\u012c\u0697\3\2\2\2\u012e"+
17159 		"\u06aa\3\2\2\2\u0130\u06ac\3\2\2\2\u0132\u06af\3\2\2\2\u0134\u06b1\3\2"+
17160 		"\2\2\u0136\u06b4\3\2\2\2\u0138\u06c8\3\2\2\2\u013a\u06d2\3\2\2\2\u013c"+
17161 		"\u06d4\3\2\2\2\u013e\u06da\3\2\2\2\u0140\u06dc\3\2\2\2\u0142\u06e2\3\2"+
17162 		"\2\2\u0144\u06ea\3\2\2\2\u0146\u06ed\3\2\2\2\u0148\u06f8\3\2\2\2\u014a"+
17163 		"\u06fa\3\2\2\2\u014c\u06fd\3\2\2\2\u014e\u0701\3\2\2\2\u0150\u0703\3\2"+
17164 		"\2\2\u0152\u0708\3\2\2\2\u0154\u070a\3\2\2\2\u0156\u0711\3\2\2\2\u0158"+
17165 		"\u0715\3\2\2\2\u015a\u0738\3\2\2\2\u015c\u073a\3\2\2\2\u015e\u0743\3\2"+
17166 		"\2\2\u0160\u0754\3\2\2\2\u0162\u0756\3\2\2\2\u0164\u0759\3\2\2\2\u0166"+
17167 		"\u076d\3\2\2\2\u0168\u076f\3\2\2\2\u016a\u0771\3\2\2\2\u016c\u0782\3\2"+
17168 		"\2\2\u016e\u0792\3\2\2\2\u0170\u079b\3\2\2\2\u0172\u079d\3\2\2\2\u0174"+
17169 		"\u07a3\3\2\2\2\u0176\u07ae\3\2\2\2\u0178\u07b7\3\2\2\2\u017a\u07b9\3\2"+
17170 		"\2\2\u017c\u07c4\3\2\2\2\u017e\u07d4\3\2\2\2\u0180\u07d9\3\2\2\2\u0182"+
17171 		"\u07db\3\2\2\2\u0184\u07df\3\2\2\2\u0186\u07e4\3\2\2\2\u0188\u07e8\3\2"+
17172 		"\2\2\u018a\u080e\3\2\2\2\u018c\u0810\3\2\2\2\u018e\u0814\3\2\2\2\u0190"+
17173 		"\u081a\3\2\2\2\u0192\u081e\3\2\2\2\u0194\u0820\3\2\2\2\u0196\u0823\3\2"+
17174 		"\2\2\u0198\u0829\3\2\2\2\u019a\u0836\3\2\2\2\u019c\u0838\3\2\2\2\u019e"+
17175 		"\u083a\3\2\2\2\u01a0\u0866\3\2\2\2\u01a2\u086a\3\2\2\2\u01a4\u087b\3\2"+
17176 		"\2\2\u01a6\u087d\3\2\2\2\u01a8\u087f\3\2\2\2\u01aa\u0881\3\2\2\2\u01ac"+
17177 		"\u0889\3\2\2\2\u01ae\u08a4\3\2\2\2\u01b0\u08a8\3\2\2\2\u01b2\u08ae\3\2"+
17178 		"\2\2\u01b4\u08b1\3\2\2\2\u01b6\u08b4\3\2\2\2\u01b8\u08c6\3\2\2\2\u01ba"+
17179 		"\u08c8\3\2\2\2\u01bc\u08ca\3\2\2\2\u01be\u08d0\3\2\2\2\u01c0\u08d9\3\2"+
17180 		"\2\2\u01c2\u08e8\3\2\2\2\u01c4\u08ea\3\2\2\2\u01c6\u08ec\3\2\2\2\u01c8"+
17181 		"\u08f8\3\2\2\2\u01ca\u08fa\3\2\2\2\u01cc\u0904\3\2\2\2\u01ce\u090f\3\2"+
17182 		"\2\2\u01d0\u0911\3\2\2\2\u01d2\u0919\3\2\2\2\u01d4\u091d\3\2\2\2\u01d6"+
17183 		"\u091f\3\2\2\2\u01d8\u092d\3\2\2\2\u01da\u0931\3\2\2\2\u01dc\u0936\3\2"+
17184 		"\2\2\u01de\u0944\3\2\2\2\u01e0\u0958\3\2\2\2\u01e2\u095a\3\2\2\2\u01e4"+
17185 		"\u095c\3\2\2\2\u01e6\u095e\3\2\2\2\u01e8\u0964\3\2\2\2\u01ea\u0966\3\2"+
17186 		"\2\2\u01ec\u096a\3\2\2\2\u01ee\u096c\3\2\2\2\u01f0\u096e\3\2\2\2\u01f2"+
17187 		"\u0972\3\2\2\2\u01f4\u097e\3\2\2\2\u01f6\u0984\3\2\2\2\u01f8\u098e\3\2"+
17188 		"\2\2\u01fa\u0990\3\2\2\2\u01fc\u01ff\5\4\3\2\u01fd\u01ff\5\u015e\u00b0"+
17189 		"\2\u01fe\u01fc\3\2\2\2\u01fe\u01fd\3\2\2\2\u01ff\u0202\3\2\2\2\u0200\u01fe"+
17190 		"\3\2\2\2\u0200\u0201\3\2\2\2\u0201\u0203\3\2\2\2\u0202\u0200\3\2\2\2\u0203"+
17191 		"\u0204\7\2\2\3\u0204\3\3\2\2\2\u0205\u0207\5x=\2\u0206\u0208\7\3\2\2\u0207"+
17192 		"\u0206\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u0227\3\2\2\2\u0209\u020b\5\b"+
17193 		"\5\2\u020a\u020c\7\3\2\2\u020b\u020a\3\2\2\2\u020b\u020c\3\2\2\2\u020c"+
17194 		"\u0227\3\2\2\2\u020d\u020f\5\24\13\2\u020e\u0210\7\3\2\2\u020f\u020e\3"+
17195 		"\2\2\2\u020f\u0210\3\2\2\2\u0210\u0227\3\2\2\2\u0211\u0227\5*\26\2\u0212"+
17196 		"\u0214\5\60\31\2\u0213\u0215\7\3\2\2\u0214\u0213\3\2\2\2\u0214\u0215\3"+
17197 		"\2\2\2\u0215\u0227\3\2\2\2\u0216\u0218\5<\37\2\u0217\u0219\7\3\2\2\u0218"+
17198 		"\u0217\3\2\2\2\u0218\u0219\3\2\2\2\u0219\u0227\3\2\2\2\u021a\u021c\5>"+
17199 		" \2\u021b\u021d\7\4\2\2\u021c\u021b\3\2\2\2\u021c\u021d\3\2\2\2\u021d"+
17200 		"\u0227\3\2\2\2\u021e\u0220\5\u01d4\u00eb\2\u021f\u0221\7\3\2\2\u0220\u021f"+
17201 		"\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0227\3\2\2\2\u0222\u0224\5\u015e\u00b0"+
17202 		"\2\u0223\u0225\7\3\2\2\u0224\u0223\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0227"+
17203 		"\3\2\2\2\u0226\u0205\3\2\2\2\u0226\u0209\3\2\2\2\u0226\u020d\3\2\2\2\u0226"+
17204 		"\u0211\3\2\2\2\u0226\u0212\3\2\2\2\u0226\u0216\3\2\2\2\u0226\u021a\3\2"+
17205 		"\2\2\u0226\u021e\3\2\2\2\u0226\u0222\3\2\2\2\u0227\5\3\2\2\2\u0228\u022a"+
17206 		"\5\4\3\2\u0229\u0228\3\2\2\2\u022a\u022b\3\2\2\2\u022b\u0229\3\2\2\2\u022b"+
17207 		"\u022c\3\2\2\2\u022c\7\3\2\2\2\u022d\u0232\5\n\6\2\u022e\u0232\5\16\b"+
17208 		"\2\u022f\u0232\5\20\t\2\u0230\u0232\5\22\n\2\u0231\u022d\3\2\2\2\u0231"+
17209 		"\u022e\3\2\2\2\u0231\u022f\3\2\2\2\u0231\u0230\3\2\2\2\u0232\t\3\2\2\2"+
17210 		"\u0233\u0235\7\5\2\2\u0234\u0236\5\f\7\2\u0235\u0234\3\2\2\2\u0235\u0236"+
17211 		"\3\2\2\2\u0236\u0237\3\2\2\2\u0237\u0239\7\3\2\2\u0238\u023a\5\u015e\u00b0"+
17212 		"\2\u0239\u0238\3\2\2\2\u0239\u023a\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023d"+
17213 		"\7\3\2\2\u023c\u023e\5\u015c\u00af\2\u023d\u023c\3\2\2\2\u023d\u023e\3"+
17214 		"\2\2\2\u023e\u023f\3\2\2\2\u023f\u0250\5\u0084C\2\u0240\u0241\7\5\2\2"+
17215 		"\u0241\u0243\7\6\2\2\u0242\u0244\5\f\7\2\u0243\u0242\3\2\2\2\u0243\u0244"+
17216 		"\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0247\7\3\2\2\u0246\u0248\5\u015e\u00b0"+
17217 		"\2\u0247\u0246\3\2\2\2\u0247\u0248\3\2\2\2\u0248\u0249\3\2\2\2\u0249\u024b"+
17218 		"\7\3\2\2\u024a\u024c\5\u015c\u00af\2\u024b\u024a\3\2\2\2\u024b\u024c\3"+
17219 		"\2\2\2\u024c\u024d\3\2\2\2\u024d\u024e\7\7\2\2\u024e\u0250\5\u0084C\2"+
17220 		"\u024f\u0233\3\2\2\2\u024f\u0240\3\2\2\2\u0250\13\3\2\2\2\u0251\u0254"+
17221 		"\5\u0096L\2\u0252\u0254\5\u015c\u00af\2\u0253\u0251\3\2\2\2\u0253\u0252"+
17222 		"\3\2\2\2\u0254\r\3\2\2\2\u0255\u0257\7\5\2\2\u0256\u0258\7\b\2\2\u0257"+
17223 		"\u0256\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u0259\3\2\2\2\u0259\u025a\5\u0138"+
17224 		"\u009d\2\u025a\u025b\7\t\2\2\u025b\u025d\5\u015e\u00b0\2\u025c\u025e\5"+
17225 		"T+\2\u025d\u025c\3\2\2\2\u025d\u025e\3\2\2\2\u025e\u025f\3\2\2\2\u025f"+
17226 		"\u0260\5\u0084C\2\u0260\17\3\2\2\2\u0261\u0262\7\n\2\2\u0262\u0263\5D"+
17227 		"#\2\u0263\u0264\5\u0084C\2\u0264\21\3\2\2\2\u0265\u0266\7\13\2\2\u0266"+
17228 		"\u0267\5\u0084C\2\u0267\u0268\7\n\2\2\u0268\u0269\5D#\2\u0269\23\3\2\2"+
17229 		"\2\u026a\u026e\5\26\f\2\u026b\u026e\5\32\16\2\u026c\u026e\5\34\17\2\u026d"+
17230 		"\u026a\3\2\2\2\u026d\u026b\3\2\2\2\u026d\u026c\3\2\2\2\u026e\25\3\2\2"+
17231 		"\2\u026f\u0270\7\f\2\2\u0270\u0271\5D#\2\u0271\u0273\5\u0084C\2\u0272"+
17232 		"\u0274\5\30\r\2\u0273\u0272\3\2\2\2\u0273\u0274\3\2\2\2\u0274\27\3\2\2"+
17233 		"\2\u0275\u0276\7\r\2\2\u0276\u027a\5\u0084C\2\u0277\u0278\7\r\2\2\u0278"+
17234 		"\u027a\5\26\f\2\u0279\u0275\3\2\2\2\u0279\u0277\3\2\2\2\u027a\31\3\2\2"+
17235 		"\2\u027b\u027c\7\16\2\2\u027c\u027d\5D#\2\u027d\u027e\7\r\2\2\u027e\u027f"+
17236 		"\5\u0084C\2\u027f\33\3\2\2\2\u0280\u0281\7\17\2\2\u0281\u0282\5\u015e"+
17237 		"\u00b0\2\u0282\u0284\7\20\2\2\u0283\u0285\5\36\20\2\u0284\u0283\3\2\2"+
17238 		"\2\u0284\u0285\3\2\2\2\u0285\u0286\3\2\2\2\u0286\u0287\7\21\2\2\u0287"+
17239 		"\35\3\2\2\2\u0288\u028a\5 \21\2\u0289\u028b\5\36\20\2\u028a\u0289\3\2"+
17240 		"\2\2\u028a\u028b\3\2\2\2\u028b\37\3\2\2\2\u028c\u028d\5\"\22\2\u028d\u028e"+
17241 		"\5\6\4\2\u028e\u0299\3\2\2\2\u028f\u0290\5(\25\2\u0290\u0291\5\6\4\2\u0291"+
17242 		"\u0299\3\2\2\2\u0292\u0293\5\"\22\2\u0293\u0294\7\3\2\2\u0294\u0299\3"+
17243 		"\2\2\2\u0295\u0296\5(\25\2\u0296\u0297\7\3\2\2\u0297\u0299\3\2\2\2\u0298"+
17244 		"\u028c\3\2\2\2\u0298\u028f\3\2\2\2\u0298\u0292\3\2\2\2\u0298\u0295\3\2"+
17245 		"\2\2\u0299!\3\2\2\2\u029a\u029b\7\b\2\2\u029b\u029c\5$\23\2\u029c\u029d"+
17246 		"\7\4\2\2\u029d#\3\2\2\2\u029e\u02a3\5&\24\2\u029f\u02a0\7\22\2\2\u02a0"+
17247 		"\u02a2\5&\24\2\u02a1\u029f\3\2\2\2\u02a2\u02a5\3\2\2\2\u02a3\u02a1\3\2"+
17248 		"\2\2\u02a3\u02a4\3\2\2\2\u02a4%\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a6\u02a8"+
17249 		"\5\u0138\u009d\2\u02a7\u02a9\5T+\2\u02a8\u02a7\3\2\2\2\u02a8\u02a9\3\2"+
17250 		"\2\2\u02a9\'\3\2\2\2\u02aa\u02ab\7\23\2\2\u02ab\u02ac\7\4\2\2\u02ac)\3"+
17251 		"\2\2\2\u02ad\u02ae\5,\27\2\u02ae\u02af\5\b\5\2\u02af\u02b4\3\2\2\2\u02b0"+
17252 		"\u02b1\5,\27\2\u02b1\u02b2\5\34\17\2\u02b2\u02b4\3\2\2\2\u02b3\u02ad\3"+
17253 		"\2\2\2\u02b3\u02b0\3\2\2\2\u02b4+\3\2\2\2\u02b5\u02b6\5.\30\2\u02b6\u02b7"+
17254 		"\7\4\2\2\u02b7-\3\2\2\2\u02b8\u02b9\5\u01ec\u00f7\2\u02b9/\3\2\2\2\u02ba"+
17255 		"\u02c0\5\62\32\2\u02bb\u02c0\5\64\33\2\u02bc\u02c0\5\66\34\2\u02bd\u02c0"+
17256 		"\58\35\2\u02be\u02c0\5:\36\2\u02bf\u02ba\3\2\2\2\u02bf\u02bb\3\2\2\2\u02bf"+
17257 		"\u02bc\3\2\2\2\u02bf\u02bd\3\2\2\2\u02bf\u02be\3\2\2\2\u02c0\61\3\2\2"+
17258 		"\2\u02c1\u02c3\7\24\2\2\u02c2\u02c4\5.\30\2\u02c3\u02c2\3\2\2\2\u02c3"+
17259 		"\u02c4\3\2\2\2\u02c4\63\3\2\2\2\u02c5\u02c7\7\25\2\2\u02c6\u02c8\5.\30"+
17260 		"\2\u02c7\u02c6\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8\65\3\2\2\2\u02c9\u02ca"+
17261 		"\7\26\2\2\u02ca\67\3\2\2\2\u02cb\u02cd\7\27\2\2\u02cc\u02ce\5\u015e\u00b0"+
17262 		"\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce9\3\2\2\2\u02cf\u02d0"+
17263 		"\7\30\2\2\u02d0\u02d1\5\u015e\u00b0\2\u02d1;\3\2\2\2\u02d2\u02d3\7\31"+
17264 		"\2\2\u02d3\u02d4\5\u0084C\2\u02d4=\3\2\2\2\u02d5\u02d6\7\32\2\2\u02d6"+
17265 		"\u02d8\5\u0084C\2\u02d7\u02d9\5@!\2\u02d8\u02d7\3\2\2\2\u02d8\u02d9\3"+
17266 		"\2\2\2\u02d9?\3\2\2\2\u02da\u02dc\5B\"\2\u02db\u02dd\5@!\2\u02dc\u02db"+
17267 		"\3\2\2\2\u02dc\u02dd\3\2\2\2\u02ddA\3\2\2\2\u02de\u02e0\7\33\2\2\u02df"+
17268 		"\u02e1\5\u0138\u009d\2\u02e0\u02df\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e3"+
17269 		"\3\2\2\2\u02e2\u02e4\5T+\2\u02e3\u02e2\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4"+
17270 		"\u02e5\3\2\2\2\u02e5\u02e6\5\u0084C\2\u02e6C\3\2\2\2\u02e7\u02f2\5\u015e"+
17271 		"\u00b0\2\u02e8\u02e9\5\u015e\u00b0\2\u02e9\u02ea\7\22\2\2\u02ea\u02eb"+
17272 		"\5F$\2\u02eb\u02f2\3\2\2\2\u02ec\u02f2\5F$\2\u02ed\u02ee\5X-\2\u02ee\u02ef"+
17273 		"\7\22\2\2\u02ef\u02f0\5\u015e\u00b0\2\u02f0\u02f2\3\2\2\2\u02f1\u02e7"+
17274 		"\3\2\2\2\u02f1\u02e8\3\2\2\2\u02f1\u02ec\3\2\2\2\u02f1\u02ed\3\2\2\2\u02f2"+
17275 		"E\3\2\2\2\u02f3\u02f8\5H%\2\u02f4\u02f5\7\22\2\2\u02f5\u02f7\5H%\2\u02f6"+
17276 		"\u02f4\3\2\2\2\u02f7\u02fa\3\2\2\2\u02f8\u02f6\3\2\2\2\u02f8\u02f9\3\2"+
17277 		"\2\2\u02f9G\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fb\u02ff\5X-\2\u02fc\u02ff"+
17278 		"\5J&\2\u02fd\u02ff\5L\'\2\u02fe\u02fb\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe"+
17279 		"\u02fd\3\2\2\2\u02ffI\3\2\2\2\u0300\u0301\7\b\2\2\u0301\u0302\5\u0138"+
17280 		"\u009d\2\u0302\u0304\5\u0094K\2\u0303\u0305\5T+\2\u0304\u0303\3\2\2\2"+
17281 		"\u0304\u0305\3\2\2\2\u0305K\3\2\2\2\u0306\u0309\5N(\2\u0307\u0308\7\22"+
17282 		"\2\2\u0308\u030a\5P)\2\u0309\u0307\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030c"+
17283 		"\3\2\2\2\u030b\u030d\5T+\2\u030c\u030b\3\2\2\2\u030c\u030d\3\2\2\2\u030d"+
17284 		"M\3\2\2\2\u030e\u030f\7\34\2\2\u030f\u0310\5\u0138\u009d\2\u0310\u0311"+
17285 		"\5\u0094K\2\u0311\u0317\3\2\2\2\u0312\u0313\7\35\2\2\u0313\u0314\5\u0138"+
17286 		"\u009d\2\u0314\u0315\5\u0094K\2\u0315\u0317\3\2\2\2\u0316\u030e\3\2\2"+
17287 		"\2\u0316\u0312\3\2\2\2\u0317O\3\2\2\2\u0318\u031d\5R*\2\u0319\u031a\7"+
17288 		"\22\2\2\u031a\u031c\5R*\2\u031b\u0319\3\2\2\2\u031c\u031f\3\2\2\2\u031d"+
17289 		"\u031b\3\2\2\2\u031d\u031e\3\2\2\2\u031eQ\3\2\2\2\u031f\u031d\3\2\2\2"+
17290 		"\u0320\u0325\5N(\2\u0321\u0322\5\u0138\u009d\2\u0322\u0323\5\u0094K\2"+
17291 		"\u0323\u0325\3\2\2\2\u0324\u0320\3\2\2\2\u0324\u0321\3\2\2\2\u0325S\3"+
17292 		"\2\2\2\u0326\u0327\7\36\2\2\u0327\u0328\5V,\2\u0328U\3\2\2\2\u0329\u032a"+
17293 		"\5\u015e\u00b0\2\u032aW\3\2\2\2\u032b\u032c\7\37\2\2\u032c\u032d\7\6\2"+
17294 		"\2\u032d\u032e\5Z.\2\u032e\u032f\7\7\2\2\u032fY\3\2\2\2\u0330\u0335\5"+
17295 		"\\/\2\u0331\u0332\7\22\2\2\u0332\u0334\5Z.\2\u0333\u0331\3\2\2\2\u0334"+
17296 		"\u0337\3\2\2\2\u0335\u0333\3\2\2\2\u0335\u0336\3\2\2\2\u0336[\3\2\2\2"+
17297 		"\u0337\u0335\3\2\2\2\u0338\u0339\5^\60\2\u0339\u033a\5`\61\2\u033a\u033d"+
17298 		"\3\2\2\2\u033b\u033d\7 \2\2\u033c\u0338\3\2\2\2\u033c\u033b\3\2\2\2\u033d"+
17299 		"]\3\2\2\2\u033e\u033f\t\2\2\2\u033f_\3\2\2\2\u0340\u0341\t\3\2\2\u0341"+
17300 		"a\3\2\2\2\u0342\u0343\7)\2\2\u0343\u0345\5d\63\2\u0344\u0346\5h\65\2\u0345"+
17301 		"\u0344\3\2\2\2\u0345\u0346\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348\7*"+
17302 		"\2\2\u0348c\3\2\2\2\u0349\u034e\5f\64\2\u034a\u034b\7\22\2\2\u034b\u034d"+
17303 		"\5f\64\2\u034c\u034a\3\2\2\2\u034d\u0350\3\2\2\2\u034e\u034c\3\2\2\2\u034e"+
17304 		"\u034f\3\2\2\2\u034fe\3\2\2\2\u0350\u034e\3\2\2\2\u0351\u035b\5\u01ba"+
17305 		"\u00de\2\u0352\u0353\5\u01ba\u00de\2\u0353\u0354\7\4\2\2\u0354\u0355\5"+
17306 		"\u01b8\u00dd\2\u0355\u035b\3\2\2\2\u0356\u0357\5\u01ba\u00de\2\u0357\u0358"+
17307 		"\7\4\2\2\u0358\u0359\5\u01c6\u00e4\2\u0359\u035b\3\2\2\2\u035a\u0351\3"+
17308 		"\2\2\2\u035a\u0352\3\2\2\2\u035a\u0356\3\2\2\2\u035bg\3\2\2\2\u035c\u035d"+
17309 		"\7\36\2\2\u035d\u035e\5j\66\2\u035ei\3\2\2\2\u035f\u0364\5l\67\2\u0360"+
17310 		"\u0361\7\22\2\2\u0361\u0363\5l\67\2\u0362\u0360\3\2\2\2\u0363\u0366\3"+
17311 		"\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365k\3\2\2\2\u0366\u0364"+
17312 		"\3\2\2\2\u0367\u036a\5n8\2\u0368\u036a\5p9\2\u0369\u0367\3\2\2\2\u0369"+
17313 		"\u0368\3\2\2\2\u036am\3\2\2\2\u036b\u036c\5\u01b8\u00dd\2\u036c\u036d"+
17314 		"\7\4\2\2\u036d\u036e\5\u01b8\u00dd\2\u036e\u0374\3\2\2\2\u036f\u0370\5"+
17315 		"\u01b8\u00dd\2\u0370\u0371\7\4\2\2\u0371\u0372\5\u01c6\u00e4\2\u0372\u0374"+
17316 		"\3\2\2\2\u0373\u036b\3\2\2\2\u0373\u036f\3\2\2\2\u0374o\3\2\2\2\u0375"+
17317 		"\u0376\5\u01b8\u00dd\2\u0376\u0377\7+\2\2\u0377\u0378\5\u01ac\u00d7\2"+
17318 		"\u0378q\3\2\2\2\u0379\u037a\7)\2\2\u037a\u037b\5t;\2\u037b\u037c\7*\2"+
17319 		"\2\u037cs\3\2\2\2\u037d\u0382\5v<\2\u037e\u037f\7\22\2\2\u037f\u0381\5"+
17320 		"v<\2\u0380\u037e\3\2\2\2\u0381\u0384\3\2\2\2\u0382\u0380\3\2\2\2\u0382"+
17321 		"\u0383\3\2\2\2\u0383u\3\2\2\2\u0384\u0382\3\2\2\2\u0385\u0386\5\u01ac"+
17322 		"\u00d7\2\u0386w\3\2\2\2\u0387\u0389\5\u0086D\2\u0388\u038a\7\3\2\2\u0389"+
17323 		"\u0388\3\2\2\2\u0389\u038a\3\2\2\2\u038a\u03c4\3\2\2\2\u038b\u038d\5\u008e"+
17324 		"H\2\u038c\u038e\7\3\2\2\u038d\u038c\3\2\2\2\u038d\u038e\3\2\2\2\u038e"+
17325 		"\u03c4\3\2\2\2\u038f\u0391\5\u0096L\2\u0390\u0392\7\3\2\2\u0391\u0390"+
17326 		"\3\2\2\2\u0391\u0392\3\2\2\2\u0392\u03c4\3\2\2\2\u0393\u0395\5\u00b0Y"+
17327 		"\2\u0394\u0396\7\3\2\2\u0395\u0394\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u03c4"+
17328 		"\3\2\2\2\u0397\u0399\5\u00b8]\2\u0398\u039a\7\3\2\2\u0399\u0398\3\2\2"+
17329 		"\2\u0399\u039a\3\2\2\2\u039a\u03c4\3\2\2\2\u039b\u039d\5\u00d2j\2\u039c"+
17330 		"\u039e\7\3\2\2\u039d\u039c\3\2\2\2\u039d\u039e\3\2\2\2\u039e\u03c4\3\2"+
17331 		"\2\2\u039f\u03a1\5\u00f4{\2\u03a0\u03a2\7\3\2\2\u03a1\u03a0\3\2\2\2\u03a1"+
17332 		"\u03a2\3\2\2\2\u03a2\u03c4\3\2\2\2\u03a3\u03a5\5\u00fa~\2\u03a4\u03a6"+
17333 		"\7\3\2\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03c4\3\2\2\2\u03a7"+
17334 		"\u03a9\5\u0100\u0081\2\u03a8\u03aa\7\3\2\2\u03a9\u03a8\3\2\2\2\u03a9\u03aa"+
17335 		"\3\2\2\2\u03aa\u03c4\3\2\2\2\u03ab\u03ad\5\u0114\u008b\2\u03ac\u03ae\7"+
17336 		"\3\2\2\u03ad\u03ac\3\2\2\2\u03ad\u03ae\3\2\2\2\u03ae\u03c4\3\2\2\2\u03af"+
17337 		"\u03b1\5\u011a\u008e\2\u03b0\u03b2\7\3\2\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2"+
17338 		"\3\2\2\2\u03b2\u03c4\3\2\2\2\u03b3\u03b5\5\u011c\u008f\2\u03b4\u03b6\7"+
17339 		"\3\2\2\u03b5\u03b4\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03c4\3\2\2\2\u03b7"+
17340 		"\u03b9\5\u0120\u0091\2\u03b8\u03ba\7\3\2\2\u03b9\u03b8\3\2\2\2\u03b9\u03ba"+
17341 		"\3\2\2\2\u03ba\u03c4\3\2\2\2\u03bb\u03bd\5\u0126\u0094\2\u03bc\u03be\7"+
17342 		"\3\2\2\u03bd\u03bc\3\2\2\2\u03bd\u03be\3\2\2\2\u03be\u03c4\3\2\2\2\u03bf"+
17343 		"\u03c1\5\u01d4\u00eb\2\u03c0\u03c2\7\3\2\2\u03c1\u03c0\3\2\2\2\u03c1\u03c2"+
17344 		"\3\2\2\2\u03c2\u03c4\3\2\2\2\u03c3\u0387\3\2\2\2\u03c3\u038b\3\2\2\2\u03c3"+
17345 		"\u038f\3\2\2\2\u03c3\u0393\3\2\2\2\u03c3\u0397\3\2\2\2\u03c3\u039b\3\2"+
17346 		"\2\2\u03c3\u039f\3\2\2\2\u03c3\u03a3\3\2\2\2\u03c3\u03a7\3\2\2\2\u03c3"+
17347 		"\u03ab\3\2\2\2\u03c3\u03af\3\2\2\2\u03c3\u03b3\3\2\2\2\u03c3\u03b7\3\2"+
17348 		"\2\2\u03c3\u03bb\3\2\2\2\u03c3\u03bf\3\2\2\2\u03c4y\3\2\2\2\u03c5\u03c7"+
17349 		"\5x=\2\u03c6\u03c8\5z>\2\u03c7\u03c6\3\2\2\2\u03c7\u03c8\3\2\2\2\u03c8"+
17350 		"{\3\2\2\2\u03c9\u03cb\5~@\2\u03ca\u03cc\5|?\2\u03cb\u03ca\3\2\2\2\u03cb"+
17351 		"\u03cc\3\2\2\2\u03cc}\3\2\2\2\u03cd\u03e7\7,\2\2\u03ce\u03e7\7-\2\2\u03cf"+
17352 		"\u03e7\7.\2\2\u03d0\u03e7\7/\2\2\u03d1\u03e7\7\60\2\2\u03d2\u03e7\7\61"+
17353 		"\2\2\u03d3\u03e7\7\62\2\2\u03d4\u03e7\7\63\2\2\u03d5\u03e7\7\64\2\2\u03d6"+
17354 		"\u03e7\7\65\2\2\u03d7\u03e7\7\66\2\2\u03d8\u03e7\7\67\2\2\u03d9\u03e7"+
17355 		"\78\2\2\u03da\u03e7\79\2\2\u03db\u03e7\7:\2\2\u03dc\u03dd\7:\2\2\u03dd"+
17356 		"\u03de\7\6\2\2\u03de\u03df\7;\2\2\u03df\u03e7\7\7\2\2\u03e0\u03e1\7:\2"+
17357 		"\2\u03e1\u03e2\7\6\2\2\u03e2\u03e3\7<\2\2\u03e3\u03e7\7\7\2\2\u03e4\u03e7"+
17358 		"\7=\2\2\u03e5\u03e7\5\u0080A\2\u03e6\u03cd\3\2\2\2\u03e6\u03ce\3\2\2\2"+
17359 		"\u03e6\u03cf\3\2\2\2\u03e6\u03d0\3\2\2\2\u03e6\u03d1\3\2\2\2\u03e6\u03d2"+
17360 		"\3\2\2\2\u03e6\u03d3\3\2\2\2\u03e6\u03d4\3\2\2\2\u03e6\u03d5\3\2\2\2\u03e6"+
17361 		"\u03d6\3\2\2\2\u03e6\u03d7\3\2\2\2\u03e6\u03d8\3\2\2\2\u03e6\u03d9\3\2"+
17362 		"\2\2\u03e6\u03da\3\2\2\2\u03e6\u03db\3\2\2\2\u03e6\u03dc\3\2\2\2\u03e6"+
17363 		"\u03e0\3\2\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e5\3\2\2\2\u03e7\177\3\2\2"+
17364 		"\2\u03e8\u03f8\7>\2\2\u03e9\u03ea\7>\2\2\u03ea\u03eb\7\6\2\2\u03eb\u03ec"+
17365 		"\7?\2\2\u03ec\u03f8\7\7\2\2\u03ed\u03f8\7@\2\2\u03ee\u03ef\7@\2\2\u03ef"+
17366 		"\u03f0\7\6\2\2\u03f0\u03f1\7?\2\2\u03f1\u03f8\7\7\2\2\u03f2\u03f8\7A\2"+
17367 		"\2\u03f3\u03f4\7A\2\2\u03f4\u03f5\7\6\2\2\u03f5\u03f6\7?\2\2\u03f6\u03f8"+
17368 		"\7\7\2\2\u03f7\u03e8\3\2\2\2\u03f7\u03e9\3\2\2\2\u03f7\u03ed\3\2\2\2\u03f7"+
17369 		"\u03ee\3\2\2\2\u03f7\u03f2\3\2\2\2\u03f7\u03f3\3\2\2\2\u03f8\u0081\3\2"+
17370 		"\2\2\u03f9\u03fb\5\u0080A\2\u03fa\u03fc\5\u0082B\2\u03fb\u03fa\3\2\2\2"+
17371 		"\u03fb\u03fc\3\2\2\2\u03fc\u0083\3\2\2\2\u03fd\u03ff\7\20\2\2\u03fe\u0400"+
17372 		"\5\6\4\2\u03ff\u03fe\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0401\3\2\2\2\u0401"+
17373 		"\u0402\7\21\2\2\u0402\u0085\3\2\2\2\u0403\u0405\5\u0156\u00ac\2\u0404"+
17374 		"\u0403\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0406\3\2\2\2\u0406\u0408\7B"+
17375 		"\2\2\u0407\u0409\5\u0088E\2\u0408\u0407\3\2\2\2\u0408\u0409\3\2\2\2\u0409"+
17376 		"\u040a\3\2\2\2\u040a\u040b\5\u008aF\2\u040b\u0087\3\2\2\2\u040c\u040d"+
17377 		"\t\4\2\2\u040d\u0089\3\2\2\2\u040e\u0414\5\u008cG\2\u040f\u0410\5\u008c"+
17378 		"G\2\u0410\u0411\7H\2\2\u0411\u0412\5\u008aF\2\u0412\u0414\3\2\2\2\u0413"+
17379 		"\u040e\3\2\2\2\u0413\u040f\3\2\2\2\u0414\u008b\3\2\2\2\u0415\u0418\5\u01ec"+
17380 		"\u00f7\2\u0416\u0418\5\u01a4\u00d3\2\u0417\u0415\3\2\2\2\u0417\u0416\3"+
17381 		"\2\2\2\u0418\u008d\3\2\2\2\u0419\u041b\5\u0156\u00ac\2\u041a\u0419\3\2"+
17382 		"\2\2\u041a\u041b\3\2\2\2\u041b\u041d\3\2\2\2\u041c\u041e\5|?\2\u041d\u041c"+
17383 		"\3\2\2\2\u041d\u041e\3\2\2\2\u041e\u041f\3\2\2\2\u041f\u0420\7\34\2\2"+
17384 		"\u0420\u0421\5\u0090I\2\u0421\u008f\3\2\2\2\u0422\u0427\5\u0092J\2\u0423"+
17385 		"\u0424\7\22\2\2\u0424\u0426\5\u0092J\2\u0425\u0423\3\2\2\2\u0426\u0429"+
17386 		"\3\2\2\2\u0427\u0425\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u0091\3\2\2\2\u0429"+
17387 		"\u0427\3\2\2\2\u042a\u042c\5\u0138\u009d\2\u042b\u042d\5\u0094K\2\u042c"+
17388 		"\u042b\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u0093\3\2\2\2\u042e\u042f\7I"+
17389 		"\2\2\u042f\u0430\5\u015e\u00b0\2\u0430\u0095\3\2\2\2\u0431\u0432\5\u0098"+
17390 		"M\2\u0432\u0433\5\u009aN\2\u0433\u0434\5\u01b6\u00dc\2\u0434\u0435\5\u009c"+
17391 		"O\2\u0435\u0451\3\2\2\2\u0436\u0437\5\u0098M\2\u0437\u0438\5\u009aN\2"+
17392 		"\u0438\u0439\5\u01b6\u00dc\2\u0439\u043a\5\u00a4S\2\u043a\u0451\3\2\2"+
17393 		"\2\u043b\u043c\5\u0098M\2\u043c\u043d\5\u009aN\2\u043d\u043e\5\u0094K"+
17394 		"\2\u043e\u043f\5\u00aaV\2\u043f\u0451\3\2\2\2\u0440\u0441\5\u0098M\2\u0441"+
17395 		"\u0442\5\u009aN\2\u0442\u0444\5\u01b6\u00dc\2\u0443\u0445\5\u0094K\2\u0444"+
17396 		"\u0443\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u0446\3\2\2\2\u0446\u0447\5\u00aa"+
17397 		"V\2\u0447\u0451\3\2\2\2\u0448\u0449\5\u0098M\2\u0449\u044a\5\u009aN\2"+
17398 		"\u044a\u044b\5\u01b6\u00dc\2\u044b\u044c\5\u0084C\2\u044c\u0451\3\2\2"+
17399 		"\2\u044d\u044e\5\u0098M\2\u044e\u044f\5\u0090I\2\u044f\u0451\3\2\2\2\u0450"+
17400 		"\u0431\3\2\2\2\u0450\u0436\3\2\2\2\u0450\u043b\3\2\2\2\u0450\u0440\3\2"+
17401 		"\2\2\u0450\u0448\3\2\2\2\u0450\u044d\3\2\2\2\u0451\u0097\3\2\2\2\u0452"+
17402 		"\u0454\5\u0156\u00ac\2\u0453\u0452\3\2\2\2\u0453\u0454\3\2\2\2\u0454\u0456"+
17403 		"\3\2\2\2\u0455\u0457\5|?\2\u0456\u0455\3\2\2\2\u0456\u0457\3\2\2\2\u0457"+
17404 		"\u0458\3\2\2\2\u0458\u0459\7\35\2\2\u0459\u0099\3\2\2\2\u045a\u045b\5"+
17405 		"\u01ec\u00f7\2\u045b\u009b\3\2\2\2\u045c\u045d\7\20\2\2\u045d\u045f\5"+
17406 		"\u009eP\2\u045e\u0460\5\u00a0Q\2\u045f\u045e\3\2\2\2\u045f\u0460\3\2\2"+
17407 		"\2\u0460\u0461\3\2\2\2\u0461\u0462\7\21\2\2\u0462\u0469\3\2\2\2\u0463"+
17408 		"\u0464\7\20\2\2\u0464\u0465\5\u00a0Q\2\u0465\u0466\5\u009eP\2\u0466\u0467"+
17409 		"\7\21\2\2\u0467\u0469\3\2\2\2\u0468\u045c\3\2\2\2\u0468\u0463\3\2\2\2"+
17410 		"\u0469\u009d\3\2\2\2\u046a\u046c\5\u0156\u00ac\2\u046b\u046a\3\2\2\2\u046b"+
17411 		"\u046c\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u046e\7J\2\2\u046e\u046f\5\u0084"+
17412 		"C\2\u046f\u009f\3\2\2\2\u0470\u0472\5\u0156\u00ac\2\u0471\u0470\3\2\2"+
17413 		"\2\u0471\u0472\3\2\2\2\u0472\u0473\3\2\2\2\u0473\u0475\7?\2\2\u0474\u0476"+
17414 		"\5\u00a2R\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476\u0477\3\2\2"+
17415 		"\2\u0477\u0478\5\u0084C\2\u0478\u00a1\3\2\2\2\u0479\u047a\7\6\2\2\u047a"+
17416 		"\u047b\5\u01ec\u00f7\2\u047b\u047c\7\7\2\2\u047c\u00a3\3\2\2\2\u047d\u047e"+
17417 		"\7\20\2\2\u047e\u0480\5\u00a6T\2\u047f\u0481\5\u00a8U\2\u0480\u047f\3"+
17418 		"\2\2\2\u0480\u0481\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u0483\7\21\2\2\u0483"+
17419 		"\u048a\3\2\2\2\u0484\u0485\7\20\2\2\u0485\u0486\5\u00a8U\2\u0486\u0487"+
17420 		"\5\u00a6T\2\u0487\u0488\7\21\2\2\u0488\u048a\3\2\2\2\u0489\u047d\3\2\2"+
17421 		"\2\u0489\u0484\3\2\2\2\u048a\u00a5\3\2\2\2\u048b\u048d\5\u0156\u00ac\2"+
17422 		"\u048c\u048b\3\2\2\2\u048c\u048d\3\2\2\2\u048d\u048e\3\2\2\2\u048e\u048f"+
17423 		"\7J\2\2\u048f\u00a7\3\2\2\2\u0490\u0492\5\u0156\u00ac\2\u0491\u0490\3"+
17424 		"\2\2\2\u0491\u0492\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u0494\7?\2\2\u0494"+
17425 		"\u00a9\3\2\2\2\u0495\u0496\7\20\2\2\u0496\u0498\5\u00acW\2\u0497\u0499"+
17426 		"\5\u00aeX\2\u0498\u0497\3\2\2\2\u0498\u0499\3\2\2\2\u0499\u049a\3\2\2"+
17427 		"\2\u049a\u049b\7\21\2\2\u049b\u04a4\3\2\2\2\u049c\u049d\7\20\2\2\u049d"+
17428 		"\u049f\5\u00aeX\2\u049e\u04a0\5\u00acW\2\u049f\u049e\3\2\2\2\u049f\u04a0"+
17429 		"\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a2\7\21\2\2\u04a2\u04a4\3\2\2\2"+
17430 		"\u04a3\u0495\3\2\2\2\u04a3\u049c\3\2\2\2\u04a4\u00ab\3\2\2\2\u04a5\u04a7"+
17431 		"\5\u0156\u00ac\2\u04a6\u04a5\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a8\3"+
17432 		"\2\2\2\u04a8\u04aa\7K\2\2\u04a9\u04ab\5\u00a2R\2\u04aa\u04a9\3\2\2\2\u04aa"+
17433 		"\u04ab\3\2\2\2\u04ab\u04ac\3\2\2\2\u04ac\u04ad\5\u0084C\2\u04ad\u00ad"+
17434 		"\3\2\2\2\u04ae\u04b0\5\u0156\u00ac\2\u04af\u04ae\3\2\2\2\u04af\u04b0\3"+
17435 		"\2\2\2\u04b0\u04b1\3\2\2\2\u04b1\u04b3\7L\2\2\u04b2\u04b4\5\u00a2R\2\u04b3"+
17436 		"\u04b2\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b6\5\u0084"+
17437 		"C\2\u04b6\u00af\3\2\2\2\u04b7\u04b8\5\u00b2Z\2\u04b8\u04b9\5\u00b6\\\2"+
17438 		"\u04b9\u00b1\3\2\2\2\u04ba\u04bc\5\u0156\u00ac\2\u04bb\u04ba\3\2\2\2\u04bb"+
17439 		"\u04bc\3\2\2\2\u04bc\u04be\3\2\2\2\u04bd\u04bf\5\u0080A\2\u04be\u04bd"+
17440 		"\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c1\7C\2\2\u04c1"+
17441 		"\u04c2\5\u00b4[\2\u04c2\u00b3\3\2\2\2\u04c3\u04c4\5\u01ec\u00f7\2\u04c4"+
17442 		"\u00b5\3\2\2\2\u04c5\u04c6\7I\2\2\u04c6\u04c7\5\u01ac\u00d7\2\u04c7\u00b7"+
17443 		"\3\2\2\2\u04c8\u04c9\5\u00ba^\2\u04c9\u04cb\5\u00bc_\2\u04ca\u04cc\5b"+
17444 		"\62\2\u04cb\u04ca\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04cd\3\2\2\2\u04cd"+
17445 		"\u04ce\5\u00be`\2\u04ce\u04cf\5\u00c2b\2\u04cf\u04d8\3\2\2\2\u04d0\u04d1"+
17446 		"\5\u00ba^\2\u04d1\u04d3\5\u00bc_\2\u04d2\u04d4\5b\62\2\u04d3\u04d2\3\2"+
17447 		"\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\3\2\2\2\u04d5\u04d6\5\u00be`\2\u04d6"+
17448 		"\u04d8\3\2\2\2\u04d7\u04c8\3\2\2\2\u04d7\u04d0\3\2\2\2\u04d8\u00b9\3\2"+
17449 		"\2\2\u04d9\u04db\5\u0156\u00ac\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2\2"+
17450 		"\2\u04db\u04dd\3\2\2\2\u04dc\u04de\5|?\2\u04dd\u04dc\3\2\2\2\u04dd\u04de"+
17451 		"\3\2\2\2\u04de\u04df\3\2\2\2\u04df\u04e0\7G\2\2\u04e0\u00bb\3\2\2\2\u04e1"+
17452 		"\u04e4\5\u01ec\u00f7\2\u04e2\u04e4\5\u01a4\u00d3\2\u04e3\u04e1\3\2\2\2"+
17453 		"\u04e3\u04e2\3\2\2\2\u04e4\u00bd\3\2\2\2\u04e5\u04e7\5\u00c4c\2\u04e6"+
17454 		"\u04e8\t\5\2\2\u04e7\u04e6\3\2\2\2\u04e7\u04e8\3\2\2\2\u04e8\u04ea\3\2"+
17455 		"\2\2\u04e9\u04eb\5\u00c0a\2\u04ea\u04e9\3\2\2\2\u04ea\u04eb\3\2\2\2\u04eb"+
17456 		"\u00bf\3\2\2\2\u04ec\u04ee\7O\2\2\u04ed\u04ef\5\u0156\u00ac\2\u04ee\u04ed"+
17457 		"\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef\u04f0\3\2\2\2\u04f0\u04f1\5\u01ac\u00d7"+
17458 		"\2\u04f1\u00c1\3\2\2\2\u04f2\u04f3\5\u0084C\2\u04f3\u00c3\3\2\2\2\u04f4"+
17459 		"\u04f6\5\u00c6d\2\u04f5\u04f7\5\u00c4c\2\u04f6\u04f5\3\2\2\2\u04f6\u04f7"+
17460 		"\3\2\2\2\u04f7\u00c5\3\2\2\2\u04f8\u04f9\7\6\2\2\u04f9\u0502\7\7\2\2\u04fa"+
17461 		"\u04fb\7\6\2\2\u04fb\u04fd\5\u00c8e\2\u04fc\u04fe\7P\2\2\u04fd\u04fc\3"+
17462 		"\2\2\2\u04fd\u04fe\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u0500\7\7\2\2\u0500"+
17463 		"\u0502\3\2\2\2\u0501\u04f8\3\2\2\2\u0501\u04fa\3\2\2\2\u0502\u00c7\3\2"+
17464 		"\2\2\u0503\u0508\5\u00caf\2\u0504\u0505\7\22\2\2\u0505\u0507\5\u00caf"+
17465 		"\2\u0506\u0504\3\2\2\2\u0507\u050a\3\2\2\2\u0508\u0506\3\2\2\2\u0508\u0509"+
17466 		"\3\2\2\2\u0509\u00c9\3\2\2\2\u050a\u0508\3\2\2\2\u050b\u050d\5\u0156\u00ac"+
17467 		"\2\u050c\u050b\3\2\2\2\u050c\u050d\3\2\2\2\u050d\u050f\3\2\2\2\u050e\u0510"+
17468 		"\7Q\2\2\u050f\u050e\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0512\3\2\2\2\u0511"+
17469 		"\u0513\7\34\2\2\u0512\u0511\3\2\2\2\u0512\u0513\3\2\2\2\u0513\u0515\3"+
17470 		"\2\2\2\u0514\u0516\7R\2\2\u0515\u0514\3\2\2\2\u0515\u0516\3\2\2\2\u0516"+
17471 		"\u0518\3\2\2\2\u0517\u0519\5\u00ccg\2\u0518\u0517\3\2\2\2\u0518\u0519"+
17472 		"\3\2\2\2\u0519\u051a\3\2\2\2\u051a\u051c\5\u00ceh\2\u051b\u051d\5\u01b6"+
17473 		"\u00dc\2\u051c\u051b\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051f\3\2\2\2\u051e"+
17474 		"\u0520\5\u00d0i\2\u051f\u051e\3\2\2\2\u051f\u0520\3\2\2\2\u0520\u053e"+
17475 		"\3\2\2\2\u0521\u0523\7Q\2\2\u0522\u0521\3\2\2\2\u0522\u0523\3\2\2\2\u0523"+
17476 		"\u0524\3\2\2\2\u0524\u0526\7\35\2\2\u0525\u0527\7R\2\2\u0526\u0525\3\2"+
17477 		"\2\2\u0526\u0527\3\2\2\2\u0527\u0529\3\2\2\2\u0528\u052a\5\u00ccg\2\u0529"+
17478 		"\u0528\3\2\2\2\u0529\u052a\3\2\2\2\u052a\u052b\3\2\2\2\u052b\u052d\5\u00ce"+
17479 		"h\2\u052c\u052e\5\u01b6\u00dc\2\u052d\u052c\3\2\2\2\u052d\u052e\3\2\2"+
17480 		"\2\u052e\u0530\3\2\2\2\u052f\u0531\5\u00d0i\2\u0530\u052f\3\2\2\2\u0530"+
17481 		"\u0531\3\2\2\2\u0531\u053e\3\2\2\2\u0532\u0534\5\u0156\u00ac\2\u0533\u0532"+
17482 		"\3\2\2\2\u0533\u0534\3\2\2\2\u0534\u0535\3\2\2\2\u0535\u053e\5\u01ac\u00d7"+
17483 		"\2\u0536\u0538\5\u00ccg\2\u0537\u0536\3\2\2\2\u0537\u0538\3\2\2\2\u0538"+
17484 		"\u0539\3\2\2\2\u0539\u053a\5\u00ceh\2\u053a\u053b\5\u01b6\u00dc\2\u053b"+
17485 		"\u053c\7P\2\2\u053c\u053e\3\2\2\2\u053d\u050c\3\2\2\2\u053d\u0522\3\2"+
17486 		"\2\2\u053d\u0533\3\2\2\2\u053d\u0537\3\2\2\2\u053e\u00cb\3\2\2\2\u053f"+
17487 		"\u0542\5\u01ec\u00f7\2\u0540\u0542\7S\2\2\u0541\u053f\3\2\2\2\u0541\u0540"+
17488 		"\3\2\2\2\u0542\u00cd\3\2\2\2\u0543\u0546\5\u01ec\u00f7\2\u0544\u0546\7"+
17489 		"S\2\2\u0545\u0543\3\2\2\2\u0545\u0544\3\2\2\2\u0546\u00cf\3\2\2\2\u0547"+
17490 		"\u0548\7I\2\2\u0548\u0549\5\u015e\u00b0\2\u0549\u00d1\3\2\2\2\u054a\u054c"+
17491 		"\5\u0156\u00ac\2\u054b\u054a\3\2\2\2\u054b\u054c\3\2\2\2\u054c\u054e\3"+
17492 		"\2\2\2\u054d\u054f\5\u0080A\2\u054e\u054d\3\2\2\2\u054e\u054f\3\2\2\2"+
17493 		"\u054f\u0550\3\2\2\2\u0550\u0551\5\u00d4k\2\u0551\u00d3\3\2\2\2\u0552"+
17494 		"\u0555\5\u00d6l\2\u0553\u0555\5\u00e6t\2\u0554\u0552\3\2\2\2\u0554\u0553"+
17495 		"\3\2\2\2\u0555\u00d5\3\2\2\2\u0556\u0558\7T\2\2\u0557\u0556\3\2\2\2\u0557"+
17496 		"\u0558\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u055a\7E\2\2\u055a\u055c\5\u00e2"+
17497 		"r\2\u055b\u055d\5b\62\2\u055c\u055b\3\2\2\2\u055c\u055d\3\2\2\2\u055d"+
17498 		"\u055f\3\2\2\2\u055e\u0560\5\u01ce\u00e8\2\u055f\u055e\3\2\2\2\u055f\u0560"+
17499 		"\3\2\2\2\u0560\u0561\3\2\2\2\u0561\u0563\7\20\2\2\u0562\u0564\5\u00d8"+
17500 		"m\2\u0563\u0562\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0565\3\2\2\2\u0565"+
17501 		"\u0566\7\21\2\2\u0566\u00d7\3\2\2\2\u0567\u0569\5\u00dan\2\u0568\u056a"+
17502 		"\5\u00d8m\2\u0569\u0568\3\2\2\2\u0569\u056a\3\2\2\2\u056a\u00d9\3\2\2"+
17503 		"\2\u056b\u0571\5x=\2\u056c\u056e\5\u00dco\2\u056d\u056f\7\3\2\2\u056e"+
17504 		"\u056d\3\2\2\2\u056e\u056f\3\2\2\2\u056f\u0571\3\2\2\2\u0570\u056b\3\2"+
17505 		"\2\2\u0570\u056c\3\2\2\2\u0571\u00db\3\2\2\2\u0572\u0574\5\u0156\u00ac"+
17506 		"\2\u0573\u0572\3\2\2\2\u0573\u0574\3\2\2\2\u0574\u0576\3\2\2\2\u0575\u0577"+
17507 		"\7T\2\2\u0576\u0575\3\2\2\2\u0576\u0577\3\2\2\2\u0577\u0578\3\2\2\2\u0578"+
17508 		"\u0579\7\b\2\2\u0579\u057a\5\u00dep\2\u057a\u00dd\3\2\2\2\u057b\u0580"+
17509 		"\5\u00e0q\2\u057c\u057d\7\22\2\2\u057d\u057f\5\u00e0q\2\u057e\u057c\3"+
17510 		"\2\2\2\u057f\u0582\3\2\2\2\u0580\u057e\3\2\2\2\u0580\u0581\3\2\2\2\u0581"+
17511 		"\u00df\3\2\2\2\u0582\u0580\3\2\2\2\u0583\u0585\5\u00e4s\2\u0584\u0586"+
17512 		"\5\u01bc\u00df\2\u0585\u0584\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u00e1\3"+
17513 		"\2\2\2\u0587\u0588\5\u01ec\u00f7\2\u0588\u00e3\3\2\2\2\u0589\u058a\5\u01ec"+
17514 		"\u00f7\2\u058a\u00e5\3\2\2\2\u058b\u058c\7E\2\2\u058c\u058e\5\u00e2r\2"+
17515 		"\u058d\u058f\5b\62\2\u058e\u058d\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0591"+
17516 		"\3\2\2\2\u0590\u0592\5\u01ce\u00e8\2\u0591\u0590\3\2\2\2\u0591\u0592\3"+
17517 		"\2\2\2\u0592\u0593\3\2\2\2\u0593\u0595\7\20\2\2\u0594\u0596\5\u00e8u\2"+
17518 		"\u0595\u0594\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0597\3\2\2\2\u0597\u0598"+
17519 		"\7\21\2\2\u0598\u00e7\3\2\2\2\u0599\u059b\5\u00eav\2\u059a\u059c\5\u00e8"+
17520 		"u\2\u059b\u059a\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u00e9\3\2\2\2\u059d"+
17521 		"\u05a0\5x=\2\u059e\u05a0\5\u00ecw\2\u059f\u059d\3\2\2\2\u059f\u059e\3"+
17522 		"\2\2\2\u05a0\u00eb\3\2\2\2\u05a1\u05a3\5\u0156\u00ac\2\u05a2\u05a1\3\2"+
17523 		"\2\2\u05a2\u05a3\3\2\2\2\u05a3\u05a4\3\2\2\2\u05a4\u05a5\7\b\2\2\u05a5"+
17524 		"\u05a6\5\u00eex\2\u05a6\u00ed\3\2\2\2\u05a7\u05ac\5\u00f0y\2\u05a8\u05a9"+
17525 		"\7\22\2\2\u05a9\u05ab\5\u00f0y\2\u05aa\u05a8\3\2\2\2\u05ab\u05ae\3\2\2"+
17526 		"\2\u05ac\u05aa\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u00ef\3\2\2\2\u05ae\u05ac"+
17527 		"\3\2\2\2\u05af\u05b1\5\u00e4s\2\u05b0\u05b2\5\u00f2z\2\u05b1\u05b0\3\2"+
17528 		"\2\2\u05b1\u05b2\3\2\2\2\u05b2\u00f1\3\2\2\2\u05b3\u05b4\7I\2\2\u05b4"+
17529 		"\u05b5\5\u01f6\u00fc\2\u05b5\u00f3\3\2\2\2\u05b6\u05b8\5\u0156\u00ac\2"+
17530 		"\u05b7\u05b6\3\2\2\2\u05b7\u05b8\3\2\2\2\u05b8\u05ba\3\2\2\2\u05b9\u05bb"+
17531 		"\5\u0080A\2\u05ba\u05b9\3\2\2\2\u05ba\u05bb\3\2\2\2\u05bb\u05bc\3\2\2"+
17532 		"\2\u05bc\u05bd\7D\2\2\u05bd\u05bf\5\u00f6|\2\u05be\u05c0\5b\62\2\u05bf"+
17533 		"\u05be\3\2\2\2\u05bf\u05c0\3\2\2\2\u05c0\u05c2\3\2\2\2\u05c1\u05c3\5\u01ce"+
17534 		"\u00e8\2\u05c2\u05c1\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4"+
17535 		"\u05c5\5\u00f8}\2\u05c5\u00f5\3\2\2\2\u05c6\u05c7\5\u01ec\u00f7\2\u05c7"+
17536 		"\u00f7\3\2\2\2\u05c8\u05ca\7\20\2\2\u05c9\u05cb\5z>\2\u05ca\u05c9\3\2"+
17537 		"\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05cc\3\2\2\2\u05cc\u05cd\7\21\2\2\u05cd"+
17538 		"\u00f9\3\2\2\2\u05ce\u05d0\5\u0156\u00ac\2\u05cf\u05ce\3\2\2\2\u05cf\u05d0"+
17539 		"\3\2\2\2\u05d0\u05d4\3\2\2\2\u05d1\u05d3\5~@\2\u05d2\u05d1\3\2\2\2\u05d3"+
17540 		"\u05d6\3\2\2\2\u05d4\u05d2\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d7\3\2"+
17541 		"\2\2\u05d6\u05d4\3\2\2\2\u05d7\u05d8\7,\2\2\u05d8\u05da\5\u00fc\177\2"+
17542 		"\u05d9\u05db\5b\62\2\u05da\u05d9\3\2\2\2\u05da\u05db\3\2\2\2\u05db\u05dd"+
17543 		"\3\2\2\2\u05dc\u05de\5\u01ce\u00e8\2\u05dd\u05dc\3\2\2\2\u05dd\u05de\3"+
17544 		"\2\2\2\u05de\u05df\3\2\2\2\u05df\u05e0\5\u00fe\u0080\2\u05e0\u00fb\3\2"+
17545 		"\2\2\u05e1\u05e2\5\u01ec\u00f7\2\u05e2\u00fd\3\2\2\2\u05e3\u05e5\7\20"+
17546 		"\2\2\u05e4\u05e6\5z>\2\u05e5\u05e4\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6\u05e7"+
17547 		"\3\2\2\2\u05e7\u05e8\7\21\2\2\u05e8\u00ff\3\2\2\2\u05e9\u05eb\5\u0156"+
17548 		"\u00ac\2\u05ea\u05e9\3\2\2\2\u05ea\u05eb\3\2\2\2\u05eb\u05ed\3\2\2\2\u05ec"+
17549 		"\u05ee\5\u0080A\2\u05ed\u05ec\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee\u05ef"+
17550 		"\3\2\2\2\u05ef\u05f0\7F\2\2\u05f0\u05f2\5\u0102\u0082\2\u05f1\u05f3\5"+
17551 		"\u01ce\u00e8\2\u05f2\u05f1\3\2\2\2\u05f2\u05f3\3\2\2\2\u05f3\u05f4\3\2"+
17552 		"\2\2\u05f4\u05f5\5\u0104\u0083\2\u05f5\u0101\3\2\2\2\u05f6\u05f7\5\u01ec"+
17553 		"\u00f7\2\u05f7\u0103\3\2\2\2\u05f8\u05fa\7\20\2\2\u05f9\u05fb\5\u0108"+
17554 		"\u0085\2\u05fa\u05f9\3\2\2\2\u05fa\u05fb\3\2\2\2\u05fb\u05fc\3\2\2\2\u05fc"+
17555 		"\u05fd\7\21\2\2\u05fd\u0105\3\2\2\2\u05fe\u0600\5\u010a\u0086\2\u05ff"+
17556 		"\u0601\7\3\2\2\u0600\u05ff\3\2\2\2\u0600\u0601\3\2\2\2\u0601\u0613\3\2"+
17557 		"\2\2\u0602\u0604\5\u010c\u0087\2\u0603\u0605\7\3\2\2\u0604\u0603\3\2\2"+
17558 		"\2\u0604\u0605\3\2\2\2\u0605\u0613\3\2\2\2\u0606\u0608\5\u010e\u0088\2"+
17559 		"\u0607\u0609\7\3\2\2\u0608\u0607\3\2\2\2\u0608\u0609\3\2\2\2\u0609\u0613"+
17560 		"\3\2\2\2\u060a\u060c\5\u0110\u0089\2\u060b\u060d\7\3\2\2\u060c\u060b\3"+
17561 		"\2\2\2\u060c\u060d\3\2\2\2\u060d\u0613\3\2\2\2\u060e\u0610\5\u0112\u008a"+
17562 		"\2\u060f\u0611\7\3\2\2\u0610\u060f\3\2\2\2\u0610\u0611\3\2\2\2\u0611\u0613"+
17563 		"\3\2\2\2\u0612\u05fe\3\2\2\2\u0612\u0602\3\2\2\2\u0612\u0606\3\2\2\2\u0612"+
17564 		"\u060a\3\2\2\2\u0612\u060e\3\2\2\2\u0613\u0107\3\2\2\2\u0614\u0616\5\u0106"+
17565 		"\u0084\2\u0615\u0617\5\u0108\u0085\2\u0616\u0615\3\2\2\2\u0616\u0617\3"+
17566 		"\2\2\2\u0617\u0109\3\2\2\2\u0618\u0619\5\u0098M\2\u0619\u061a\5\u009a"+
17567 		"N\2\u061a\u061b\5\u01b6\u00dc\2\u061b\u061c\5\u00a4S\2\u061c\u010b\3\2"+
17568 		"\2\2\u061d\u061e\5\u00ba^\2\u061e\u0620\5\u00bc_\2\u061f\u0621\5b\62\2"+
17569 		"\u0620\u061f\3\2\2\2\u0620\u0621\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0623"+
17570 		"\5\u00be`\2\u0623\u010d\3\2\2\2\u0624\u0626\5\u0116\u008c\2\u0625\u0627"+
17571 		"\5b\62\2\u0626\u0625\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0628\3\2\2\2\u0628"+
17572 		"\u062a\5\u00c6d\2\u0629\u062b\t\5\2\2\u062a\u0629\3\2\2\2\u062a\u062b"+
17573 		"\3\2\2\2\u062b\u010f\3\2\2\2\u062c\u062d\5\u0122\u0092\2\u062d\u062e\5"+
17574 		"\u0124\u0093\2\u062e\u062f\5\u00a4S\2\u062f\u0111\3\2\2\2\u0630\u0632"+
17575 		"\5\u00b2Z\2\u0631\u0633\5\u01ce\u00e8\2\u0632\u0631\3\2\2\2\u0632\u0633"+
17576 		"\3\2\2\2\u0633\u0635\3\2\2\2\u0634\u0636\5\u00b6\\\2\u0635\u0634\3\2\2"+
17577 		"\2\u0635\u0636\3\2\2\2\u0636\u0113\3\2\2\2\u0637\u0639\5\u0116\u008c\2"+
17578 		"\u0638\u063a\5b\62\2\u0639\u0638\3\2\2\2\u0639\u063a\3\2\2\2\u063a\u063b"+
17579 		"\3\2\2\2\u063b\u063d\5\u00c6d\2\u063c\u063e\t\5\2\2\u063d\u063c\3\2\2"+
17580 		"\2\u063d\u063e\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0640\5\u0118\u008d\2"+
17581 		"\u0640\u0115\3\2\2\2\u0641\u0643\5\u0156\u00ac\2\u0642\u0641\3\2\2\2\u0642"+
17582 		"\u0643\3\2\2\2\u0643\u0645\3\2\2\2\u0644\u0646\5|?\2\u0645\u0644\3\2\2"+
17583 		"\2\u0645\u0646\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0649\7U\2\2\u0648\u064a"+
17584 		"\t\6\2\2\u0649\u0648\3\2\2\2\u0649\u064a\3\2\2\2\u064a\u0117\3\2\2\2\u064b"+
17585 		"\u064c\5\u0084C\2\u064c\u0119\3\2\2\2\u064d\u064f\5\u0156\u00ac\2\u064e"+
17586 		"\u064d\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0650\3\2\2\2\u0650\u0651\7X"+
17587 		"\2\2\u0651\u0652\5\u0084C\2\u0652\u011b\3\2\2\2\u0653\u0655\5\u0156\u00ac"+
17588 		"\2\u0654\u0653\3\2\2\2\u0654\u0655\3\2\2\2\u0655\u0657\3\2\2\2\u0656\u0658"+
17589 		"\5\u0080A\2\u0657\u0656\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u0659\3\2\2"+
17590 		"\2\u0659\u065a\7Y\2\2\u065a\u065c\5\u01b8\u00dd\2\u065b\u065d\5h\65\2"+
17591 		"\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u065f\3\2\2\2\u065e\u0660"+
17592 		"\5\u01ce\u00e8\2\u065f\u065e\3\2\2\2\u065f\u0660\3\2\2\2\u0660\u0661\3"+
17593 		"\2\2\2\u0661\u0662\5\u011e\u0090\2\u0662\u011d\3\2\2\2\u0663\u0665\7\20"+
17594 		"\2\2\u0664\u0666\5z>\2\u0665\u0664\3\2\2\2\u0665\u0666\3\2\2\2\u0666\u0667"+
17595 		"\3\2\2\2\u0667\u0668\7\21\2\2\u0668\u011f\3\2\2\2\u0669\u066a\5\u0122"+
17596 		"\u0092\2\u066a\u066b\5\u0124\u0093\2\u066b\u066c\5\u009cO\2\u066c\u0676"+
17597 		"\3\2\2\2\u066d\u066e\5\u0122\u0092\2\u066e\u066f\5\u0124\u0093\2\u066f"+
17598 		"\u0670\5\u00a4S\2\u0670\u0676\3\2\2\2\u0671\u0672\5\u0122\u0092\2\u0672"+
17599 		"\u0673\5\u0124\u0093\2\u0673\u0674\5\u0084C\2\u0674\u0676\3\2\2\2\u0675"+
17600 		"\u0669\3\2\2\2\u0675\u066d\3\2\2\2\u0675\u0671\3\2\2\2\u0676\u0121\3\2"+
17601 		"\2\2\u0677\u0679\5\u0156\u00ac\2\u0678\u0677\3\2\2\2\u0678\u0679\3\2\2"+
17602 		"\2\u0679\u067b\3\2\2\2\u067a\u067c\5|?\2\u067b\u067a\3\2\2\2\u067b\u067c"+
17603 		"\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u067e\7Z\2\2\u067e\u067f\5\u00c6d\2"+
17604 		"\u067f\u0123\3\2\2\2\u0680\u0682\7O\2\2\u0681\u0683\5\u0156\u00ac\2\u0682"+
17605 		"\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0684\3\2\2\2\u0684\u0685\5\u01ac"+
17606 		"\u00d7\2\u0685\u0125\3\2\2\2\u0686\u068a\5\u0128\u0095\2\u0687\u068a\5"+
17607 		"\u012a\u0096\2\u0688\u068a\5\u012c\u0097\2\u0689\u0686\3\2\2\2\u0689\u0687"+
17608 		"\3\2\2\2\u0689\u0688\3\2\2\2\u068a\u0127\3\2\2\2\u068b\u068c\7\67\2\2"+
17609 		"\u068c\u068d\7[\2\2\u068d\u068e\5\u01a4\u00d3\2\u068e\u068f\7\20\2\2\u068f"+
17610 		"\u0690\7\21\2\2\u0690\u0129\3\2\2\2\u0691\u0692\7\66\2\2\u0692\u0693\7"+
17611 		"[\2\2\u0693\u0694\5\u01a4\u00d3\2\u0694\u0695\7\20\2\2\u0695\u0696\7\21"+
17612 		"\2\2\u0696\u012b\3\2\2\2\u0697\u0698\7\60\2\2\u0698\u0699\7[\2\2\u0699"+
17613 		"\u069a\5\u01a4\u00d3\2\u069a\u069b\7\20\2\2\u069b\u069c\5\u012e\u0098"+
17614 		"\2\u069c\u069d\7\21\2\2\u069d\u012d\3\2\2\2\u069e\u06a0\5\u0130\u0099"+
17615 		"\2\u069f\u069e\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0\u06a2\3\2\2\2\u06a1\u06a3"+
17616 		"\5\u0134\u009b\2\u06a2\u06a1\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06ab\3"+
17617 		"\2\2\2\u06a4\u06a6\5\u0134\u009b\2\u06a5\u06a4\3\2\2\2\u06a5\u06a6\3\2"+
17618 		"\2\2\u06a6\u06a8\3\2\2\2\u06a7\u06a9\5\u0130\u0099\2\u06a8\u06a7\3\2\2"+
17619 		"\2\u06a8\u06a9\3\2\2\2\u06a9\u06ab\3\2\2\2\u06aa\u069f\3\2\2\2\u06aa\u06a5"+
17620 		"\3\2\2\2\u06ab\u012f\3\2\2\2\u06ac\u06ad\7\\\2\2\u06ad\u06ae\5\u0132\u009a"+
17621 		"\2\u06ae\u0131\3\2\2\2\u06af\u06b0\5\u01fa\u00fe\2\u06b0\u0133\3\2\2\2"+
17622 		"\u06b1\u06b2\7]\2\2\u06b2\u06b3\5\u0136\u009c\2\u06b3\u0135\3\2\2\2\u06b4"+
17623 		"\u06b5\t\7\2\2\u06b5\u0137\3\2\2\2\u06b6\u06b7\b\u009d\1\2\u06b7\u06b9"+
17624 		"\5\u013a\u009e\2\u06b8\u06ba\5\u01b6\u00dc\2\u06b9\u06b8\3\2\2\2\u06b9"+
17625 		"\u06ba\3\2\2\2\u06ba\u06c9\3\2\2\2\u06bb\u06bd\5\u013c\u009f\2\u06bc\u06be"+
17626 		"\5\u01b6\u00dc\2\u06bd\u06bc\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u06c9\3"+
17627 		"\2\2\2\u06bf\u06c9\5\u013e\u00a0\2\u06c0\u06c2\5\u0140\u00a1\2\u06c1\u06c3"+
17628 		"\5\u01b6\u00dc\2\u06c2\u06c1\3\2\2\2\u06c2\u06c3\3\2\2\2\u06c3\u06c9\3"+
17629 		"\2\2\2\u06c4\u06c9\5\u0146\u00a4\2\u06c5\u06c6\7a\2\2\u06c6\u06c9\5\u01ac"+
17630 		"\u00d7\2\u06c7\u06c9\5\u014e\u00a8\2\u06c8\u06b6\3\2\2\2\u06c8\u06bb\3"+
17631 		"\2\2\2\u06c8\u06bf\3\2\2\2\u06c8\u06c0\3\2\2\2\u06c8\u06c4\3\2\2\2\u06c8"+
17632 		"\u06c5\3\2\2\2\u06c8\u06c7\3\2\2\2\u06c9\u06cf\3\2\2\2\u06ca\u06cb\f\4"+
17633 		"\2\2\u06cb\u06cc\7b\2\2\u06cc\u06ce\5\u01ac\u00d7\2\u06cd\u06ca\3\2\2"+
17634 		"\2\u06ce\u06d1\3\2\2\2\u06cf\u06cd\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u0139"+
17635 		"\3\2\2\2\u06d1\u06cf\3\2\2\2\u06d2\u06d3\7S\2\2\u06d3\u013b\3\2\2\2\u06d4"+
17636 		"\u06d5\5\u01ec\u00f7\2\u06d5\u013d\3\2\2\2\u06d6\u06d7\7\35\2\2\u06d7"+
17637 		"\u06db\5\u0138\u009d\2\u06d8\u06d9\7\34\2\2\u06d9\u06db\5\u0138\u009d"+
17638 		"\2\u06da\u06d6\3\2\2\2\u06da\u06d8\3\2\2\2\u06db\u013f\3\2\2\2\u06dc\u06de"+
17639 		"\7\6\2\2\u06dd\u06df\5\u0142\u00a2\2\u06de\u06dd\3\2\2\2\u06de\u06df\3"+
17640 		"\2\2\2\u06df\u06e0\3\2\2\2\u06e0\u06e1\7\7\2\2\u06e1\u0141\3\2\2\2\u06e2"+
17641 		"\u06e7\5\u0144\u00a3\2\u06e3\u06e4\7\22\2\2\u06e4\u06e6\5\u0144\u00a3"+
17642 		"\2\u06e5\u06e3\3\2\2\2\u06e6\u06e9\3\2\2\2\u06e7\u06e5\3\2\2\2\u06e7\u06e8"+
17643 		"\3\2\2\2\u06e8\u0143\3\2\2\2\u06e9\u06e7\3\2\2\2\u06ea\u06eb\5\u0138\u009d"+
17644 		"\2\u06eb\u0145\3\2\2\2\u06ec\u06ee\5\u01b8\u00dd\2\u06ed\u06ec\3\2\2\2"+
17645 		"\u06ed\u06ee\3\2\2\2\u06ee\u06f0\3\2\2\2\u06ef\u06f1\7H\2\2\u06f0\u06ef"+
17646 		"\3\2\2\2\u06f0\u06f1\3\2\2\2\u06f1\u06f2\3\2\2\2\u06f2\u06f4\5\u00e4s"+
17647 		"\2\u06f3\u06f5\5\u0140\u00a1\2\u06f4\u06f3\3\2\2\2\u06f4\u06f5\3\2\2\2"+
17648 		"\u06f5\u0147\3\2\2\2\u06f6\u06f9\5\u014a\u00a6\2\u06f7\u06f9\5\u014c\u00a7"+
17649 		"\2\u06f8\u06f6\3\2\2\2\u06f8\u06f7\3\2\2\2\u06f9\u0149\3\2\2\2\u06fa\u06fb"+
17650 		"\7a\2\2\u06fb\u06fc\5\u01ac\u00d7\2\u06fc\u014b\3\2\2\2\u06fd\u06fe\5"+
17651 		"\u0138\u009d\2\u06fe\u06ff\7b\2\2\u06ff\u0700\5\u01ac\u00d7\2\u0700\u014d"+
17652 		"\3\2\2\2\u0701\u0702\5\u015e\u00b0\2\u0702\u014f\3\2\2\2\u0703\u0704\7"+
17653 		"c\2\2\u0704\u0706\5\u0152\u00aa\2\u0705\u0707\5\u0154\u00ab\2\u0706\u0705"+
17654 		"\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u0151\3\2\2\2\u0708\u0709\5\u01ec\u00f7"+
17655 		"\2\u0709\u0153\3\2\2\2\u070a\u070c\7\6\2\2\u070b\u070d\5\u0158\u00ad\2"+
17656 		"\u070c\u070b\3\2\2\2\u070c\u070d\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u070f"+
17657 		"\7\7\2\2\u070f\u0155\3\2\2\2\u0710\u0712\5\u0150\u00a9\2\u0711\u0710\3"+
17658 		"\2\2\2\u0712\u0713\3\2\2\2\u0713\u0711\3\2\2\2\u0713\u0714\3\2\2\2\u0714"+
17659 		"\u0157\3\2\2\2\u0715\u0717\5\u015a\u00ae\2\u0716\u0718\5\u0158\u00ad\2"+
17660 		"\u0717\u0716\3\2\2\2\u0717\u0718\3\2\2\2\u0718\u0159\3\2\2\2\u0719\u071b"+
17661 		"\7\6\2\2\u071a\u071c\5\u0158\u00ad\2\u071b\u071a\3\2\2\2\u071b\u071c\3"+
17662 		"\2\2\2\u071c\u071d\3\2\2\2\u071d\u0739\7\7\2\2\u071e\u0720\7d\2\2\u071f"+
17663 		"\u0721\5\u0158\u00ad\2\u0720\u071f\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0722"+
17664 		"\3\2\2\2\u0722\u0739\7e\2\2\u0723\u0725\7\20\2\2\u0724\u0726\5\u0158\u00ad"+
17665 		"\2\u0725\u0724\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u0727\3\2\2\2\u0727\u0739"+
17666 		"\7\21\2\2\u0728\u0739\5\u01ec\u00f7\2\u0729\u0739\5\u015e\u00b0\2\u072a"+
17667 		"\u0739\5\u01f0\u00f9\2\u072b\u0739\5\u01f6\u00fc\2\u072c\u0739\5\u01a4"+
17668 		"\u00d3\2\u072d\u0739\7\4\2\2\u072e\u0739\7\3\2\2\u072f\u0739\7\22\2\2"+
17669 		"\u0730\u0739\7W\2\2\u0731\u0739\7)\2\2\u0732\u0739\7*\2\2\u0733\u0739"+
17670 		"\7f\2\2\u0734\u0739\7g\2\2\u0735\u0739\7h\2\2\u0736\u0739\7P\2\2\u0737"+
17671 		"\u0739\7i\2\2\u0738\u0719\3\2\2\2\u0738\u071e\3\2\2\2\u0738\u0723\3\2"+
17672 		"\2\2\u0738\u0728\3\2\2\2\u0738\u0729\3\2\2\2\u0738\u072a\3\2\2\2\u0738"+
17673 		"\u072b\3\2\2\2\u0738\u072c\3\2\2\2\u0738\u072d\3\2\2\2\u0738\u072e\3\2"+
17674 		"\2\2\u0738\u072f\3\2\2\2\u0738\u0730\3\2\2\2\u0738\u0731\3\2\2\2\u0738"+
17675 		"\u0732\3\2\2\2\u0738\u0733\3\2\2\2\u0738\u0734\3\2\2\2\u0738\u0735\3\2"+
17676 		"\2\2\u0738\u0736\3\2\2\2\u0738\u0737\3\2\2\2\u0739\u015b\3\2\2\2\u073a"+
17677 		"\u073f\5\u015e\u00b0\2\u073b\u073c\7\22\2\2\u073c\u073e\5\u015e\u00b0"+
17678 		"\2\u073d\u073b\3\2\2\2\u073e\u0741\3\2\2\2\u073f\u073d\3\2\2\2\u073f\u0740"+
17679 		"\3\2\2\2\u0740\u015d\3\2\2\2\u0741\u073f\3\2\2\2\u0742\u0744\5\u0164\u00b3"+
17680 		"\2\u0743\u0742\3\2\2\2\u0743\u0744\3\2\2\2\u0744\u0745\3\2\2\2\u0745\u0749"+
17681 		"\5\u0160\u00b1\2\u0746\u0748\5\u0166\u00b4\2\u0747\u0746\3\2\2\2\u0748"+
17682 		"\u074b\3\2\2\2\u0749\u0747\3\2\2\2\u0749\u074a\3\2\2\2\u074a\u015f\3\2"+
17683 		"\2\2\u074b\u0749\3\2\2\2\u074c\u074e\5\u01a8\u00d5\2\u074d\u074c\3\2\2"+
17684 		"\2\u074d\u074e\3\2\2\2\u074e\u074f\3\2\2\2\u074f\u0751\5\u019e\u00d0\2"+
17685 		"\u0750\u0752\7\3\2\2\u0751\u0750\3\2\2\2\u0751\u0752\3\2\2\2\u0752\u0755"+
17686 		"\3\2\2\2\u0753\u0755\5\u0162\u00b2\2\u0754\u074d\3\2\2\2\u0754\u0753\3"+
17687 		"\2\2\2\u0755\u0161\3\2\2\2\u0756\u0757\7j\2\2\u0757\u0758\5\u01ec\u00f7"+
17688 		"\2\u0758\u0163\3\2\2\2\u0759\u075b\7k\2\2\u075a\u075c\t\6\2\2\u075b\u075a"+
17689 		"\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u0165\3\2\2\2\u075d\u075e\5\u01a6\u00d4"+
17690 		"\2\u075e\u075f\5\u0160\u00b1\2\u075f\u076e\3\2\2\2\u0760\u0762\5\u0168"+
17691 		"\u00b5\2\u0761\u0763\5\u0164\u00b3\2\u0762\u0761\3\2\2\2\u0762\u0763\3"+
17692 		"\2\2\2\u0763\u0764\3\2\2\2\u0764\u0765\5\u0160\u00b1\2\u0765\u076e\3\2"+
17693 		"\2\2\u0766\u0768\5\u016a\u00b6\2\u0767\u0769\5\u0164\u00b3\2\u0768\u0767"+
17694 		"\3\2\2\2\u0768\u0769\3\2\2\2\u0769\u076a\3\2\2\2\u076a\u076b\5\u0160\u00b1"+
17695 		"\2\u076b\u076e\3\2\2\2\u076c\u076e\5\u016c\u00b7\2\u076d\u075d\3\2\2\2"+
17696 		"\u076d\u0760\3\2\2\2\u076d\u0766\3\2\2\2\u076d\u076c\3\2\2\2\u076e\u0167"+
17697 		"\3\2\2\2\u076f\u0770\7I\2\2\u0770\u0169\3\2\2\2\u0771\u0773\7V\2\2\u0772"+
17698 		"\u0774\5\u0164\u00b3\2\u0773\u0772\3\2\2\2\u0773\u0774\3\2\2\2\u0774\u0775"+
17699 		"\3\2\2\2\u0775\u0776\5\u015e\u00b0\2\u0776\u0777\7\4\2\2\u0777\u016b\3"+
17700 		"\2\2\2\u0778\u0779\7a\2\2\u0779\u0783\5\u01ac\u00d7\2\u077a\u077b\7b\2"+
17701 		"\2\u077b\u077c\7V\2\2\u077c\u0783\5\u01ac\u00d7\2\u077d\u077e\7b\2\2\u077e"+
17702 		"\u0783\5\u01ac\u00d7\2\u077f\u0780\7b\2\2\u0780\u0781\7W\2\2\u0781\u0783"+
17703 		"\5\u01ac\u00d7\2\u0782\u0778\3\2\2\2\u0782\u077a\3\2\2\2\u0782\u077d\3"+
17704 		"\2\2\2\u0782\u077f\3\2\2\2\u0783\u016d\3\2\2\2\u0784\u0787\5\u01ec\u00f7"+
17705 		"\2\u0785\u0787\5\u01a4\u00d3\2\u0786\u0784\3\2\2\2\u0786\u0785\3\2\2\2"+
17706 		"\u0787\u0789\3\2\2\2\u0788\u078a\5r:\2\u0789\u0788\3\2\2\2\u0789\u078a"+
17707 		"\3\2\2\2\u078a\u0793\3\2\2\2\u078b\u0793\5\u0170\u00b9\2\u078c\u0793\5"+
17708 		"\u017e\u00c0\2\u078d\u0793\5\u0180\u00c1\2\u078e\u0793\5\u0188\u00c5\2"+
17709 		"\u078f\u0793\5\u0196\u00cc\2\u0790\u0793\5\u0194\u00cb\2\u0791\u0793\5"+
17710 		"\u019c\u00cf\2\u0792\u0786\3\2\2\2\u0792\u078b\3\2\2\2\u0792\u078c\3\2"+
17711 		"\2\2\u0792\u078d\3\2\2\2\u0792\u078e\3\2\2\2\u0792\u078f\3\2\2\2\u0792"+
17712 		"\u0790\3\2\2\2\u0792\u0791\3\2\2\2\u0793\u016f\3\2\2\2\u0794\u079c\5\u01f6"+
17713 		"\u00fc\2\u0795\u079c\5\u0172\u00ba\2\u0796\u079c\5\u0178\u00bd\2\u0797"+
17714 		"\u079c\7l\2\2\u0798\u079c\7m\2\2\u0799\u079c\7n\2\2\u079a\u079c\7o\2\2"+
17715 		"\u079b\u0794\3\2\2\2\u079b\u0795\3\2\2\2\u079b\u0796\3\2\2\2\u079b\u0797"+
17716 		"\3\2\2\2\u079b\u0798\3\2\2\2\u079b\u0799\3\2\2\2\u079b\u079a\3\2\2\2\u079c"+
17717 		"\u0171\3\2\2\2\u079d\u079f\7d\2\2\u079e\u07a0\5\u0174\u00bb\2\u079f\u079e"+
17718 		"\3\2\2\2\u079f\u07a0\3\2\2\2\u07a0\u07a1\3\2\2\2\u07a1\u07a2\7e\2\2\u07a2"+
17719 		"\u0173\3\2\2\2\u07a3\u07a8\5\u0176\u00bc\2\u07a4\u07a5\7\22\2\2\u07a5"+
17720 		"\u07a7\5\u0176\u00bc\2\u07a6\u07a4\3\2\2\2\u07a7\u07aa\3\2\2\2\u07a8\u07a6"+
17721 		"\3\2\2\2\u07a8\u07a9\3\2\2\2\u07a9\u07ac\3\2\2\2\u07aa\u07a8\3\2\2\2\u07ab"+
17722 		"\u07ad\7\22\2\2\u07ac\u07ab\3\2\2\2\u07ac\u07ad\3\2\2\2\u07ad\u0175\3"+
17723 		"\2\2\2\u07ae\u07af\5\u015e\u00b0\2\u07af\u0177\3\2\2\2\u07b0\u07b1\7d"+
17724 		"\2\2\u07b1\u07b2\5\u017a\u00be\2\u07b2\u07b3\7e\2\2\u07b3\u07b8\3\2\2"+
17725 		"\2\u07b4\u07b5\7d\2\2\u07b5\u07b6\7\4\2\2\u07b6\u07b8\7e\2\2\u07b7\u07b0"+
17726 		"\3\2\2\2\u07b7\u07b4\3\2\2\2\u07b8\u0179\3\2\2\2\u07b9\u07be\5\u017c\u00bf"+
17727 		"\2\u07ba\u07bb\7\22\2\2\u07bb\u07bd\5\u017c\u00bf\2\u07bc\u07ba\3\2\2"+
17728 		"\2\u07bd\u07c0\3\2\2\2\u07be\u07bc\3\2\2\2\u07be\u07bf\3\2\2\2\u07bf\u07c2"+
17729 		"\3\2\2\2\u07c0\u07be\3\2\2\2\u07c1\u07c3\7\22\2\2\u07c2\u07c1\3\2\2\2"+
17730 		"\u07c2\u07c3\3\2\2\2\u07c3\u017b\3\2\2\2\u07c4\u07c5\5\u015e\u00b0\2\u07c5"+
17731 		"\u07c6\7\4\2\2\u07c6\u07c7\5\u015e\u00b0\2\u07c7\u017d\3\2\2\2\u07c8\u07d5"+
17732 		"\7p\2\2\u07c9\u07ca\7p\2\2\u07ca\u07cb\7H\2\2\u07cb\u07d5\5\u01ec\u00f7"+
17733 		"\2\u07cc\u07cd\7p\2\2\u07cd\u07ce\7d\2\2\u07ce\u07cf\5\u015c\u00af\2\u07cf"+
17734 		"\u07d0\7e\2\2\u07d0\u07d5\3\2\2\2\u07d1\u07d2\7p\2\2\u07d2\u07d3\7H\2"+
17735 		"\2\u07d3\u07d5\7U\2\2\u07d4\u07c8\3\2\2\2\u07d4\u07c9\3\2\2\2\u07d4\u07cc"+
17736 		"\3\2\2\2\u07d4\u07d1\3\2\2\2\u07d5\u017f\3\2\2\2\u07d6\u07da\5\u0182\u00c2"+
17737 		"\2\u07d7\u07da\5\u0184\u00c3\2\u07d8\u07da\5\u0186\u00c4\2\u07d9\u07d6"+
17738 		"\3\2\2\2\u07d9\u07d7\3\2\2\2\u07d9\u07d8\3\2\2\2\u07da\u0181\3\2\2\2\u07db"+
17739 		"\u07dc\7q\2\2\u07dc\u07dd\7H\2\2\u07dd\u07de\5\u01ec\u00f7\2\u07de\u0183"+
17740 		"\3\2\2\2\u07df\u07e0\7q\2\2\u07e0\u07e1\7d\2\2\u07e1\u07e2\5\u015c\u00af"+
17741 		"\2\u07e2\u07e3\7e\2\2\u07e3\u0185\3\2\2\2\u07e4\u07e5\7q\2\2\u07e5\u07e6"+
17742 		"\7H\2\2\u07e6\u07e7\7U\2\2\u07e7\u0187\3\2\2\2\u07e8\u07ea\7\20\2\2\u07e9"+
17743 		"\u07eb\5\u018a\u00c6\2\u07ea\u07e9\3\2\2\2\u07ea\u07eb\3\2\2\2\u07eb\u07ed"+
17744 		"\3\2\2\2\u07ec\u07ee\5\6\4\2\u07ed\u07ec\3\2\2\2\u07ed\u07ee\3\2\2\2\u07ee"+
17745 		"\u07ef\3\2\2\2\u07ef\u07f0\7\21\2\2\u07f0\u0189\3\2\2\2\u07f1\u07f3\5"+
17746 		"\u00c6d\2\u07f2\u07f4\5\u00c0a\2\u07f3\u07f2\3\2\2\2\u07f3\u07f4\3\2\2"+
17747 		"\2\u07f4\u07f5\3\2\2\2\u07f5\u07f6\7\t\2\2\u07f6\u080f\3\2\2\2\u07f7\u07f9"+
17748 		"\5\u01f2\u00fa\2\u07f8\u07fa\5\u00c0a\2\u07f9\u07f8\3\2\2\2\u07f9\u07fa"+
17749 		"\3\2\2\2\u07fa\u07fb\3\2\2\2\u07fb\u07fc\7\t\2\2\u07fc\u080f\3\2\2\2\u07fd"+
17750 		"\u07fe\5\u018c\u00c7\2\u07fe\u0800\5\u00c6d\2\u07ff\u0801\5\u00c0a\2\u0800"+
17751 		"\u07ff\3\2\2\2\u0800\u0801\3\2\2\2\u0801\u0802\3\2\2\2\u0802\u0803\7\t"+
17752 		"\2\2\u0803\u080f\3\2\2\2\u0804\u0805\5\u018c\u00c7\2\u0805\u0807\5\u01f2"+
17753 		"\u00fa\2\u0806\u0808\5\u00c0a\2\u0807\u0806\3\2\2\2\u0807\u0808\3\2\2"+
17754 		"\2\u0808\u0809\3\2\2\2\u0809\u080a\7\t\2\2\u080a\u080f\3\2\2\2\u080b\u080c"+
17755 		"\5\u018c\u00c7\2\u080c\u080d\7\t\2\2\u080d\u080f\3\2\2\2\u080e\u07f1\3"+
17756 		"\2\2\2\u080e\u07f7\3\2\2\2\u080e\u07fd\3\2\2\2\u080e\u0804\3\2\2\2\u080e"+
17757 		"\u080b\3\2\2\2\u080f\u018b\3\2\2\2\u0810\u0811\7d\2\2\u0811\u0812\5\u018e"+
17758 		"\u00c8\2\u0812\u0813\7e\2\2\u0813\u018d\3\2\2\2\u0814\u0817\5\u0190\u00c9"+
17759 		"\2\u0815\u0816\7\22\2\2\u0816\u0818\5\u0190\u00c9\2\u0817\u0815\3\2\2"+
17760 		"\2\u0817\u0818\3\2\2\2\u0818\u018f\3\2\2\2\u0819\u081b\5\u0192\u00ca\2"+
17761 		"\u081a\u0819\3\2\2\2\u081a\u081b\3\2\2\2\u081b\u081c\3\2\2\2\u081c\u081d"+
17762 		"\5\u015e\u00b0\2\u081d\u0191\3\2\2\2\u081e\u081f\t\b\2\2\u081f\u0193\3"+
17763 		"\2\2\2\u0820\u0821\7H\2\2\u0821\u0822\5\u01ec\u00f7\2\u0822\u0195\3\2"+
17764 		"\2\2\u0823\u0825\7\6\2\2\u0824\u0826\5\u0198\u00cd\2\u0825\u0824\3\2\2"+
17765 		"\2\u0825\u0826\3\2\2\2\u0826\u0827\3\2\2\2\u0827\u0828\7\7\2\2\u0828\u0197"+
17766 		"\3\2\2\2\u0829\u082e\5\u019a\u00ce\2\u082a\u082b\7\22\2\2\u082b\u082d"+
17767 		"\5\u019a\u00ce\2\u082c\u082a\3\2\2\2\u082d\u0830\3\2\2\2\u082e\u082c\3"+
17768 		"\2\2\2\u082e\u082f\3\2\2\2\u082f\u0199\3\2\2\2\u0830\u082e\3\2\2\2\u0831"+
17769 		"\u0837\5\u015e\u00b0\2\u0832\u0833\5\u01ec\u00f7\2\u0833\u0834\7\4\2\2"+
17770 		"\u0834\u0835\5\u015e\u00b0\2\u0835\u0837\3\2\2\2\u0836\u0831\3\2\2\2\u0836"+
17771 		"\u0832\3\2\2\2\u0837\u019b\3\2\2\2\u0838\u0839\7S\2\2\u0839\u019d\3\2"+
17772 		"\2\2\u083a\u083b\b\u00d0\1\2\u083b\u083c\5\u016e\u00b8\2\u083c\u0863\3"+
17773 		"\2\2\2\u083d\u083e\f\r\2\2\u083e\u0862\5\u01aa\u00d6\2\u083f\u0841\f\f"+
17774 		"\2\2\u0840\u0842\5\u0196\u00cc\2\u0841\u0840\3\2\2\2\u0841\u0842\3\2\2"+
17775 		"\2\u0842\u0843\3\2\2\2\u0843\u0862\5\u0188\u00c5\2\u0844\u0845\f\13\2"+
17776 		"\2\u0845\u0862\5\u0196\u00cc\2\u0846\u0847\f\n\2\2\u0847\u0848\7H\2\2"+
17777 		"\u0848\u0862\7U\2\2\u0849\u084a\f\t\2\2\u084a\u084b\7H\2\2\u084b\u0862"+
17778 		"\7\u008f\2\2\u084c\u084d\f\b\2\2\u084d\u084e\7H\2\2\u084e\u0850\5\u01ec"+
17779 		"\u00f7\2\u084f\u0851\5r:\2\u0850\u084f\3\2\2\2\u0850\u0851\3\2\2\2\u0851"+
17780 		"\u0862\3\2\2\2\u0852\u0853\f\7\2\2\u0853\u0854\7H\2\2\u0854\u0862\7p\2"+
17781 		"\2\u0855\u0856\f\6\2\2\u0856\u0857\7H\2\2\u0857\u0862\7t\2\2\u0858\u0859"+
17782 		"\f\5\2\2\u0859\u085a\7d\2\2\u085a\u085b\5\u015c\u00af\2\u085b\u085c\7"+
17783 		"e\2\2\u085c\u0862\3\2\2\2\u085d\u085e\f\4\2\2\u085e\u0862\7W\2\2\u085f"+
17784 		"\u0860\f\3\2\2\u0860\u0862\7V\2\2\u0861\u083d\3\2\2\2\u0861\u083f\3\2"+
17785 		"\2\2\u0861\u0844\3\2\2\2\u0861\u0846\3\2\2\2\u0861\u0849\3\2\2\2\u0861"+
17786 		"\u084c\3\2\2\2\u0861\u0852\3\2\2\2\u0861\u0855\3\2\2\2\u0861\u0858\3\2"+
17787 		"\2\2\u0861\u085d\3\2\2\2\u0861\u085f\3\2\2\2\u0862\u0865\3\2\2\2\u0863"+
17788 		"\u0861\3\2\2\2\u0863\u0864\3\2\2\2\u0864\u019f\3\2\2\2\u0865\u0863\3\2"+
17789 		"\2\2\u0866\u0867\t\t\2\2\u0867\u01a1\3\2\2\2\u0868\u086b\5\u01a0\u00d1"+
17790 		"\2\u0869\u086b\7\u0089\2\2\u086a\u0868\3\2\2\2\u086a\u0869\3\2\2\2\u086b"+
17791 		"\u01a3\3\2\2\2\u086c\u0870\5\u01a0\u00d1\2\u086d\u086f\5\u01a2\u00d2\2"+
17792 		"\u086e\u086d\3\2\2\2\u086f\u0872\3\2\2\2\u0870\u086e\3\2\2\2\u0870\u0871"+
17793 		"\3\2\2\2\u0871\u087c\3\2\2\2\u0872\u0870\3\2\2\2\u0873\u0877\7\u008a\2"+
17794 		"\2\u0874\u0876\5\u01a2\u00d2\2\u0875\u0874\3\2\2\2\u0876\u0879\3\2\2\2"+
17795 		"\u0877\u0875\3\2\2\2\u0877\u0878\3\2\2\2\u0878\u087c\3\2\2\2\u0879\u0877"+
17796 		"\3\2\2\2\u087a\u087c\7P\2\2\u087b\u086c\3\2\2\2\u087b\u0873\3\2\2\2\u087b"+
17797 		"\u087a\3\2\2\2\u087c\u01a5\3\2\2\2\u087d\u087e\5\u01a4\u00d3\2\u087e\u01a7"+
17798 		"\3\2\2\2\u087f\u0880\5\u01a4\u00d3\2\u0880\u01a9\3\2\2\2\u0881\u0882\5"+
17799 		"\u01a4\u00d3\2\u0882\u01ab\3\2\2\2\u0883\u0884\b\u00d7\1\2\u0884\u088a"+
17800 		"\5\u01ae\u00d8\2\u0885\u088a\5\u01b0\u00d9\2\u0886\u088a\5\u01b8\u00dd"+
17801 		"\2\u0887\u088a\5\u01bc\u00df\2\u0888\u088a\5\u01c6\u00e4\2\u0889\u0883"+
17802 		"\3\2\2\2\u0889\u0885\3\2\2\2\u0889\u0886\3\2\2\2\u0889\u0887\3\2\2\2\u0889"+
17803 		"\u0888\3\2\2\2\u088a\u08a1\3\2\2\2\u088b\u088d\f\13\2\2\u088c\u088e\7"+
17804 		"M\2\2\u088d\u088c\3\2\2\2\u088d\u088e\3\2\2\2\u088e\u088f\3\2\2\2\u088f"+
17805 		"\u0890\7O\2\2\u0890\u08a0\5\u01ac\u00d7\f\u0891\u0892\f\n\2\2\u0892\u0893"+
17806 		"\7N\2\2\u0893\u0894\7O\2\2\u0894\u08a0\5\u01ac\u00d7\13\u0895\u0896\f"+
17807 		"\7\2\2\u0896\u08a0\7V\2\2\u0897\u0898\f\6\2\2\u0898\u08a0\7W\2\2\u0899"+
17808 		"\u089a\f\4\2\2\u089a\u089b\7H\2\2\u089b\u08a0\7w\2\2\u089c\u089d\f\3\2"+
17809 		"\2\u089d\u089e\7H\2\2\u089e\u08a0\7x\2\2\u089f\u088b\3\2\2\2\u089f\u0891"+
17810 		"\3\2\2\2\u089f\u0895\3\2\2\2\u089f\u0897\3\2\2\2\u089f\u0899\3\2\2\2\u089f"+
17811 		"\u089c\3\2\2\2\u08a0\u08a3\3\2\2\2\u08a1\u089f\3\2\2\2\u08a1\u08a2\3\2"+
17812 		"\2\2\u08a2\u01ad\3\2\2\2\u08a3\u08a1\3\2\2\2\u08a4\u08a5\7d\2\2\u08a5"+
17813 		"\u08a6\5\u01ac\u00d7\2\u08a6\u08a7\7e\2\2\u08a7\u01af\3\2\2\2\u08a8\u08a9"+
17814 		"\7d\2\2\u08a9\u08aa\5\u01ac\u00d7\2\u08aa\u08ab\7\4\2\2\u08ab\u08ac\5"+
17815 		"\u01ac\u00d7\2\u08ac\u08ad\7e\2\2\u08ad\u01b1\3\2\2\2\u08ae\u08af\5\u01ac"+
17816 		"\u00d7\2\u08af\u08b0\7V\2\2\u08b0\u01b3\3\2\2\2\u08b1\u08b2\5\u01ac\u00d7"+
17817 		"\2\u08b2\u08b3\7W\2\2\u08b3\u01b5\3\2\2\2\u08b4\u08b6\7\4\2\2\u08b5\u08b7"+
17818 		"\5\u0156\u00ac\2\u08b6\u08b5\3\2\2\2\u08b6\u08b7\3\2\2\2\u08b7\u08b8\3"+
17819 		"\2\2\2\u08b8\u08b9\5\u01ac\u00d7\2\u08b9\u01b7\3\2\2\2\u08ba\u08bc\5\u01ba"+
17820 		"\u00de\2\u08bb\u08bd\5r:\2\u08bc\u08bb\3\2\2\2\u08bc\u08bd\3\2\2\2\u08bd"+
17821 		"\u08c7\3\2\2\2\u08be\u08c0\5\u01ba\u00de\2\u08bf\u08c1\5r:\2\u08c0\u08bf"+
17822 		"\3\2\2\2\u08c0\u08c1\3\2\2\2\u08c1\u08c2\3\2\2\2\u08c2\u08c3\7H\2\2\u08c3"+
17823 		"\u08c4\5\u01b8\u00dd\2\u08c4\u08c7\3\2\2\2\u08c5\u08c7\7y\2\2\u08c6\u08ba"+
17824 		"\3\2\2\2\u08c6\u08be\3\2\2\2\u08c6\u08c5\3\2\2\2\u08c7\u01b9\3\2\2\2\u08c8"+
17825 		"\u08c9\5\u01ec\u00f7\2\u08c9\u01bb\3\2\2\2\u08ca\u08cc\7\6\2\2\u08cb\u08cd"+
17826 		"\5\u01be\u00e0\2\u08cc\u08cb\3\2\2\2\u08cc\u08cd\3\2\2\2\u08cd\u08ce\3"+
17827 		"\2\2\2\u08ce\u08cf\7\7\2\2\u08cf\u01bd\3\2\2\2\u08d0\u08d2\5\u01c0\u00e1"+
17828 		"\2\u08d1\u08d3\7P\2\2\u08d2\u08d1\3\2\2\2\u08d2\u08d3\3\2\2\2\u08d3\u01bf"+
17829 		"\3\2\2\2\u08d4\u08da\5\u01c2\u00e2\2\u08d5\u08d6\5\u01c2\u00e2\2\u08d6"+
17830 		"\u08d7\7\22\2\2\u08d7\u08d8\5\u01c0\u00e1\2\u08d8\u08da\3\2\2\2\u08d9"+
17831 		"\u08d4\3\2\2\2\u08d9\u08d5\3\2\2\2\u08da\u01c1\3\2\2\2\u08db\u08dd\5\u0156"+
17832 		"\u00ac\2\u08dc\u08db\3\2\2\2\u08dc\u08dd\3\2\2\2\u08dd\u08df\3\2\2\2\u08de"+
17833 		"\u08e0\7Q\2\2\u08df\u08de\3\2\2\2\u08df\u08e0\3\2\2\2\u08e0\u08e1\3\2"+
17834 		"\2\2\u08e1\u08e9\5\u01ac\u00d7\2\u08e2\u08e4\7Q\2\2\u08e3\u08e2\3\2\2"+
17835 		"\2\u08e3\u08e4\3\2\2\2\u08e4\u08e5\3\2\2\2\u08e5\u08e6\5\u01c4\u00e3\2"+
17836 		"\u08e6\u08e7\5\u01b6\u00dc\2\u08e7\u08e9\3\2\2\2\u08e8\u08dc\3\2\2\2\u08e8"+
17837 		"\u08e3\3\2\2\2\u08e9\u01c3\3\2\2\2\u08ea\u08eb\5\u01ec\u00f7\2\u08eb\u01c5"+
17838 		"\3\2\2\2\u08ec\u08ed\7F\2\2\u08ed\u08ef\7)\2\2\u08ee\u08f0\5\u01c8\u00e5"+
17839 		"\2\u08ef\u08ee\3\2\2\2\u08ef\u08f0\3\2\2\2\u08f0\u08f1\3\2\2\2\u08f1\u08f2"+
17840 		"\7*\2\2\u08f2\u01c7\3\2\2\2\u08f3\u08f9\5\u01ca\u00e6\2\u08f4\u08f5\5"+
17841 		"\u01ca\u00e6\2\u08f5\u08f6\7\22\2\2\u08f6\u08f7\5\u01c8\u00e5\2\u08f7"+
17842 		"\u08f9\3\2\2\2\u08f8\u08f3\3\2\2\2\u08f8\u08f4\3\2\2\2\u08f9\u01c9\3\2"+
17843 		"\2\2\u08fa\u08fb\5\u01b8\u00dd\2\u08fb\u01cb\3\2\2\2\u08fc\u08fd\5\u01ac"+
17844 		"\u00d7\2\u08fd\u08fe\7H\2\2\u08fe\u08ff\7w\2\2\u08ff\u0905\3\2\2\2\u0900"+
17845 		"\u0901\5\u01ac\u00d7\2\u0901\u0902\7H\2\2\u0902\u0903\7x\2\2\u0903\u0905"+
17846 		"\3\2\2\2\u0904\u08fc\3\2\2\2\u0904\u0900\3\2\2\2\u0905\u01cd\3\2\2\2\u0906"+
17847 		"\u0907\7\4\2\2\u0907\u0908\5\u01d2\u00ea\2\u0908\u0909\7\22\2\2\u0909"+
17848 		"\u090a\5\u01d0\u00e9\2\u090a\u0910\3\2\2\2\u090b\u090c\7\4\2\2\u090c\u0910"+
17849 		"\5\u01d2\u00ea\2\u090d\u090e\7\4\2\2\u090e\u0910\5\u01d0\u00e9\2\u090f"+
17850 		"\u0906\3\2\2\2\u090f\u090b\3\2\2\2\u090f\u090d\3\2\2\2\u0910\u01cf\3\2"+
17851 		"\2\2\u0911\u0916\5\u01b8\u00dd\2\u0912\u0913\7\22\2\2\u0913\u0915\5\u01b8"+
17852 		"\u00dd\2\u0914\u0912\3\2\2\2\u0915\u0918\3\2\2\2\u0916\u0914\3\2\2\2\u0916"+
17853 		"\u0917\3\2\2\2\u0917\u01d1\3\2\2\2\u0918\u0916\3\2\2\2\u0919\u091a\7,"+
17854 		"\2\2\u091a\u01d3\3\2\2\2\u091b\u091e\5\u01d6\u00ec\2\u091c\u091e\5\u01e6"+
17855 		"\u00f4\2\u091d\u091b\3\2\2\2\u091d\u091c\3\2\2\2\u091e\u01d5\3\2\2\2\u091f"+
17856 		"\u0920\7z\2\2\u0920\u0922\5\u01de\u00f0\2\u0921\u0923\5\6\4\2\u0922\u0921"+
17857 		"\3\2\2\2\u0922\u0923\3\2\2\2\u0923\u0925\3\2\2\2\u0924\u0926\5\u01d8\u00ed"+
17858 		"\2\u0925\u0924\3\2\2\2\u0925\u0926\3\2\2\2\u0926\u0928\3\2\2\2\u0927\u0929"+
17859 		"\5\u01dc\u00ef\2\u0928\u0927\3\2\2\2\u0928\u0929\3\2\2\2\u0929\u092a\3"+
17860 		"\2\2\2\u092a\u092b\7{\2\2\u092b\u01d7\3\2\2\2\u092c\u092e\5\u01da\u00ee"+
17861 		"\2\u092d\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u092d\3\2\2\2\u092f\u0930"+
17862 		"\3\2\2\2\u0930\u01d9\3\2\2\2\u0931\u0932\7|\2\2\u0932\u0934\5\u01de\u00f0"+
17863 		"\2\u0933\u0935\5\6\4\2\u0934\u0933\3\2\2\2\u0934\u0935\3\2\2\2\u0935\u01db"+
17864 		"\3\2\2\2\u0936\u0938\7}\2\2\u0937\u0939\5\6\4\2\u0938\u0937\3\2\2\2\u0938"+
17865 		"\u0939\3\2\2\2\u0939\u01dd\3\2\2\2\u093a\u093b\b\u00f0\1\2\u093b\u093c"+
17866 		"\7W\2\2\u093c\u0945\5\u01de\u00f0\4\u093d\u0945\5\u01e0\u00f1\2\u093e"+
17867 		"\u0945\5\u01ec\u00f7\2\u093f\u0945\5\u01f4\u00fb\2\u0940\u0941\7\6\2\2"+
17868 		"\u0941\u0942\5\u01de\u00f0\2\u0942\u0943\7\7\2\2\u0943\u0945\3\2\2\2\u0944"+
17869 		"\u093a\3\2\2\2\u0944\u093d\3\2\2\2\u0944\u093e\3\2\2\2\u0944\u093f\3\2"+
17870 		"\2\2\u0944\u0940\3\2\2\2\u0945\u094b\3\2\2\2\u0946\u0947\f\3\2\2\u0947"+
17871 		"\u0948\t\n\2\2\u0948\u094a\5\u01de\u00f0\4\u0949\u0946\3\2\2\2\u094a\u094d"+
17872 		"\3\2\2\2\u094b\u0949\3\2\2\2\u094b\u094c\3\2\2\2\u094c\u01df\3\2\2\2\u094d"+
17873 		"\u094b\3\2\2\2\u094e\u094f\7~\2\2\u094f\u0950\7\6\2\2\u0950\u0951\5\u01e2"+
17874 		"\u00f2\2\u0951\u0952\7\7\2\2\u0952\u0959\3\2\2\2\u0953\u0954\7\177\2\2"+
17875 		"\u0954\u0955\7\6\2\2\u0955\u0956\5\u01e4\u00f3\2\u0956\u0957\7\7\2\2\u0957"+
17876 		"\u0959\3\2\2\2\u0958\u094e\3\2\2\2\u0958\u0953\3\2\2\2\u0959\u01e1\3\2"+
17877 		"\2\2\u095a\u095b\t\13\2\2\u095b\u01e3\3\2\2\2\u095c\u095d\t\f\2\2\u095d"+
17878 		"\u01e5\3\2\2\2\u095e\u0962\7\u0084\2\2\u095f\u0960\5\u01e8\u00f5\2\u0960"+
17879 		"\u0961\5\u01ea\u00f6\2\u0961\u0963\3\2\2\2\u0962\u095f\3\2\2\2\u0962\u0963"+
17880 		"\3\2\2\2\u0963\u01e7\3\2\2\2\u0964\u0965\5\u01fa\u00fe\2\u0965\u01e9\3"+
17881 		"\2\2\2\u0966\u0967\7\u0093\2\2\u0967\u01eb\3\2\2\2\u0968\u096b\7\u008b"+
17882 		"\2\2\u0969\u096b\5\u01f0\u00f9\2\u096a\u0968\3\2\2\2\u096a\u0969\3\2\2"+
17883 		"\2\u096b\u01ed\3\2\2\2\u096c\u096d\t\r\2\2\u096d\u01ef\3\2\2\2\u096e\u096f"+
17884 		"\t\16\2\2\u096f\u01f1\3\2\2\2\u0970\u0973\5\u01ec\u00f7\2\u0971\u0973"+
17885 		"\7S\2\2\u0972\u0970\3\2\2\2\u0972\u0971\3\2\2\2\u0973\u097b\3\2\2\2\u0974"+
17886 		"\u0977\7\22\2\2\u0975\u0978\5\u01ec\u00f7\2\u0976\u0978\7S\2\2\u0977\u0975"+
17887 		"\3\2\2\2\u0977\u0976\3\2\2\2\u0978\u097a\3\2\2\2\u0979\u0974\3\2\2\2\u097a"+
17888 		"\u097d\3\2\2\2\u097b\u0979\3\2\2\2\u097b\u097c\3\2\2\2\u097c\u01f3\3\2"+
17889 		"\2\2\u097d\u097b\3\2\2\2\u097e\u097f\7\u0086\2\2\u097f\u01f5\3\2\2\2\u0980"+
17890 		"\u0985\5\u01f8\u00fd\2\u0981\u0985\7\u0093\2\2\u0982\u0985\7\u0086\2\2"+
17891 		"\u0983\u0985\7\u0087\2\2\u0984\u0980\3\2\2\2\u0984\u0981\3\2\2\2\u0984"+
17892 		"\u0982\3\2\2\2\u0984\u0983\3\2\2\2\u0985\u01f7\3\2\2\2\u0986\u0988\7f"+
17893 		"\2\2\u0987\u0986\3\2\2\2\u0987\u0988\3\2\2\2\u0988\u0989\3\2\2\2\u0989"+
17894 		"\u098f\5\u01fa\u00fe\2\u098a\u098c\7f\2\2\u098b\u098a\3\2\2\2\u098b\u098c"+
17895 		"\3\2\2\2\u098c\u098d\3\2\2\2\u098d\u098f\7\u0091\2\2\u098e\u0987\3\2\2"+
17896 		"\2\u098e\u098b\3\2\2\2\u098f\u01f9\3\2\2\2\u0990\u0991\t\17\2\2\u0991"+
17897 		"\u01fb\3\2\2\2\u013a\u01fe\u0200\u0207\u020b\u020f\u0214\u0218\u021c\u0220"+
17898 		"\u0224\u0226\u022b\u0231\u0235\u0239\u023d\u0243\u0247\u024b\u024f\u0253"+
17899 		"\u0257\u025d\u026d\u0273\u0279\u0284\u028a\u0298\u02a3\u02a8\u02b3\u02bf"+
17900 		"\u02c3\u02c7\u02cd\u02d8\u02dc\u02e0\u02e3\u02f1\u02f8\u02fe\u0304\u0309"+
17901 		"\u030c\u0316\u031d\u0324\u0335\u033c\u0345\u034e\u035a\u0364\u0369\u0373"+
17902 		"\u0382\u0389\u038d\u0391\u0395\u0399\u039d\u03a1\u03a5\u03a9\u03ad\u03b1"+
17903 		"\u03b5\u03b9\u03bd\u03c1\u03c3\u03c7\u03cb\u03e6\u03f7\u03fb\u03ff\u0404"+
17904 		"\u0408\u0413\u0417\u041a\u041d\u0427\u042c\u0444\u0450\u0453\u0456\u045f"+
17905 		"\u0468\u046b\u0471\u0475\u0480\u0489\u048c\u0491\u0498\u049f\u04a3\u04a6"+
17906 		"\u04aa\u04af\u04b3\u04bb\u04be\u04cb\u04d3\u04d7\u04da\u04dd\u04e3\u04e7"+
17907 		"\u04ea\u04ee\u04f6\u04fd\u0501\u0508\u050c\u050f\u0512\u0515\u0518\u051c"+
17908 		"\u051f\u0522\u0526\u0529\u052d\u0530\u0533\u0537\u053d\u0541\u0545\u054b"+
17909 		"\u054e\u0554\u0557\u055c\u055f\u0563\u0569\u056e\u0570\u0573\u0576\u0580"+
17910 		"\u0585\u058e\u0591\u0595\u059b\u059f\u05a2\u05ac\u05b1\u05b7\u05ba\u05bf"+
17911 		"\u05c2\u05ca\u05cf\u05d4\u05da\u05dd\u05e5\u05ea\u05ed\u05f2\u05fa\u0600"+
17912 		"\u0604\u0608\u060c\u0610\u0612\u0616\u0620\u0626\u062a\u0632\u0635\u0639"+
17913 		"\u063d\u0642\u0645\u0649\u064e\u0654\u0657\u065c\u065f\u0665\u0675\u0678"+
17914 		"\u067b\u0682\u0689\u069f\u06a2\u06a5\u06a8\u06aa\u06b9\u06bd\u06c2\u06c8"+
17915 		"\u06cf\u06da\u06de\u06e7\u06ed\u06f0\u06f4\u06f8\u0706\u070c\u0713\u0717"+
17916 		"\u071b\u0720\u0725\u0738\u073f\u0743\u0749\u074d\u0751\u0754\u075b\u0762"+
17917 		"\u0768\u076d\u0773\u0782\u0786\u0789\u0792\u079b\u079f\u07a8\u07ac\u07b7"+
17918 		"\u07be\u07c2\u07d4\u07d9\u07ea\u07ed\u07f3\u07f9\u0800\u0807\u080e\u0817"+
17919 		"\u081a\u0825\u082e\u0836\u0841\u0850\u0861\u0863\u086a\u0870\u0877\u087b"+
17920 		"\u0889\u088d\u089f\u08a1\u08b6\u08bc\u08c0\u08c6\u08cc\u08d2\u08d9\u08dc"+
17921 		"\u08df\u08e3\u08e8\u08ef\u08f8\u0904\u090f\u0916\u091d\u0922\u0925\u0928"+
17922 		"\u092f\u0934\u0938\u0944\u094b\u0958\u0962\u096a\u0972\u0977\u097b\u0984"+
17923 		"\u0987\u098b\u098e";
17924 	public static final ATN _ATN =
17925 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
17926 	static {
17927 		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
17928 		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
17929 			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
17930 		}
17931 	}
17932 }