1
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
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 }